claude-flow-novice 2.8.1 → 2.9.1

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

@@ -1,174 +0,0 @@
-# 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/commands/sparc/swarm-coordinator.md

@@ -1,54 +0,0 @@
-# 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/commands/sparc/tdd.md

@@ -1,54 +0,0 @@
-# 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/commands/sparc/tester.md

@@ -1,54 +0,0 @@
-# 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/commands/sparc/workflow-manager.md

@@ -1,54 +0,0 @@
-# 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/commands/sparc.js

@@ -1,110 +0,0 @@
-#!/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/commands/stream-chain/pipeline.md

@@ -1,121 +0,0 @@
-# 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/commands/stream-chain/run.md

@@ -1,70 +0,0 @@
-# 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/commands/swarm/README.md

@@ -1,15 +0,0 @@
-# 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)