/stream-chain

name: stream-chain
description: Stream-JSON chaining for multi-agent pipelines, data transformation, and sequential workflows
version: 1.0.0
category: workflow
tags: [streaming, pipeline, chaining, multi-agent, workflow]

Stream-Chain Skill

Execute sophisticated multi-step workflows where each agent's output flows into the next, enabling complex data transformations and sequential processing pipelines.

Overview

Stream-Chain provides two powerful modes for orchestrating multi-agent workflows:

1. **Custom Chains** (`run`): Execute custom prompt sequences with full control 2. **Predefined Pipelines** (`pipeline`): Use battle-tested workflows for common tasks

Each step in a chain receives the complete output from the previous step, enabling sophisticated multi-agent coordination through streaming data flow.

---

Quick Start

Run a Custom Chain

claude-flow stream-chain run \
  "Analyze codebase structure" \
  "Identify improvement areas" \
  "Generate action plan"

Execute a Pipeline

claude-flow stream-chain pipeline analysis

---

Custom Chains (`run`)

Execute custom stream chains with your own prompts for maximum flexibility.

Syntax

claude-flow stream-chain run <prompt1> <prompt2> [...] [options]

**Requirements:**

• Minimum 2 prompts required
• Each prompt becomes a step in the chain
• Output flows sequentially through all steps

Options

| Option | Description | Default | |--------|-------------|---------| | `--verbose` | Show detailed execution information | `false` | | `--timeout <seconds>` | Timeout per step | `30` | | `--debug` | Enable debug mode with full logging | `false` |

How Context Flows

Each step receives the previous output as context:

Step 1: "Write a sorting function"
Output: [function implementation]

Step 2 receives:
  "Previous step output:
  [function implementation]

  Next task: Add comprehensive tests"

Step 3 receives:
  "Previous steps output:
  [function + tests]

  Next task: Optimize performance"

Examples

Basic Development Chain

claude-flow stream-chain run \
  "Write a user authentication function" \
  "Add input validation and error handling" \
  "Create unit tests with edge cases"

Security Audit Workflow

claude-flow stream-chain run \
  "Analyze authentication system for vulnerabilities" \
  "Identify and categorize security issues by severity" \
  "Propose fixes with implementation priority" \
  "Generate security test cases" \
  --timeout 45 \
  --verbose

Code Refactoring Chain

claude-flow stream-chain run \
  "Identify code smells in src/ directory" \
  "Create refactoring plan with specific changes" \
  "Apply refactoring to top 3 priority items" \
  "Verify refactored code maintains behavior" \
  --debug

Data Processing Pipeline

claude-flow stream-chain run \
  "Extract data from API responses" \
  "Transform data into normalized format" \
  "Validate data against schema" \
  "Generate data quality report"

---

Predefined Pipelines (`pipeline`)

Execute battle-tested workflows optimized for common development tasks.

Syntax

claude-flow stream-chain pipeline <type> [options]

Available Pipelines

1. Analysis Pipeline

Comprehensive codebase analysis and improvement identification.

claude-flow stream-chain pipeline analysis

**Workflow Steps:** 1. **Structure Analysis**: Map directory structure and identify components 2. **Issue Detection**: Find potential improvements and problems 3. **Recommendations**: Generate actionable improvement report

**Use Cases:**

• New codebase onboarding
• Technical debt assessment
• Architecture review
• Code quality audits

2. Refactor Pipeline

Systematic code refactoring with prioritization.

claude-flow stream-chain pipeline refactor

**Workflow Steps:** 1. **Candidate Identification**: Find code needing refactoring 2. **Prioritization**: Create ranked refactoring plan 3. **Implementation**: Provide refactored code for top priorities

**Use Cases:**

• Technical debt reduction
• Code quality improvement
• Legacy code modernization
• Design pattern implementation

3. Test Pipeline

Comprehensive test generation with coverage analysis.

claude-flow stream-chain pipeline test

**Workflow Steps:** 1. **Coverage Analysis**: Identify areas lacking tests 2. **Test Design**: Create test cases for critical functions 3. **Implementation**: Generate unit tests with assertions

**Use Cases:**

• Increasing test coverage
• TDD workflow support
• Regression test creation
• Quality assurance

4. Optimize Pipeline

Performance optimization with profiling and implementation.

claude-flow stream-chain pipeline optimize

**Workflow Steps:** 1. **Profiling**: Identify performance bottlenecks 2. **Strategy**: Analyze and suggest optimization approaches 3. **Implementation**: Provide optimized code

**Use Cases:**

• Performance improvement
• Resource optimization
• Scalability enhancement
• Latency reduction

Pipeline Options

| Option | Description | Default | |--------|-------------|---------| | `--verbose` | Show detailed execution | `false` | | `--timeout <seconds>` | Timeout per step | `30` | | `--debug` | Enable debug mode | `false` |

Pipeline Examples

Quick Analysis

claude-flow stream-chain pipeline analysis

Extended Refactoring

claude-flow stream-chain pipeline refactor --timeout 60 --verbose

Debug Test Generation

claude-flow stream-chain pipeline test --debug

Comprehensive Optimization

claude-flow stream-chain pipeline optimize --timeout 90 --verbose

Pipeline Output

Each pipeline execution provides:

• **Progress**: Step-by-step execution status
• **Results**: Success/failure per step
• **Timing**: Total and per-step execution time
• **Summary**: Consolidated results and recommen