stream-chain
Stream-JSON chaining for multi-agent pipelines, data transformation, and sequential workflows
#workflow
Install
npx skills add https://github.com/spencermarx/open-code-review/tree/main/.claude/skills/stream-chain
claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install spencermarx-open-code-review@llmmart
git clone https://github.com/spencermarx/open-code-review.git
The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole spencermarx/open-code-review collection as a plugin from our marketplace. Git is the plain clone.
Skill manifest
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:
- Custom Chains (
run): Execute custom prompt sequences with full control - 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:
- Structure Analysis: Map directory structure and identify components
- Issue Detection: Find potential improvements and problems
- 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:
- Candidate Identification: Find code needing refactoring
- Prioritization: Create ranked refactoring plan
- 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:
- Coverage Analysis: Identify areas lacking tests
- Test Design: Create test cases for critical functions
- 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:
- Profiling: Identify performance bottlenecks
- Strategy: Analyze and suggest optimization approaches
- 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 recommendations
Custom Pipeline Definitions
Define reusable pipelines in .claude-flow/config.json:
Configuration Format
{
"streamChain": {
"pipelines": {
"security": {
"name": "Security Audit Pipeline",
"description": "Comprehensive security analysis",
"prompts": [
"Scan codebase for security vulnerabilities",
"Categorize issues by severity (critical/high/medium/low)",
"Generate fixes with priority and implementation steps",
"Create security test suite"
],
"timeout": 45
},
"documentation": {
"name": "Documentation Generation Pipeline",
"prompts": [
"Analyze code structure and identify undocumented areas",
"Generate API documentation with examples",
"Create usage guides and tutorials",
"Build architecture diagrams and flow charts"
]
}
}
}
}
Execute Custom Pipeline
claude-flow stream-chain pipeline security
claude-flow stream-chain pipeline documentation
Advanced Use Cases
Multi-Agent Coordination
Chain different agent types for complex workflows:
claude-flow stream-chain run \
"Research best practices for API design" \
"Design REST API with discovered patterns" \
"Implement API endpoints with validation" \
"Generate OpenAPI specification" \
"Create integration tests" \
"Write deployment documentation"
Data Transformation Pipeline
Process and transform data through multiple stages:
claude-flow stream-chain run \
"Extract user data from CSV files" \
"Normalize and validate data format" \
"Enrich data with external API calls" \
"Generate analytics report" \
"Create visualization code"
Code Migration Workflow
Systematic code migration with validation:
claude-flow stream-chain run \
"Analyze legacy codebase dependencies" \
"Create migration plan with risk assessment" \
"Generate modernized code for high-priority modules" \
"Create migration tests" \
"Document migration steps and rollback procedures"
Quality Assurance Chain
Comprehensive code quality workflow:
claude-flow stream-chain pipeline analysis
claude-flow stream-chain pipeline refactor
claude-flow stream-chain pipeline test
claude-flow stream-chain pipeline optimize
Best Practices
1. Clear and Specific Prompts
Good:
"Analyze authentication.js for SQL injection vulnerabilities"
Avoid:
"Check security"
2. Logical Progression
Order prompts to build on previous outputs:
1. "Identify the problem"
2. "Analyze root causes"
3. "Design solution"
4. "Implement solution"
5. "Verify implementation"
3. Appropriate Timeouts
- Simple tasks: 30 seconds (default)
- Analysis tasks: 45-60 seconds
- Implementation tasks: 60-90 seconds
- Complex workflows: 90-120 seconds
4. Verification Steps
Include validation in your chains:
claude-flow stream-chain run \
"Implement feature X" \
"Write tests for feature X" \
"Verify tests pass and cover edge cases"
5. Iterative Refinement
Use chains for iterative improvement:
claude-flow stream-chain run \
"Generate initial implementation" \
"Review and identify issues" \
"Refine based on issues found" \
"Final quality check"
Integration with Claude Flow
Combine with Swarm Coordination
# Initialize swarm for coordination
claude-flow swarm init --topology mesh
# Execute stream chain with swarm agents
claude-flow stream-chain run \
"Agent 1: Research task" \
"Agent 2: Implement solution" \
"Agent 3: Test implementation" \
"Agent 4: Review and refine"
Memory Integration
Stream chains automatically store context in memory for cross-session persistence:
# Execute chain with memory
claude-flow stream-chain run \
"Analyze requirements" \
"Design architecture" \
--verbose
# Results stored in .claude-flow/memory/stream-chain/
Neural Pattern Training
Successful chains train neural patterns for improved performance:
# Enable neural training
claude-flow stream-chain pipeline optimize --debug
# Patterns learned and stored for future optimizations
Troubleshooting
Chain Timeout
If steps timeout, increase timeout value:
claude-flow stream-chain run "complex task" --timeout 120
Context Loss
If context not flowing properly, use --debug:
claude-flow stream-chain run "step 1" "step 2" --debug
Pipeline Not Found
Verify pipeline name and custom definitions:
# Check available pipelines
cat .claude-flow/config.json | grep -A 10 "streamChain"
Performance Characteristics
- Throughput: 2-5 steps per minute (varies by complexity)
- Context Size: Up to 100K tokens per step
- Memory Usage: ~50MB per active chain
- Concurrency: Supports parallel chain execution
Related Skills
- SPARC Methodology: Systematic development workflow
- Swarm Coordination: Multi-agent orchestration
- Memory Management: Persistent context storage
- Neural Patterns: Adaptive learning
Examples Repository
Complete Development Workflow
# Full feature development chain
claude-flow stream-chain run \
"Analyze requirements for user profile feature" \
"Design database schema and API endpoints" \
"Implement backend with validation" \
"Create frontend components" \
"Write comprehensive tests" \
"Generate API documentation" \
--timeout 60 \
--verbose
Code Review Pipeline
# Automated code review workflow
claude-flow stream-chain run \
"Analyze recent git changes" \
"Identify code quality issues" \
"Check for security vulnerabilities" \
"Verify test coverage" \
"Generate code review report with recommendations"
Migration Assistant
# Framework migration helper
claude-flow stream-chain run \
"Analyze current Vue 2 codebase" \
"Identify Vue 3 breaking changes" \
"Create migration checklist" \
"Generate migration scripts" \
"Provide updated code examples"
Conclusion
Stream-Chain enables sophisticated multi-step workflows by:
- Sequential Processing: Each step builds on previous results
- Context Preservation: Full output history flows through chain
- Flexible Orchestration: Custom chains or predefined pipelines
- Agent Coordination: Natural multi-agent collaboration pattern
- Data Transformation: Complex processing through simple steps
Use run for custom workflows and pipeline for battle-tested solutions.
Files (open-code-review)
-
SKILL.md 12.4 KB
--- 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 ```bash claude-flow stream-chain run \ "Analyze codebase structure" \ "Identify improvement areas" \ "Generate action plan" ``` ### Execute a Pipeline ```bash claude-flow stream-chain pipeline analysis ``` --- ## Custom Chains (`run`) Execute custom stream chains with your own prompts for maximum flexibility. ### Syntax ```bash 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 ```bash 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 ```bash 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 ```bash 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 ```bash 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 ```bash claude-flow stream-chain pipeline <type> [options] ``` ### Available Pipelines #### 1. Analysis Pipeline Comprehensive codebase analysis and improvement identification. ```bash 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. ```bash 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. ```bash 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. ```bash 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 ```bash claude-flow stream-chain pipeline analysis ``` #### Extended Refactoring ```bash claude-flow stream-chain pipeline refactor --timeout 60 --verbose ``` #### Debug Test Generation ```bash claude-flow stream-chain pipeline test --debug ``` #### Comprehensive Optimization ```bash 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 recommendations --- ## Custom Pipeline Definitions Define reusable pipelines in `.claude-flow/config.json`: ### Configuration Format ```json { "streamChain": { "pipelines": { "security": { "name": "Security Audit Pipeline", "description": "Comprehensive security analysis", "prompts": [ "Scan codebase for security vulnerabilities", "Categorize issues by severity (critical/high/medium/low)", "Generate fixes with priority and implementation steps", "Create security test suite" ], "timeout": 45 }, "documentation": { "name": "Documentation Generation Pipeline", "prompts": [ "Analyze code structure and identify undocumented areas", "Generate API documentation with examples", "Create usage guides and tutorials", "Build architecture diagrams and flow charts" ] } } } } ``` ### Execute Custom Pipeline ```bash claude-flow stream-chain pipeline security claude-flow stream-chain pipeline documentation ``` --- ## Advanced Use Cases ### Multi-Agent Coordination Chain different agent types for complex workflows: ```bash claude-flow stream-chain run \ "Research best practices for API design" \ "Design REST API with discovered patterns" \ "Implement API endpoints with validation" \ "Generate OpenAPI specification" \ "Create integration tests" \ "Write deployment documentation" ``` ### Data Transformation Pipeline Process and transform data through multiple stages: ```bash claude-flow stream-chain run \ "Extract user data from CSV files" \ "Normalize and validate data format" \ "Enrich data with external API calls" \ "Generate analytics report" \ "Create visualization code" ``` ### Code Migration Workflow Systematic code migration with validation: ```bash claude-flow stream-chain run \ "Analyze legacy codebase dependencies" \ "Create migration plan with risk assessment" \ "Generate modernized code for high-priority modules" \ "Create migration tests" \ "Document migration steps and rollback procedures" ``` ### Quality Assurance Chain Comprehensive code quality workflow: ```bash claude-flow stream-chain pipeline analysis claude-flow stream-chain pipeline refactor claude-flow stream-chain pipeline test claude-flow stream-chain pipeline optimize ``` --- ## Best Practices ### 1. Clear and Specific Prompts **Good:** ```bash "Analyze authentication.js for SQL injection vulnerabilities" ``` **Avoid:** ```bash "Check security" ``` ### 2. Logical Progression Order prompts to build on previous outputs: ```bash 1. "Identify the problem" 2. "Analyze root causes" 3. "Design solution" 4. "Implement solution" 5. "Verify implementation" ``` ### 3. Appropriate Timeouts - Simple tasks: 30 seconds (default) - Analysis tasks: 45-60 seconds - Implementation tasks: 60-90 seconds - Complex workflows: 90-120 seconds ### 4. Verification Steps Include validation in your chains: ```bash claude-flow stream-chain run \ "Implement feature X" \ "Write tests for feature X" \ "Verify tests pass and cover edge cases" ``` ### 5. Iterative Refinement Use chains for iterative improvement: ```bash claude-flow stream-chain run \ "Generate initial implementation" \ "Review and identify issues" \ "Refine based on issues found" \ "Final quality check" ``` --- ## Integration with Claude Flow ### Combine with Swarm Coordination ```bash # Initialize swarm for coordination claude-flow swarm init --topology mesh # Execute stream chain with swarm agents claude-flow stream-chain run \ "Agent 1: Research task" \ "Agent 2: Implement solution" \ "Agent 3: Test implementation" \ "Agent 4: Review and refine" ``` ### Memory Integration Stream chains automatically store context in memory for cross-session persistence: ```bash # Execute chain with memory claude-flow stream-chain run \ "Analyze requirements" \ "Design architecture" \ --verbose # Results stored in .claude-flow/memory/stream-chain/ ``` ### Neural Pattern Training Successful chains train neural patterns for improved performance: ```bash # Enable neural training claude-flow stream-chain pipeline optimize --debug # Patterns learned and stored for future optimizations ``` --- ## Troubleshooting ### Chain Timeout If steps timeout, increase timeout value: ```bash claude-flow stream-chain run "complex task" --timeout 120 ``` ### Context Loss If context not flowing properly, use `--debug`: ```bash claude-flow stream-chain run "step 1" "step 2" --debug ``` ### Pipeline Not Found Verify pipeline name and custom definitions: ```bash # Check available pipelines cat .claude-flow/config.json | grep -A 10 "streamChain" ``` --- ## Performance Characteristics - **Throughput**: 2-5 steps per minute (varies by complexity) - **Context Size**: Up to 100K tokens per step - **Memory Usage**: ~50MB per active chain - **Concurrency**: Supports parallel chain execution --- ## Related Skills - **SPARC Methodology**: Systematic development workflow - **Swarm Coordination**: Multi-agent orchestration - **Memory Management**: Persistent context storage - **Neural Patterns**: Adaptive learning --- ## Examples Repository ### Complete Development Workflow ```bash # Full feature development chain claude-flow stream-chain run \ "Analyze requirements for user profile feature" \ "Design database schema and API endpoints" \ "Implement backend with validation" \ "Create frontend components" \ "Write comprehensive tests" \ "Generate API documentation" \ --timeout 60 \ --verbose ``` ### Code Review Pipeline ```bash # Automated code review workflow claude-flow stream-chain run \ "Analyze recent git changes" \ "Identify code quality issues" \ "Check for security vulnerabilities" \ "Verify test coverage" \ "Generate code review report with recommendations" ``` ### Migration Assistant ```bash # Framework migration helper claude-flow stream-chain run \ "Analyze current Vue 2 codebase" \ "Identify Vue 3 breaking changes" \ "Create migration checklist" \ "Generate migration scripts" \ "Provide updated code examples" ``` --- ## Conclusion Stream-Chain enables sophisticated multi-step workflows by: - **Sequential Processing**: Each step builds on previous results - **Context Preservation**: Full output history flows through chain - **Flexible Orchestration**: Custom chains or predefined pipelines - **Agent Coordination**: Natural multi-agent collaboration pattern - **Data Transformation**: Complex processing through simple steps Use `run` for custom workflows and `pipeline` for battle-tested solutions.
Comments (0)
Sign in to join the conversation.
Reviews (0)
No reviews yet.
No comments yet.