claude-flow-novice 2.10.4 → 2.10.6

package/claude-assets/commands/sparc/sparc-modes.md

@@ -0,0 +1,174 @@
+# SPARC Modes Overview
+
+SPARC (Specification, Planning, Architecture, Review, Code) is a comprehensive development methodology with 17 specialized modes, all integrated with MCP tools for enhanced coordination and execution.
+
+## Available Modes
+
+### Core Orchestration Modes
+- **orchestrator**: Multi-agent task orchestration
+- **swarm-coordinator**: Specialized swarm management
+- **workflow-manager**: Process automation
+- **batch-executor**: Parallel task execution
+
+### Development Modes  
+- **coder**: Autonomous code generation
+- **architect**: System design
+- **reviewer**: Code review
+- **tdd**: Test-driven development
+
+### Analysis and Research Modes
+- **researcher**: Deep research capabilities
+- **analyzer**: Code and data analysis
+- **optimizer**: Performance optimization
+
+### Creative and Support Modes
+- **designer**: UI/UX design
+- **innovator**: Creative problem solving
+- **documenter**: Documentation generation
+- **debugger**: Systematic debugging
+- **tester**: Comprehensive testing
+- **memory-manager**: Knowledge management
+
+## Usage
+
+### Option 1: Using MCP Tools (Preferred in Claude Code)
+```javascript
+// Execute SPARC mode directly
+mcp__claude-flow__sparc_mode {
+  mode: "<mode>",
+  task_description: "<task>",
+  options: {
+    // mode-specific options
+  }
+}
+
+// Initialize swarm for advanced coordination
+mcp__claude-flow__swarm_init {
+  topology: "hierarchical",
+  strategy: "auto",
+  maxAgents: 8
+}
+
+// Spawn specialized agents
+mcp__claude-flow__agent_spawn {
+  type: "<agent-type>",
+  capabilities: ["<capability1>", "<capability2>"]
+}
+
+// Monitor execution
+mcp__claude-flow__swarm_monitor {
+  swarmId: "current",
+  interval: 5000
+}
+```
+
+### Option 2: Using NPX CLI (Fallback when MCP not available)
+```bash
+# Use when running from terminal or MCP tools unavailable
+npx claude-flow-novice sparc run <mode> "task description"
+
+# For alpha features
+npx claude-flow@alpha sparc run <mode> "task description"
+
+# List all modes
+npx claude-flow-novice sparc modes
+
+# Get help for a mode
+npx claude-flow-novice sparc help <mode>
+
+# Run with options
+npx claude-flow-novice sparc run <mode> "task" --parallel --monitor
+```
+
+### Option 3: Local Installation
+```bash
+# If claude-flow-novice is installed locally
+./claude-flow-novice sparc run <mode> "task description"
+```
+
+## Common Workflows
+
+### Full Development Cycle
+
+#### Using MCP Tools (Preferred)
+```javascript
+// 1. Initialize development swarm
+mcp__claude-flow__swarm_init {
+  topology: "hierarchical",
+  maxAgents: 12
+}
+
+// 2. Architecture design
+mcp__claude-flow__sparc_mode {
+  mode: "architect",
+  task_description: "design microservices"
+}
+
+// 3. Implementation
+mcp__claude-flow__sparc_mode {
+  mode: "coder",
+  task_description: "implement services"
+}
+
+// 4. Testing
+mcp__claude-flow__sparc_mode {
+  mode: "tdd",
+  task_description: "test all services"
+}
+
+// 5. Review
+mcp__claude-flow__sparc_mode {
+  mode: "reviewer",
+  task_description: "review implementation"
+}
+```
+
+#### Using NPX CLI (Fallback)
+```bash
+# 1. Architecture design
+npx claude-flow-novice sparc run architect "design microservices"
+
+# 2. Implementation
+npx claude-flow-novice sparc run coder "implement services"
+
+# 3. Testing
+npx claude-flow-novice sparc run tdd "test all services"
+
+# 4. Review
+npx claude-flow-novice sparc run reviewer "review implementation"
+```
+
+### Research and Innovation
+
+#### Using MCP Tools (Preferred)
+```javascript
+// 1. Research phase
+mcp__claude-flow__sparc_mode {
+  mode: "researcher",
+  task_description: "research best practices"
+}
+
+// 2. Innovation
+mcp__claude-flow__sparc_mode {
+  mode: "innovator",
+  task_description: "propose novel solutions"
+}
+
+// 3. Documentation
+mcp__claude-flow__sparc_mode {
+  mode: "documenter",
+  task_description: "document findings"
+}
+```
+
+#### Using NPX CLI (Fallback)
+```bash
+# 1. Research phase
+npx claude-flow-novice sparc run researcher "research best practices"
+
+# 2. Innovation
+npx claude-flow-novice sparc run innovator "propose novel solutions"
+
+# 3. Documentation
+npx claude-flow-novice sparc run documenter "document findings"
+```

package/claude-assets/commands/sparc/swarm-coordinator.md

@@ -0,0 +1,54 @@
+# SPARC Swarm Coordinator Mode
+
+## Purpose
+Specialized swarm management with batch coordination capabilities.
+
+## Activation
+
+### Option 1: Using MCP Tools (Preferred in Claude Code)
+```javascript
+mcp__claude-flow__sparc_mode {
+  mode: "swarm-coordinator",
+  task_description: "manage development swarm",
+  options: {
+    topology: "hierarchical",
+    max_agents: 10
+  }
+}
+```
+
+### Option 2: Using NPX CLI (Fallback when MCP not available)
+```bash
+# Use when running from terminal or MCP tools unavailable
+npx claude-flow-novice sparc run swarm-coordinator "manage development swarm"
+
+# For alpha features
+npx claude-flow@alpha sparc run swarm-coordinator "manage development swarm"
+```
+
+### Option 3: Local Installation
+```bash
+# If claude-flow-novice is installed locally
+./claude-flow-novice sparc run swarm-coordinator "manage development swarm"
+```
+
+## Core Capabilities
+- Swarm initialization
+- Agent management
+- Task distribution
+- Load balancing
+- Result collection
+
+## Coordination Modes
+- Hierarchical swarms
+- Mesh networks
+- Pipeline coordination
+- Adaptive strategies
+- Hybrid approaches
+
+## Management Features
+- Dynamic scaling
+- Resource optimization
+- Failure recovery
+- Performance monitoring
+- Quality assurance

package/claude-assets/commands/sparc/tdd.md

@@ -0,0 +1,54 @@
+# SPARC TDD Mode
+
+## Purpose
+Test-driven development with TodoWrite planning and comprehensive testing.
+
+## Activation
+
+### Option 1: Using MCP Tools (Preferred in Claude Code)
+```javascript
+mcp__claude-flow__sparc_mode {
+  mode: "tdd",
+  task_description: "shopping cart feature",
+  options: {
+    coverage_target: 90,
+    test_framework: "jest"
+  }
+}
+```
+
+### Option 2: Using NPX CLI (Fallback when MCP not available)
+```bash
+# Use when running from terminal or MCP tools unavailable
+npx claude-flow-novice sparc run tdd "shopping cart feature"
+
+# For alpha features
+npx claude-flow@alpha sparc run tdd "shopping cart feature"
+```
+
+### Option 3: Local Installation
+```bash
+# If claude-flow-novice is installed locally
+./claude-flow-novice sparc run tdd "shopping cart feature"
+```
+
+## Core Capabilities
+- Test-first development
+- Red-green-refactor cycle
+- Test suite design
+- Coverage optimization
+- Continuous testing
+
+## TDD Workflow
+1. Write failing tests
+2. Implement minimum code
+3. Make tests pass
+4. Refactor code
+5. Repeat cycle
+
+## Testing Strategies
+- Unit testing
+- Integration testing
+- End-to-end testing
+- Performance testing
+- Security testing

package/claude-assets/commands/sparc/tester.md

@@ -0,0 +1,54 @@
+# SPARC Tester Mode
+
+## Purpose
+Comprehensive testing with parallel execution capabilities.
+
+## Activation
+
+### Option 1: Using MCP Tools (Preferred in Claude Code)
+```javascript
+mcp__claude-flow__sparc_mode {
+  mode: "tester",
+  task_description: "full regression suite",
+  options: {
+    parallel: true,
+    coverage: true
+  }
+}
+```
+
+### Option 2: Using NPX CLI (Fallback when MCP not available)
+```bash
+# Use when running from terminal or MCP tools unavailable
+npx claude-flow-novice sparc run tester "full regression suite"
+
+# For alpha features
+npx claude-flow@alpha sparc run tester "full regression suite"
+```
+
+### Option 3: Local Installation
+```bash
+# If claude-flow-novice is installed locally
+./claude-flow-novice sparc run tester "full regression suite"
+```
+
+## Core Capabilities
+- Test planning
+- Test execution
+- Bug detection
+- Coverage analysis
+- Report generation
+
+## Test Types
+- Unit tests
+- Integration tests
+- E2E tests
+- Performance tests
+- Security tests
+
+## Parallel Features
+- Concurrent test runs
+- Distributed testing
+- Load testing
+- Cross-browser testing
+- Multi-environment validation

package/claude-assets/commands/sparc/workflow-manager.md

@@ -0,0 +1,54 @@
+# SPARC Workflow Manager Mode
+
+## Purpose
+Process automation with TodoWrite planning and Task execution.
+
+## Activation
+
+### Option 1: Using MCP Tools (Preferred in Claude Code)
+```javascript
+mcp__claude-flow__sparc_mode {
+  mode: "workflow-manager",
+  task_description: "automate deployment",
+  options: {
+    pipeline: "ci-cd",
+    rollback_enabled: true
+  }
+}
+```
+
+### Option 2: Using NPX CLI (Fallback when MCP not available)
+```bash
+# Use when running from terminal or MCP tools unavailable
+npx claude-flow-novice sparc run workflow-manager "automate deployment"
+
+# For alpha features
+npx claude-flow@alpha sparc run workflow-manager "automate deployment"
+```
+
+### Option 3: Local Installation
+```bash
+# If claude-flow-novice is installed locally
+./claude-flow-novice sparc run workflow-manager "automate deployment"
+```
+
+## Core Capabilities
+- Workflow design
+- Process automation
+- Pipeline creation
+- Event handling
+- State management
+
+## Workflow Patterns
+- Sequential flows
+- Parallel branches
+- Conditional logic
+- Loop iterations
+- Error handling
+
+## Automation Features
+- Trigger management
+- Task scheduling
+- Progress tracking
+- Result validation
+- Rollback capability

package/claude-assets/commands/sparc.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+
+/**
+ * SPARC Methodology Slash Command
+ * Usage: /sparc <mode> <task>
+ */
+
+import { SlashCommand } from '../core/slash-command.js';
+
+export class SparcCommand extends SlashCommand {
+  constructor() {
+    super('sparc', 'Execute SPARC methodology phases');
+  }
+
+  async execute(args, context) {
+    const [mode, ...taskArgs] = args;
+    const task = taskArgs.join(' ');
+
+    const modes = {
+      'spec': 'Specification - Requirements analysis and user story definition',
+      'pseudo': 'Pseudocode - Algorithm design and logic flow',
+      'arch': 'Architecture - System design and component structure',
+      'refine': 'Refinement - Iterative improvement and optimization',
+      'complete': 'Completion - Final implementation and testing'
+    };
+
+    if (!mode || !modes[mode]) {
+      return {
+        success: false,
+        error: `Invalid mode. Available modes: ${Object.keys(modes).join(', ')}`,
+        usage: '/sparc <mode> <task_description>'
+      };
+    }
+
+    if (!task) {
+      return {
+        success: false,
+        error: 'Task description required',
+        usage: `/sparc ${mode} <task_description>`
+      };
+    }
+
+    console.log(`🎯 SPARC ${mode.toUpperCase()}: ${task}`);
+
+    const sparcPrompt = `
+🎯 **SPARC Methodology - ${modes[mode]}**
+
+**Task**: ${task}
+
+**Phase**: ${mode.toUpperCase()}
+**Description**: ${modes[mode]}
+
+**Instructions for ${mode.toUpperCase()} phase**:
+${this.getPhaseInstructions(mode)}
+
+**Execute this SPARC phase now**:
+`;
+
+    return {
+      success: true,
+      prompt: sparcPrompt,
+      mode: `sparc-${mode}`,
+      task: task,
+      timestamp: new Date().toISOString()
+    };
+  }
+
+  getPhaseInstructions(mode) {
+    const instructions = {
+      'spec': `
+- Define clear requirements and acceptance criteria
+- Create user stories and use cases
+- Identify constraints and assumptions
+- Specify input/output requirements
+- Document functional and non-functional requirements`,
+
+      'pseudo': `
+- Break down the problem into logical steps
+- Write high-level algorithm pseudocode
+- Define data structures and flow
+- Identify key functions and modules
+- Plan error handling and edge cases`,
+
+      'arch': `
+- Design system architecture and components
+- Define interfaces and APIs
+- Choose appropriate patterns and technologies
+- Plan data flow and storage
+- Consider scalability and maintainability`,
+
+      'refine': `
+- Review and improve the design
+- Optimize algorithms and data structures
+- Refactor for clarity and efficiency
+- Add comprehensive error handling
+- Enhance documentation and comments`,
+
+      'complete': `
+- Implement the final solution
+- Write comprehensive tests
+- Perform integration testing
+- Document usage and deployment
+- Prepare for production deployment`
+    };
+
+    return instructions[mode] || 'Execute the specified SPARC phase';
+  }
+}
+
+export default SparcCommand;

package/claude-assets/commands/stream-chain/pipeline.md

@@ -0,0 +1,121 @@
+# stream-chain pipeline
+
+Execute predefined pipelines for common development workflows.
+
+## Usage
+
+```bash
+claude-flow-novice stream-chain pipeline <type> [options]
+```
+
+## Available Pipelines
+
+### analysis
+Code analysis and improvement pipeline.
+
+```bash
+claude-flow-novice stream-chain pipeline analysis
+```
+
+**Steps:**
+1. Analyze current directory structure and identify main components
+2. Based on analysis, identify potential improvements and issues
+3. Generate detailed report with actionable recommendations
+
+### refactor
+Automated refactoring workflow.
+
+```bash
+claude-flow-novice stream-chain pipeline refactor
+```
+
+**Steps:**
+1. Identify code that could benefit from refactoring
+2. Create prioritized refactoring plan with specific changes
+3. Provide refactored code examples for top 3 priorities
+
+### test
+Comprehensive test generation.
+
+```bash
+claude-flow-novice stream-chain pipeline test
+```
+
+**Steps:**
+1. Analyze codebase and identify areas lacking test coverage
+2. Design comprehensive test cases for critical functions
+3. Generate unit test implementations with assertions
+
+### optimize
+Performance optimization pipeline.
+
+```bash
+claude-flow-novice stream-chain pipeline optimize
+```
+
+**Steps:**
+1. Profile codebase and identify performance bottlenecks
+2. Analyze bottlenecks and suggest optimization strategies
+3. Provide optimized implementations for main issues
+
+## Options
+
+- `--verbose` - Show detailed execution
+- `--timeout <seconds>` - Timeout per step (default: 30)
+- `--debug` - Enable debug mode
+
+## Examples
+
+### Run Analysis Pipeline
+```bash
+claude-flow-novice stream-chain pipeline analysis
+```
+
+### Refactor with Extended Timeout
+```bash
+claude-flow-novice stream-chain pipeline refactor --timeout 60
+```
+
+### Verbose Test Generation
+```bash
+claude-flow-novice stream-chain pipeline test --verbose
+```
+
+### Performance Optimization
+```bash
+claude-flow-novice stream-chain pipeline optimize --debug
+```
+
+## Output
+
+Each pipeline generates:
+- Step-by-step execution progress
+- Success/failure status per step
+- Total execution time
+- Summary of results
+
+## Custom Pipelines
+
+Define custom pipelines in `.claude-flow/config.json`:
+
+```json
+{
+  "streamChain": {
+    "pipelines": {
+      "security": {
+        "name": "Security Audit Pipeline",
+        "prompts": [
+          "Scan for security vulnerabilities",
+          "Prioritize by severity",
+          "Generate fixes"
+        ]
+      }
+    }
+  }
+}
+```
+
+Then run:
+```bash
+claude-flow-novice stream-chain pipeline security
+```

package/claude-assets/commands/stream-chain/run.md

@@ -0,0 +1,70 @@
+# stream-chain run
+
+Execute a custom stream chain with your own prompts.
+
+## Usage
+
+```bash
+claude-flow-novice stream-chain run <prompt1> <prompt2> [...] [options]
+```
+
+Minimum 2 prompts required for chaining.
+
+## Options
+
+- `--verbose` - Show detailed execution information
+- `--timeout <seconds>` - Timeout per step (default: 30)
+- `--debug` - Enable debug mode
+
+## How It Works
+
+Each prompt in the chain receives the complete output from the previous step as context, enabling complex multi-step workflows.
+
+## Examples
+
+### Basic Chain
+```bash
+claude-flow-novice stream-chain run \
+  "Write a function" \
+  "Add tests for it"
+```
+
+### Complex Workflow
+```bash
+claude-flow-novice stream-chain run \
+  "Analyze the authentication system" \
+  "Identify security vulnerabilities" \
+  "Propose fixes with priority levels" \
+  "Implement the critical fixes" \
+  "Generate tests for the fixes"
+```
+
+### With Options
+```bash
+claude-flow-novice stream-chain run \
+  "Complex analysis task" \
+  "Detailed implementation" \
+  --timeout 60 \
+  --verbose
+```
+
+## Context Preservation
+
+The output from each step is injected into the next prompt:
+
+```
+Step 1: "Write a sorting function"
+Output: [function code]
+
+Step 2 receives: "Previous step output:
+[function code]
+
+Next step: Optimize for performance"
+```
+
+## Best Practices
+
+1. **Clear Instructions**: Make each prompt specific
+2. **Logical Flow**: Order prompts in logical sequence
+3. **Appropriate Timeouts**: Increase for complex tasks
+4. **Verification**: Add verification steps in chain

package/claude-assets/commands/swarm/README.md

@@ -0,0 +1,15 @@
+# Swarm Commands
+
+Commands for swarm operations in Claude Flow.
+
+## Available Commands
+
+- [swarm](./swarm.md)
+- [swarm-init](./swarm-init.md)
+- [swarm-spawn](./swarm-spawn.md)
+- [swarm-status](./swarm-status.md)
+- [swarm-monitor](./swarm-monitor.md)
+- [swarm-strategies](./swarm-strategies.md)
+- [swarm-modes](./swarm-modes.md)
+- [swarm-background](./swarm-background.md)
+- [swarm-analysis](./swarm-analysis.md)