@sparkleideas/claude-flow 3.5.2-patch.1

package/src/cli/command-registry.js

@@ -0,0 +1,1192 @@
+// command-registry.js - Extensible command registration system
+import process from 'process';
+import { initCommand } from './simple-commands/init/index.js';
+import { memoryCommand } from './simple-commands/memory.js';
+import { memoryConsolidationCommand } from './simple-commands/memory-consolidation.js';
+import { sparcCommand } from './simple-commands/sparc.js';
+import { agentCommand } from './simple-commands/agent.js';
+import { taskCommand } from './simple-commands/task.js';
+import { configCommand } from './simple-commands/config.js';
+import { statusCommand } from './simple-commands/status.js';
+import { mcpCommand } from './simple-commands/mcp.js';
+import { proxyCommand } from './simple-commands/proxy.js';
+import { monitorCommand } from './simple-commands/monitor.js';
+import { startCommand } from './simple-commands/start.js';
+import { swarmCommand } from './simple-commands/swarm.js';
+import { batchManagerCommand } from './simple-commands/batch-manager.js';
+import { githubCommand } from './simple-commands/github.js';
+import { trainingAction } from './simple-commands/training.js';
+import { analysisAction } from './simple-commands/analysis.js';
+import { automationAction } from './simple-commands/automation.js';
+import { coordinationAction } from './simple-commands/coordination.js';
+import { hooksAction } from './simple-commands/hooks.js';
+import { hookSafetyCommand } from './simple-commands/hook-safety.js';
+import { hiveMindCommand } from './simple-commands/hive-mind.js';
+import { HelpFormatter } from './help-formatter.js';
+import hiveMindOptimizeCommand from './simple-commands/hive-mind-optimize.js';
+import { neuralCommand } from './simple-commands/neural.js';
+import { goalCommand } from './simple-commands/goal.js';
+import {
+  showUnifiedMetrics,
+  fixTaskAttribution,
+} from './simple-commands/swarm-metrics-integration.js';
+import { migrateHooksCommand, migrateHooksCommandConfig } from './simple-commands/migrate-hooks.js';
+import {
+  fixHookVariablesCommand,
+  fixHookVariablesCommandConfig,
+} from './simple-commands/fix-hook-variables.js';
+import { 
+  initializePerformanceTracking,
+  trackCommandExecution 
+} from './simple-commands/performance-hooks.js';
+// Maestro commands integrated with clean implementation
+// Note: Maestro TypeScript commands now integrated directly in ./commands/maestro.ts
+// Note: TypeScript imports commented out for Node.js compatibility
+// import { ruvSwarmAction } from './commands/ruv-swarm.ts';
+// import { configIntegrationAction } from './commands/config-integration.ts';
+
+// Command registry for extensible CLI
+export const commandRegistry = new Map();
+
+// Register core commands
+export function registerCoreCommands() {
+  commandRegistry.set('init', {
+    handler: initCommand,
+    description: 'Initialize Claude Code integration files and SPARC development environment',
+    usage: 'init [--force] [--minimal] [--sparc]',
+    examples: [
+      'npx @sparkleideas/claude-flow@latest init --sparc  # Recommended: Full SPARC setup',
+      'init --sparc                         # Initialize with SPARC modes',
+      'init --force --minimal               # Minimal setup, overwrite existing',
+      'init --sparc --force                 # Force SPARC setup',
+    ],
+    details: `
+The --sparc flag creates a complete development environment:
+  • .roomodes file containing 17 specialized SPARC modes
+  • CLAUDE.md for AI-readable project instructions
+  • Pre-configured modes: architect, code, tdd, debug, security, and more
+  • Ready for TDD workflows and automated code generation
+  
+First-time users should run: npx @sparkleideas/claude-flow@latest init --sparc`,
+  });
+
+  commandRegistry.set('start', {
+    handler: startCommand,
+    description: 'Start the Claude-Flow orchestration system',
+    usage: 'start [--daemon] [--port <port>] [--verbose] [--ui] [--web]',
+    examples: [
+      'start                    # Start in interactive mode',
+      'start --daemon           # Start as background daemon',
+      'start --port 8080        # Use custom MCP port',
+      'start --verbose          # Show detailed system activity',
+      'start --ui               # Launch terminal-based UI',
+      'start --web              # Launch web-based UI',
+    ],
+  });
+
+  // Add start-ui as a convenient alias for launching the UI
+  commandRegistry.set('start-ui', {
+    handler: async (args, flags) => {
+      // Import and use the direct UI launcher
+      const { launchUI } = await import('./simple-commands/start-ui.js');
+      // Pass the full raw arguments from process.argv
+      const fullArgs = process.argv.slice(3); // Skip node, script, and command
+      return launchUI(fullArgs);
+    },
+    description: 'Start the UI interface (web UI by default)',
+    usage: 'start-ui [--port <port>] [--terminal]',
+    examples: [
+      'start-ui                 # Launch web-based UI (default)',
+      'start-ui --port 3000     # Use custom port',
+      'start-ui --terminal      # Launch terminal-based UI instead',
+    ],
+  });
+
+  commandRegistry.set('memory', {
+    handler: memoryCommand,
+    description: 'Memory management operations',
+    usage: 'memory <subcommand> [options]',
+    examples: [
+      'memory store key "value"',
+      'memory query search_term',
+      'memory stats',
+      'memory export backup.json',
+    ],
+  });
+
+  commandRegistry.set('memory-consolidate', {
+    handler: memoryConsolidationCommand,
+    description: 'Consolidate fragmented memory stores into unified database',
+    usage: 'memory-consolidate <command> [options]',
+    examples: [
+      'memory-consolidate scan                # Scan for all memory stores',
+      'memory-consolidate plan                # Create consolidation plan',
+      'memory-consolidate execute --force     # Execute consolidation',
+      'memory-consolidate report              # Generate report',
+    ],
+    details: `
+Memory Consolidation Features:
+  • Discovers all memory storage locations (JSON & SQLite)
+  • Creates automatic backups before consolidation
+  • Merges all stores into unified SQLite database
+  • Optimizes with indices for better performance
+  • Maintains backward compatibility
+  
+Benefits:
+  • Single source of truth for all memory data
+  • Improved query performance with indices
+  • Reduced disk fragmentation
+  • Easier backup and restore
+  • Cross-session persistence`,
+  });
+
+  commandRegistry.set('sparc', {
+    handler: sparcCommand,
+    description: 'SPARC development mode operations',
+    usage: 'sparc [subcommand] [options]',
+    examples: [
+      'sparc "orchestrate full app development"  # Default: sparc orchestrator',
+      'sparc modes                               # List available modes',
+      'sparc run code "implement feature"        # Run specific mode',
+      'sparc tdd "feature description"           # TDD workflow',
+      'sparc info architect                      # Mode details',
+    ],
+  });
+
+  // Note: Maestro commands are now handled by TypeScript module
+  // See src/cli/commands/maestro.ts for the clean implementation
+  commandRegistry.set('maestro', {
+    handler: () => {
+      console.log('⚠️  Maestro commands have been moved to TypeScript.');
+      console.log('Please use: npx @sparkleideas/claude-flow maestro help');
+      console.log('Or import from: ./commands/maestro.js after compilation');
+    },
+    description: 'Maestro: Specs-Driven Development with Hive Mind Integration',
+    usage: 'maestro <subcommand> [options]',
+    examples: [
+      'maestro create-spec my-feature --request "Implement user auth"',
+      'maestro generate-design my-feature',
+      'maestro generate-tasks my-feature',
+      'maestro implement-task my-feature 1',
+      'maestro approve-phase my-feature',
+      'maestro status my-feature --detailed',
+      'maestro init-steering api-design',
+      'maestro help',
+    ],
+  });
+
+  commandRegistry.set('agent', {
+    handler: agentCommand,
+    description: 'Manage AI agents, memory, and @sparkleideas/agentic-flow integration (NEW in v2.6.0)',
+    usage: 'agent <subcommand> [options]',
+    examples: [
+      'agent run coder "Build REST API" --optimize  # Multi-provider execution',
+      'agent agents                                  # List 66+ available agents',
+      'agent memory init                             # Initialize ReasoningBank',
+      'agent config wizard                           # Configure API keys',
+      'agent mcp start --daemon                      # Start MCP server',
+      'agent spawn researcher --name "DataBot"      # Internal agent management',
+    ],
+    details: `
+Agent management features:
+  • Multi-provider execution (Anthropic, OpenRouter, ONNX, Gemini)
+  • ReasoningBank memory system (70% → 88% success improvement)
+  • Model optimization (85-98% cost savings)
+  • MCP server management (213+ tools)
+  • Configuration management (API keys, models, settings)
+  • Custom agent creation and management
+  • Internal agent hierarchies and coordination
+
+Subcommands:
+  run          - Execute agents with multi-provider support
+  agents       - List all 66+ available agents
+  create       - Create custom agents
+  info         - Show agent information
+  conflicts    - Check for agent conflicts
+  memory       - ReasoningBank memory management
+  config       - Configuration management
+  mcp          - MCP server management
+  spawn        - Internal agent management
+  list         - List internal agents
+
+See '@sparkleideas/claude-flow help agent' for full documentation.`,
+  });
+
+  commandRegistry.set('proxy', {
+    handler: proxyCommand,
+    description: 'OpenRouter proxy server for 85-98% cost savings (NEW in v2.6.0)',
+    usage: 'proxy <subcommand> [options]',
+    examples: [
+      'proxy start --daemon                         # Start proxy server',
+      'proxy status --verbose                       # Check status',
+      'proxy config                                 # Configuration guide',
+      'proxy logs --follow                          # View logs',
+    ],
+    details: `
+OpenRouter Proxy Features:
+  • Transparent API translation (Anthropic → OpenRouter)
+  • 85-98% cost savings vs direct Anthropic API
+  • Works with Claude Code out of the box
+  • Zero code changes required
+  • Supports all OpenRouter models
+
+Cost Savings Examples:
+  • Claude 3.5 Sonnet: $3.00 → $0.30 per million tokens (90% savings)
+  • Claude 3 Opus: $15.00 → $2.25 per million tokens (85% savings)
+  • DeepSeek R1: Free (100% savings)
+
+Setup:
+  1. Get OpenRouter API key: https://openrouter.ai/keys
+  2. @sparkleideas/claude-flow agent config set OPENROUTER_API_KEY sk-or-xxx
+  3. @sparkleideas/claude-flow proxy start --daemon
+  4. export ANTHROPIC_BASE_URL=http://localhost:8080
+  5. Use Claude Code normally → automatic savings!
+
+Commands:
+  start        - Start proxy server
+  stop         - Stop proxy server
+  restart      - Restart proxy server
+  status       - Get server status
+  logs         - View server logs
+  config       - Configuration guide`,
+  });
+
+  commandRegistry.set('task', {
+    handler: taskCommand,
+    description: 'Manage tasks and workflows',
+    usage: 'task <subcommand> [options]',
+    examples: [
+      'task create research "Market analysis"',
+      'task list --filter running',
+      'task workflow examples/dev-flow.json',
+      'task coordination status',
+    ],
+  });
+
+  commandRegistry.set('config', {
+    handler: configCommand,
+    description: 'Manage system configuration',
+    usage: 'config <subcommand> [options]',
+    examples: [
+      'config init',
+      'config set terminal.poolSize 15',
+      'config get orchestrator.maxConcurrentTasks',
+      'config validate',
+    ],
+  });
+
+  commandRegistry.set('status', {
+    handler: statusCommand,
+    description: 'Show system status and health',
+    usage: 'status [--verbose] [--json]',
+    examples: ['status', 'status --verbose', 'status --json'],
+  });
+
+  commandRegistry.set('mcp', {
+    handler: mcpCommand,
+    description: 'Manage MCP server and tools',
+    usage: 'mcp <subcommand> [options]',
+    examples: ['mcp status', 'mcp start --port 8080', 'mcp tools --verbose', 'mcp auth setup'],
+  });
+
+  commandRegistry.set('monitor', {
+    handler: monitorCommand,
+    description: 'Real-time system monitoring',
+    usage: 'monitor [--watch] [--interval <ms>]',
+    examples: [
+      'monitor',
+      'monitor --watch',
+      'monitor --interval 1000 --watch',
+      'monitor --format json',
+    ],
+  });
+
+  commandRegistry.set('swarm', {
+    handler: swarmCommand,
+    description: 'Swarm-based AI agent coordination',
+    usage: 'swarm <objective> [options]',
+    examples: [
+      'swarm "Build a REST API"',
+      'swarm "Research cloud architecture" --strategy research',
+      'swarm "Analyze data" --max-agents 3 --parallel',
+      'swarm "Development task" --ui --monitor --background',
+    ],
+  });
+
+  commandRegistry.set('hive-mind', {
+    handler: hiveMindCommand,
+    description: '🧠 Advanced Hive Mind swarm intelligence with collective decision-making',
+    usage: 'hive-mind <subcommand> [options]',
+    examples: [
+      'hive-mind init                          # Initialize hive mind system',
+      'hive-mind spawn "Build microservices"   # Create swarm with objective',
+      'hive-mind wizard                        # Interactive setup wizard',
+      'hive-mind status                        # View active swarms',
+      'hive-mind consensus                     # View consensus decisions',
+      'hive-mind metrics                       # Performance analytics',
+    ],
+    customHelp: true, // Use command's own help function
+    details: `
+Hive Mind System Features:
+  • Queen-led coordination with specialized worker agents
+  • Collective memory and knowledge sharing
+  • Consensus building for critical decisions  
+  • Auto-scaling based on workload
+  • Parallel task execution with work stealing
+  • Real-time monitoring and metrics
+  • SQLite-backed persistence
+  • MCP tool integration for 87+ operations
+
+Queen Types:
+  • Strategic - Long-term planning and optimization
+  • Tactical - Task prioritization and rapid response
+  • Adaptive - Learning and strategy evolution
+
+Worker Types:
+  • Researcher, Coder, Analyst, Tester
+  • Architect, Reviewer, Optimizer, Documenter
+
+Use 'hive-mind wizard' for interactive setup or 'hive-mind help' for full documentation.`,
+  });
+
+  commandRegistry.set('hive-mind-optimize', {
+    handler: hiveMindOptimizeCommand,
+    description: '🔧 Optimize hive mind database for better performance',
+    usage: 'hive-mind-optimize [options]',
+    examples: [
+      'hive-mind-optimize                      # Interactive optimization wizard',
+      'hive-mind-optimize --auto               # Auto-optimize with defaults',
+      'hive-mind-optimize --report             # Generate optimization report',
+      'hive-mind-optimize --clean-memory --memory-days 60',
+      'hive-mind-optimize --auto --vacuum --archive-tasks',
+    ],
+    details: `
+Hive Mind Database Optimization Features:
+  • Safe, backward-compatible optimizations
+  • Performance indexes for 50% faster queries
+  • Memory cleanup and archiving
+  • Task archival for space management
+  • Behavioral pattern tracking
+  • Database integrity checking
+  
+Optimization Levels:
+  • v1.0 → v1.1: Basic performance indexes
+  • v1.1 → v1.2: Advanced query optimization
+  • v1.2 → v1.3: Performance tracking tables
+  • v1.3 → v1.4: Memory optimization features
+  • v1.4 → v1.5: Behavioral analysis tracking
+
+Safety Features:
+  • Automatic backups before major operations
+  • All changes are backward-compatible
+  • Existing data is always preserved
+  • Rollback capability on errors`,
+  });
+
+  commandRegistry.set('swarm-metrics', {
+    handler: async (args, flags) => {
+      const subcommand = args[0];
+      if (subcommand === 'fix') {
+        return await fixTaskAttribution();
+      } else {
+        return await showUnifiedMetrics();
+      }
+    },
+    description: 'Unified swarm metrics and task attribution diagnostics',
+    usage: 'swarm-metrics [fix] [options]',
+    examples: [
+      'swarm-metrics                    # Show unified metrics from all swarm systems',
+      'swarm-metrics fix                # Fix task attribution issues between systems',
+    ],
+    details: `
+Swarm Metrics Integration Features:
+  • Unified view of hive-mind and @sparkleideas/ruv-swarm metrics
+  • Task attribution diagnosis and repair
+  • Cross-system swarm performance comparison
+  • Database integration status checking
+  • Automatic sample task creation for empty swarms
+
+This command helps resolve issues where:
+  • Overall task statistics show correctly but per-swarm shows 0/0
+  • Multiple swarm systems are not properly integrated
+  • Task assignments are missing or incorrectly attributed
+
+Use 'swarm-metrics fix' to automatically repair attribution issues.`,
+  });
+
+  commandRegistry.set('batch', {
+    handler: batchManagerCommand,
+    description: 'Batch operation management and configuration utilities',
+    usage: 'batch <command> [options]',
+    examples: [
+      'batch create-config my-batch.json',
+      'batch create-config --interactive',
+      'batch validate-config my-batch.json',
+      'batch estimate my-batch.json',
+      'batch list-templates',
+      'batch list-environments',
+    ],
+    details: `
+Batch operations support:
+  • Multiple project initialization with templates
+  • Environment-specific configurations (dev, staging, prod)
+  • Parallel processing with resource management
+  • Progress tracking and detailed reporting
+  • Configuration validation and estimation tools
+  
+Use with init command:
+  @sparkleideas/claude-flow init --batch-init project1,project2,project3
+  @sparkleideas/claude-flow init --config batch-config.json --parallel`,
+  });
+
+  commandRegistry.set('github', {
+    handler: githubCommand,
+    description: 'GitHub workflow automation with 6 specialized modes',
+    usage: 'github <mode> <objective> [options]',
+    examples: [
+      'github pr-manager "create feature PR with automated testing"',
+      'github gh-coordinator "setup CI/CD pipeline" --auto-approve',
+      'github release-manager "prepare v2.0.0 release"',
+      'github repo-architect "optimize repository structure"',
+      'github issue-tracker "analyze project roadmap issues"',
+      'github sync-coordinator "sync package versions across repos"',
+    ],
+    details: `
+GitHub automation modes:
+  • gh-coordinator: GitHub workflow orchestration and coordination
+  • pr-manager: Pull request management with multi-reviewer coordination
+  • issue-tracker: Issue management and project coordination
+  • release-manager: Release coordination and deployment pipelines
+  • repo-architect: Repository structure optimization
+  • sync-coordinator: Multi-package synchronization and version alignment
+  
+Advanced features:
+  • Multi-reviewer coordination with automated scheduling
+  • Intelligent issue categorization and assignment
+  • Automated testing integration and quality gates
+  • Release pipeline orchestration with rollback capabilities`,
+  });
+
+  commandRegistry.set('training', {
+    handler: trainingAction,
+    description: 'Neural pattern learning and model updates',
+    usage: 'training <command> [options]',
+    examples: [
+      'training neural-train --data recent --model task-predictor',
+      'training pattern-learn --operation "file-creation" --outcome "success"',
+      'training model-update --agent-type coordinator --operation-result "efficient"',
+    ],
+    details: `
+Neural training commands:
+  • neural-train: Train neural patterns from operations
+  • pattern-learn: Learn from specific operation outcomes
+  • model-update: Update agent models with new insights
+  
+Improves task selection accuracy, agent performance prediction, and coordination efficiency.`,
+  });
+
+  commandRegistry.set('analysis', {
+    handler: analysisAction,
+    description: 'Performance and usage analytics',
+    usage: 'analysis <command> [options]',
+    examples: [
+      'analysis bottleneck-detect --scope system',
+      'analysis performance-report --timeframe 7d --format detailed',
+      'analysis token-usage --breakdown --cost-analysis',
+    ],
+    details: `
+Analysis commands:
+  • bottleneck-detect: Detect performance bottlenecks in the system
+  • performance-report: Generate comprehensive performance reports
+  • token-usage: Analyze token consumption and costs
+  
+Helps with performance optimization, cost management, and resource allocation.`,
+  });
+
+  commandRegistry.set('automation', {
+    handler: automationAction,
+    description: 'Intelligent agent and workflow management with MLE-STAR and Claude integration',
+    usage: 'automation <command> [options]',
+    examples: [
+      'automation auto-agent --task-complexity enterprise --swarm-id swarm-123',
+      'automation smart-spawn --requirement "web-development" --max-agents 8',
+      'automation workflow-select --project-type api --priority speed',
+      'automation run-workflow my-workflow.json --claude --non-interactive',
+      'automation mle-star --dataset data/train.csv --target price --claude',
+    ],
+    details: `
+Automation commands:
+  • auto-agent: Automatically spawn optimal agents based on task complexity
+  • smart-spawn: Intelligently spawn agents based on specific requirements
+  • workflow-select: Select and configure optimal workflows for project types
+  • run-workflow: Execute workflows from JSON/YAML files with Claude integration
+  • mle-star: Run MLE-STAR Machine Learning Engineering workflow (flagship)
+  
+New features:
+  • Claude CLI integration for actual execution
+  • MLE-STAR methodology for ML engineering
+  • Non-interactive mode for CI/CD integration
+  • Comprehensive workflow templates
+  
+Provides optimal resource allocation, intelligent agent selection, and complete automation workflows.`,
+  });
+
+  commandRegistry.set('coordination', {
+    handler: coordinationAction,
+    description: 'Swarm and agent orchestration',
+    usage: 'coordination <command> [options]',
+    examples: [
+      'coordination swarm-init --topology hierarchical --max-agents 8',
+      'coordination agent-spawn --type developer --name "api-dev" --swarm-id swarm-123',
+      'coordination task-orchestrate --task "Build REST API" --strategy parallel',
+    ],
+    details: `
+Coordination commands:
+  • swarm-init: Initialize swarm coordination infrastructure
+  • agent-spawn: Spawn and coordinate new agents
+  • task-orchestrate: Orchestrate task execution across agents
+  
+Enables intelligent task distribution, agent synchronization, and shared memory coordination.`,
+  });
+
+  commandRegistry.set('hooks', {
+    handler: hooksAction,
+    description: 'Lifecycle event management',
+    usage: 'hooks <command> [options]',
+    examples: [
+      'hooks pre-task --description "Build API" --task-id task-123',
+      'hooks post-task --task-id task-123 --analyze-performance --generate-insights',
+      'hooks session-end --export-metrics --generate-summary',
+    ],
+    details: `
+Hooks commands:
+  • pre-task: Execute before task begins (preparation & setup)
+  • post-task: Execute after task completion (analysis & cleanup)
+  • pre-edit: Execute before file modifications (backup & validation)
+  • post-edit: Execute after file modifications (tracking & coordination)
+  • session-end: Execute at session termination (cleanup & export)
+  
+Enables automated preparation & cleanup, performance tracking, and coordination synchronization.`,
+  });
+
+  commandRegistry.set('hook-safety', {
+    handler: hookSafetyCommand,
+    description: '🚨 Critical hook safety system - Prevent infinite loops & financial damage',
+    usage: 'hook-safety <command> [options]',
+    examples: [
+      'hook-safety validate                           # Check for dangerous hook configurations',
+      'hook-safety validate --config ~/.claude/settings.json',
+      'hook-safety status                             # View safety status and context',
+      'hook-safety reset                              # Reset circuit breakers',
+      'hook-safety safe-mode                          # Enable safe mode (skip all hooks)',
+    ],
+    details: `
+🚨 CRITICAL: Stop hooks calling 'claude' commands create INFINITE LOOPS that can:
+  • Bypass API rate limits
+  • Cost thousands of dollars per day  
+  • Make your system unresponsive
+
+Hook Safety commands:
+  • validate: Check Claude Code settings for dangerous patterns
+  • status: Show current safety status and execution context
+  • reset: Reset circuit breakers and execution counters  
+  • safe-mode: Enable/disable safe mode (skips all hooks)
+
+SAFE ALTERNATIVES:
+  • Use PostToolUse hooks instead of Stop hooks
+  • Implement flag-based update patterns
+  • Use 'claude --skip-hooks' for manual updates
+  • Create conditional execution scripts
+
+For more information: https://github.com/ruvnet/claude-flow/issues/166`,
+  });
+
+  commandRegistry.set('migrate-hooks', migrateHooksCommandConfig);
+
+  commandRegistry.set('fix-hook-variables', {
+    handler: fixHookVariablesCommand,
+    ...fixHookVariablesCommandConfig,
+  });
+
+  // Verification system commands
+  commandRegistry.set('verify', {
+    handler: async (args, flags) => {
+      try {
+        const { verificationCommand } = await import('./simple-commands/verification.js');
+        return await verificationCommand(args, flags);
+      } catch (error) {
+        console.error('❌ Error loading verification module:', error.message);
+        console.log('Error details:', error);
+      }
+    },
+    description: '🔍 Verification and truth enforcement system',
+    usage: 'verify <subcommand> [options]',
+    examples: [
+      'verify status                    # Show verification system status',
+      'verify check --taskId task-123   # Run verification checks',
+      'verify validate --taskId task-456 # Validate task results',
+      'verify config                    # Manage verification config',
+      'verify cleanup --force           # Clean up old verification data',
+    ],
+    details: `
+Verification system commands:
+  • status: Show current system status and health
+  • check: Run verification checks on tasks
+  • validate: Validate task completion and results
+  • config: Manage verification configuration
+  • cleanup: Clean up old verification data
+  • pre-task: Execute pre-task verification
+  • post-task: Execute post-task validation
+  • integration: Run integration tests
+  • truth: Execute truth telemetry checks
+  • rollback: Trigger rollback if needed
+
+Truth enforcement features:
+  • 0.95 minimum truth threshold
+  • Cross-agent integration testing
+  • Automated rollback on failures
+  • Cryptographic verification
+  • Byzantine fault tolerance`,
+  });
+
+  commandRegistry.set('truth', {
+    handler: async (args, flags) => {
+      try {
+        const { truthCommand } = await import('./simple-commands/verification.js');
+        return await truthCommand(args, flags);
+      } catch (error) {
+        console.error('❌ Error loading verification module:', error.message);
+        console.log('Error details:', error);
+      }
+    },
+    description: '🎯 Truth telemetry and accuracy scoring',
+    usage: 'truth [options]',
+    examples: [
+      'truth                            # Show current truth scores',
+      'truth --taskId task-123          # Check truth for specific task',
+      'truth --threshold 0.95           # Set minimum truth threshold',
+      'truth --report                   # Generate truth report',
+    ],
+    details: `
+Truth scoring system:
+  • Real-time truth metrics collection
+  • Agent performance scoring
+  • System-wide truth accuracy tracking
+  • Automated alerting for threshold violations
+  • Dashboard data export functionality
+
+Target metrics:
+  • >95% truth accuracy rate
+  • <10% human intervention rate
+  • >90% integration success rate
+  • <5% automated rollback frequency`,
+  });
+
+  commandRegistry.set('neural', {
+    handler: neuralCommand,
+    description: '🧠 Neural module commands for SAFLA self-learning systems',
+    usage: 'neural <command> [options]',
+    examples: [
+      'neural init                      # Initialize neural module',
+      'neural init --force              # Force overwrite existing',
+      'neural init --target ./agents    # Custom location',
+    ],
+    details: `
+Neural Module Features:
+  • Self-Aware Feedback Loop Algorithm (SAFLA)
+  • 4-tier memory system (Vector, Episodic, Semantic, Working)
+  • 172,000+ ops/sec processing with WASM optimization
+  • 60% memory compression while maintaining recall
+  • Cross-session learning and persistence
+  • Distributed neural training with MCP integration`,
+  });
+
+  commandRegistry.set('goal', {
+    handler: goalCommand,
+    description: '🎯 Goal module commands for GOAP intelligent planning',
+    usage: 'goal <command> [options]',
+    examples: [
+      'goal init                        # Initialize goal module',
+      'goal init --force                # Force overwrite existing',
+      'goal init --target ./agents      # Custom location',
+    ],
+    details: `
+Goal Module Features:
+  • Goal-Oriented Action Planning (GOAP) algorithm
+  • A* pathfinding for optimal plan generation
+  • OODA loop execution monitoring
+  • Adaptive replanning on failures
+  • Mixed LLM + code execution
+  • Cost-optimized action sequences`,
+  });
+
+  commandRegistry.set('pair', {
+    handler: async (args, flags) => {
+      try {
+        const pairCommand = (await import('./simple-commands/pair.js')).default;
+        return await pairCommand(args, flags);
+      } catch (error) {
+        console.error('❌ Error loading pair module:', error.message);
+        console.log('Error details:', error);
+      }
+    },
+    description: '👥 Interactive pair programming with AI assistance',
+    usage: 'pair [options]',
+    examples: [
+      'pair --start                     # Start pair programming session',
+      'pair --start --mode driver       # You write, AI assists',
+      'pair --start --verify --test     # Enable verification and testing',
+      'pair --status                    # Show session status',
+      'pair --end                       # End current session',
+    ],
+    details: `
+Pair programming features:
+  • Three modes: driver, navigator, switch
+  • Real-time code assistance
+  • Optional verification and testing
+  • Session persistence
+  • Background execution support`,
+  });
+
+  commandRegistry.set('verify-train', {
+    handler: async (args, flags) => {
+      try {
+        const { verificationTrainingCommand } = await import('./simple-commands/verification-training-integration.js');
+        return await verificationTrainingCommand(args, flags);
+      } catch (error) {
+        console.error('❌ Error loading verification-training module:', error.message);
+        console.log('Error details:', error);
+      }
+    },
+    description: '🧠 Verification-Training integration for continuous improvement',
+    usage: 'verify-train <command> [options]',
+    examples: [
+      'verify-train status              # Show training status',
+      'verify-train feed                # Feed verification data to training',
+      'verify-train predict coder       # Predict verification outcome',
+      'verify-train recommend           # Get agent recommendations',
+      'verify-train train               # Trigger neural training',
+    ],
+    details: `
+Verification-Training Integration:
+  • Feeds verification results to training system
+  • Learns from agent performance over time
+  • Predicts verification outcomes
+  • Recommends best agents for tasks
+  • Improves reliability through continuous learning`,
+  });
+
+  commandRegistry.set('train-pipeline', {
+    handler: async (args, flags) => {
+      try {
+        // Always use real execution - no more simulation
+        const { trainingPipelineCommand } = await import('./simple-commands/training-pipeline.js');
+        return await trainingPipelineCommand(args, flags);
+      } catch (error) {
+        console.error('❌ Error loading training-pipeline module:', error.message);
+        console.log('Error details:', error);
+      }
+    },
+    description: '🚀 Real training pipeline with actual code execution and learning',
+    usage: 'train-pipeline <command> [options]',
+    examples: [
+      'train-pipeline run               # Run training with real code',
+      'train-pipeline run --complexity hard --iterations 5',
+      'train-pipeline generate          # Generate real training tasks',
+      'train-pipeline validate          # Validate current performance',
+      'train-pipeline status            # Show pipeline status with real metrics',
+    ],
+    details: `
+Real Training Pipeline Features:
+  • Creates actual code files and tests
+  • Runs real npm test commands
+  • Learns from actual test results
+  • Validates improvements with real metrics
+  • Applies learned optimizations to production
+  
+Pipeline Stages:
+  1. Generate real code tasks (easy/medium/hard)
+  2. Execute with different strategies using npm
+  3. Learn from real test results
+  4. Validate actual improvements
+  5. Apply to production configuration
+  
+Options:
+  --complexity <level> Task complexity (easy/medium/hard)
+  --iterations <n>     Number of training iterations`,
+  });
+
+  commandRegistry.set('stream-chain', {
+    handler: async (args, flags) => {
+      try {
+        const { streamChainCommand } = await import('./simple-commands/stream-chain.js');
+        return await streamChainCommand(args, flags);
+      } catch (error) {
+        console.error('❌ Error loading stream-chain module:', error.message);
+        console.log('Error details:', error);
+      }
+    },
+    description: '🔗 Connect multiple Claude instances via stream-json for chained workflows',
+    usage: 'stream-chain <subcommand> [options]',
+    examples: [
+      'stream-chain run "analyze" "design" "implement"  # Custom chain',
+      'stream-chain demo                                 # Run demo chain', 
+      'stream-chain pipeline analysis                    # Run analysis pipeline',
+      'stream-chain test                                 # Test stream connection',
+      'stream-chain help                                 # Show detailed help',
+    ],
+    details: `
+📚 SUBCOMMANDS
+    run <p1> <p2> [...]  Execute custom chain (min 2 prompts)
+    demo                 Run 3-step demo chain
+    pipeline <type>      Run predefined pipeline (analysis/refactor/test/optimize)
+    test                 Test stream connection
+    help                 Show comprehensive documentation
+
+⚙️  OPTIONS
+    --verbose            Show detailed execution info
+    --timeout <seconds>  Timeout per step (default: 30)
+    --debug              Enable debug mode
+
+🔄 STREAM CHAINING
+    Chains multiple Claude Code calls with context preservation:
+    • Step 1 outputs stream-json → Step 2 receives context → Step 3...
+    • 100% context preservation between steps
+    • Real execution with Claude Code (not simulated)
+
+🚀 PIPELINES
+    analysis  - Analyze → Identify issues → Generate report
+    refactor  - Find opportunities → Create plan → Apply changes
+    test      - Analyze coverage → Design cases → Generate tests
+    optimize  - Profile code → Find bottlenecks → Apply optimizations
+
+⚡ PERFORMANCE
+    • Latency: ~10-30s per step
+    • Context: Full preservation
+    • Streaming: No intermediate files
+
+📖 For full documentation: stream-chain help`,
+  });
+
+  commandRegistry.set('hive', {
+    handler: async (args, flags) => {
+      try {
+        // Try to load the hive command module
+        const { hiveAction } = await import('./commands/hive.js');
+        return hiveAction({ args, flags, command: 'hive' });
+      } catch (error) {
+        // Fallback to simple implementation if module not found
+        console.log('🐝 Hive Mind - Advanced Multi-Agent Coordination');
+        console.log('');
+        console.log('The Hive Mind system provides:');
+        console.log('  • Consensus-based decision making');
+        console.log('  • Distributed task orchestration');
+        console.log('  • Quality-driven execution');
+        console.log('  • Real-time swarm monitoring');
+        console.log('');
+        console.log('Usage: hive <objective> [options]');
+        console.log('');
+        console.log('For full functionality, ensure the hive module is properly built.');
+      }
+    },
+    description: 'Hive Mind - Advanced multi-agent swarm with consensus',
+    usage: 'hive <objective> [options]',
+    examples: [
+      'hive "Build microservices architecture"',
+      'hive "Optimize database performance" --consensus unanimous',
+      'hive "Develop ML pipeline" --topology mesh --monitor',
+      'hive "Create REST API" --sparc --max-agents 8',
+      'hive "Research cloud patterns" --background --quality-threshold 0.9',
+    ],
+    details: `
+Hive Mind features:
+  • 👑 Queen-led orchestration with specialized agents
+  • 🗳️ Consensus mechanisms (quorum, unanimous, weighted, leader)
+  • 🏗️ Multiple topologies (hierarchical, mesh, ring, star)
+  • 📊 Real-time monitoring dashboard
+  • 🧪 SPARC methodology integration
+  • 💾 Distributed memory and knowledge sharing
+  
+Agent types:
+  • Queen: Orchestrator and decision maker
+  • Architect: System design and planning  
+  • Worker: Implementation and execution
+  • Scout: Research and exploration
+  • Guardian: Quality and validation
+  
+Options:
+  --topology <type>         Swarm topology (default: hierarchical)
+  --consensus <type>        Decision mechanism (default: quorum)
+  --max-agents <n>          Maximum agents (default: 8)
+  --quality-threshold <n>   Min quality 0-1 (default: 0.8)
+  --sparc                   Use SPARC methodology
+  --monitor                 Real-time monitoring
+  --background              Run in background`,
+  });
+
+  // Temporarily commented out for Node.js compatibility
+  /*
+  commandRegistry.set('@sparkleideas/ruv-swarm', {
+    handler: ruvSwarmAction,
+    description: 'Advanced AI swarm coordination with neural capabilities',
+    usage: '@sparkleideas/ruv-swarm <command> [options]',
+    examples: [
+      '@sparkleideas/ruv-swarm init --topology mesh --max-agents 8',
+      '@sparkleideas/ruv-swarm spawn researcher --name "AI Researcher"',
+      '@sparkleideas/ruv-swarm orchestrate "Build a REST API"',
+      '@sparkleideas/ruv-swarm neural train --iterations 20',
+      '@sparkleideas/ruv-swarm benchmark --type swarm',
+      '@sparkleideas/ruv-swarm config show',
+      '@sparkleideas/ruv-swarm status --verbose'
+    ],
+    details: `
+Advanced swarm coordination features:
+  • 84.8% SWE-Bench solve rate
+  • 32.3% token reduction through coordination
+  • 2.8-4.4x speed improvement via parallel execution
+  • 27+ neural models for cognitive approaches
+  • Persistent memory across sessions
+  • Automatic topology optimization
+  
+Commands:
+  init        - Initialize swarm with specified topology
+  status      - Get current swarm status and metrics
+  spawn       - Spawn specialized agents (researcher, coder, analyst, etc.)
+  orchestrate - Coordinate complex tasks across agents
+  neural      - Neural pattern training and management
+  benchmark   - Performance testing and optimization
+  config      - Configuration management
+  memory      - Memory usage and coordination data`
+  });
+  */
+
+  // Additional @sparkleideas/ruv-swarm coordination commands - temporarily commented out
+  /*
+  commandRegistry.set('swarm-init', {
+    handler: async (args, flags) => {
+      const { ruvSwarmAction } = await import('./commands/ruv-swarm.js');
+      return ruvSwarmAction({ args: ['init', ...args], flags });
+    },
+    description: 'Quick swarm initialization with topology selection',
+    usage: 'swarm-init [--topology <type>] [--max-agents <n>] [--strategy <type>]',
+    examples: [
+      'swarm-init --topology mesh --max-agents 8',
+      'swarm-init --topology hierarchical --strategy specialized',
+      'swarm-init --topology star --max-agents 5 --strategy balanced'
+    ]
+  });
+
+  commandRegistry.set('neural-spawn', {
+    handler: async (args, flags) => {
+      const { ruvSwarmAction } = await import('./commands/ruv-swarm.js');
+      return ruvSwarmAction({ args: ['spawn', ...args], flags });
+    },
+    description: 'Spawn neural agents with cognitive capabilities',
+    usage: 'neural-spawn <type> [--name <name>] [--capabilities <list>]',
+    examples: [
+      'neural-spawn researcher --name "Data Analyst"',
+      'neural-spawn coder --capabilities "typescript,react,api"',
+      'neural-spawn coordinator --name "Project Manager"'
+    ]
+  });
+
+  commandRegistry.set('memory-coordinate', {
+    handler: async (args, flags) => {
+      const { ruvSwarmAction } = await import('./commands/ruv-swarm.js');
+      return ruvSwarmAction({ args: ['memory', ...args], flags });
+    },
+    description: 'Coordinate memory across swarm agents',
+    usage: 'memory-coordinate [--detail <level>] [--sync] [--compress]',
+    examples: [
+      'memory-coordinate --detail summary',
+      'memory-coordinate --detail detailed --sync',
+      'memory-coordinate --compress --sync'
+    ]
+  });
+
+  commandRegistry.set('config-integration', {
+    handler: configIntegrationAction,
+    description: 'Enhanced configuration management with @sparkleideas/ruv-swarm integration',
+    usage: 'config-integration <command> [options]',
+    examples: [
+      'config-integration setup --enable-ruv-swarm',
+      'config-integration preset development',
+      'config-integration sync --force',
+      'config-integration status --verbose',
+      'config-integration export my-config.json',
+      'config-integration validate --fix'
+    ],
+    details: `
+Advanced configuration management features:
+  • Unified configuration across Claude-Flow and @sparkleideas/ruv-swarm
+  • Configuration presets for different environments
+  • Automatic synchronization between config systems
+  • Import/export capabilities with validation
+  • Real-time status monitoring and validation
+  
+Presets:
+  development  - Hierarchical topology, specialized strategy, 8 agents
+  research     - Mesh topology, adaptive strategy, 12 agents  
+  production   - Star topology, balanced strategy, 6 agents
+  
+Commands:
+  setup        - Initialize @sparkleideas/ruv-swarm integration
+  sync         - Synchronize configurations
+  status       - Show integration status
+  validate     - Validate all configurations
+  preset       - Apply configuration preset
+  export       - Export unified configuration
+  import       - Import and apply configuration`
+  });
+  */
+}
+
+// Register a new command
+export function registerCommand(name, command) {
+  if (commandRegistry.has(name)) {
+    console.warn(`Command '${name}' already exists and will be overwritten`);
+  }
+
+  commandRegistry.set(name, {
+    handler: command.handler,
+    description: command.description || 'No description available',
+    usage: command.usage || `${name} [options]`,
+    examples: command.examples || [],
+    hidden: command.hidden || false,
+  });
+}
+
+// Get command handler
+export function getCommand(name) {
+  return commandRegistry.get(name);
+}
+
+// List all registered commands
+export function listCommands(includeHidden = false) {
+  const commands = [];
+  for (const [name, command] of commandRegistry.entries()) {
+    if (includeHidden || !command.hidden) {
+      commands.push({
+        name,
+        ...command,
+      });
+    }
+  }
+  return commands.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+// Check if command exists
+export function hasCommand(name) {
+  return commandRegistry.has(name);
+}
+
+// Execute a command
+export async function executeCommand(name, subArgs, flags) {
+  const command = commandRegistry.get(name);
+  if (!command) {
+    throw new Error(`Unknown command: ${name}`);
+  }
+
+  try {
+    // Track command execution for performance metrics
+    await trackCommandExecution(name, command.handler, subArgs, flags);
+  } catch (err) {
+    throw new Error(`Command '${name}' failed: ${err.message}`);
+  }
+}
+
+// Helper to show command help
+export function showCommandHelp(name) {
+  const command = commandRegistry.get(name);
+  if (!command) {
+    console.log(
+      HelpFormatter.formatError(
+        `Unknown command: ${name}`,
+        '@sparkleideas/claude-flow',
+        '@sparkleideas/claude-flow <command> [options]',
+      ),
+    );
+    return;
+  }
+
+  // If command has custom help, call it with help flag
+  if (command.customHelp) {
+    command.handler(['--help'], { help: true });
+    return;
+  }
+
+  // Convert command info to standardized format
+  const helpInfo = {
+    name: `@sparkleideas/claude-flow ${name}`,
+    description: HelpFormatter.stripFormatting(command.description),
+    usage: `@sparkleideas/claude-flow ${command.usage}`,
+    details: command.details, // Pass through the details section
+  };
+
+  // Parse examples
+  if (command.examples && command.examples.length > 0) {
+    helpInfo.examples = command.examples.map((ex) => {
+      if (ex.startsWith('npx')) {
+        return ex;
+      }
+      return `@sparkleideas/claude-flow ${ex}`;
+    });
+  }
+
+  // Parse options from details if available
+  if (command.details) {
+    const optionsMatch = command.details.match(/Options:([\s\S]*?)(?=\n\n|$)/);
+    if (optionsMatch) {
+      const optionsText = optionsMatch[1];
+      const options = [];
+      const optionLines = optionsText.split('\n').filter((line) => line.trim());
+
+      for (const line of optionLines) {
+        const match = line.match(/^\s*(--.+?)\s{2,}(.+)$/);
+        if (match) {
+          let [_, flags, description] = match;
+          // Check for default value in description
+          const defaultMatch = description.match(/\(default: (.+?)\)/);
+          const option = {
+            flags: flags.trim(),
+            description: description.replace(/\(default: .+?\)/, '').trim(),
+          };
+          if (defaultMatch) {
+            option.defaultValue = defaultMatch[1];
+          }
+          options.push(option);
+        }
+      }
+
+      if (options.length > 0) {
+        helpInfo.options = options;
+      }
+    }
+  }
+
+  console.log(HelpFormatter.formatHelp(helpInfo));
+}
+
+// Helper to show all commands
+export function showAllCommands() {
+  const commands = listCommands();
+
+  console.log('Available commands:');
+  console.log();
+
+  for (const command of commands) {
+    console.log(`  ${command.name.padEnd(12)} ${command.description}`);
+  }
+
+  console.log();
+  console.log('Use "@sparkleideas/claude-flow help <command>" for detailed usage information');
+}
+
+// Initialize the command registry
+registerCoreCommands();
+
+// Initialize performance tracking
+initializePerformanceTracking().catch(err => {
+  // Performance tracking is optional, don't fail if it errors
+  console.error('Failed to initialize performance tracking:', err.message);
+});