claude-flow 2.0.0-alpha.83 → 2.0.0-alpha.85

package/src/cli/simple-commands/stream-processor.js

@@ -0,0 +1,327 @@
+/**
+ * Stream processor for Claude stream-json output
+ * Provides real-time status updates and progress tracking
+ */
+
+import { Transform } from 'stream';
+
+export class StreamJsonProcessor extends Transform {
+  constructor(options = {}) {
+    super({ objectMode: false });
+    this.buffer = '';
+    this.agentId = options.agentId;
+    this.agentName = options.agentName || 'Agent';
+    this.agentIcon = options.agentIcon || '🤖';
+    this.taskId = options.taskId || 'unknown';
+    this.startTime = Date.now();
+    this.eventCount = 0;
+    this.lastUpdate = Date.now();
+    this.options = options;
+    this.display = options.display; // Reference to concurrent display
+  }
+
+  _transform(chunk, encoding, callback) {
+    this.buffer += chunk.toString();
+    const lines = this.buffer.split('\n');
+    this.buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      if (line.trim()) {
+        try {
+          const event = JSON.parse(line);
+          this.processEvent(event);
+        } catch (e) {
+          // Not JSON, pass through if in verbose mode
+          if (this.options.verbose) {
+            console.log(`[${this.agentName}] ${line}`);
+          }
+        }
+      }
+    }
+
+    // Update progress display periodically
+    if (Date.now() - this.lastUpdate > 1000) {
+      this.updateProgress();
+      this.lastUpdate = Date.now();
+    }
+
+    callback();
+  }
+
+  _flush(callback) {
+    if (this.buffer.trim()) {
+      try {
+        const event = JSON.parse(this.buffer);
+        this.processEvent(event);
+      } catch (e) {
+        // Ignore
+      }
+    }
+    this.showFinalStatus();
+    callback();
+  }
+
+  processEvent(event) {
+    this.eventCount++;
+    
+    // If we have a concurrent display, update it instead of console logging
+    if (this.display) {
+      this.updateDisplay(event);
+      return;
+    }
+    
+    // Handle quiet mode - show important actions and commands
+    if (this.options.verbose === false && this.options.logLevel === 'quiet') {
+      switch (event.type) {
+        case 'system':
+          if (event.subtype === 'init') {
+            console.log(`🤖 ${this.agentName} - Started`);
+          }
+          break;
+        case 'assistant':
+          // In quiet mode, still show bash commands and key actions
+          if (event.message?.content?.length > 0) {
+            const content = event.message.content[0];
+            if (content.type === 'tool_use' && content.name === 'Bash' && content.input?.command) {
+              const command = content.input.command;
+              if (command.length > 60) {
+                console.log(`  🔧 ${command.substring(0, 57)}...`);
+              } else {
+                console.log(`  🔧 ${command}`);
+              }
+            } else if (content.type === 'tool_use' && ['WebSearch', 'Read', 'Write'].includes(content.name)) {
+              const toolName = content.name.replace(/([A-Z])/g, ' $1').trim();
+              if (content.input) {
+                const firstKey = Object.keys(content.input)[0];
+                const firstValue = content.input[firstKey];
+                if (typeof firstValue === 'string' && firstValue.length < 40) {
+                  console.log(`  🔧 ${toolName}: ${firstValue}`);
+                } else {
+                  console.log(`  🔧 ${toolName}`);
+                }
+              }
+            }
+          }
+          break;
+        case 'result':
+          if (event.subtype === 'success') {
+            console.log(`✅ ${this.agentName} - Completed (${this.formatDuration(event.duration_ms)})`);
+          } else if (event.is_error) {
+            console.log(`❌ ${this.agentName} - Failed: ${event.error || 'Unknown error'}`);
+          }
+          break;
+      }
+      return;
+    }
+    
+    // Use clean, concise formatting for non-interactive mode
+    switch (event.type) {
+      case 'system':
+        if (event.subtype === 'init') {
+          console.log(`\n🤖 ${this.agentName} - Started (Session: ${event.session_id?.substring(0, 8) || 'unknown'})`);
+        }
+        break;
+        
+      case 'assistant':
+        if (event.message?.content?.length > 0) {
+          const content = event.message.content[0];
+          if (content.type === 'text') {
+            // Show only the first meaningful line, skip verbose details
+            const lines = content.text.split('\n').filter(line => line.trim());
+            if (lines.length > 0) {
+              const firstLine = lines[0].trim();
+              if (firstLine.length > 100) {
+                console.log(`💭 ${firstLine.substring(0, 97)}...`);
+              } else {
+                console.log(`💭 ${firstLine}`);
+              }
+            }
+          } else if (content.type === 'tool_use') {
+            // Show tool use with actual command/input when available
+            const toolName = content.name.replace(/([A-Z])/g, ' $1').trim();
+            
+            // For Bash tool, show the actual command
+            if (content.name === 'Bash' && content.input?.command) {
+              const command = content.input.command;
+              if (command.length > 80) {
+                console.log(`🔧 Bash: ${command.substring(0, 77)}...`);
+              } else {
+                console.log(`🔧 Bash: ${command}`);
+              }
+            }
+            // For other tools, show key parameters
+            else if (content.input && Object.keys(content.input).length > 0) {
+              const firstKey = Object.keys(content.input)[0];
+              const firstValue = content.input[firstKey];
+              
+              if (typeof firstValue === 'string' && firstValue.length < 60) {
+                console.log(`🔧 ${toolName}: ${firstValue}`);
+              } else if (typeof firstValue === 'string') {
+                console.log(`🔧 ${toolName}: ${firstValue.substring(0, 57)}...`);
+              } else {
+                console.log(`🔧 ${toolName}`);
+              }
+            } else {
+              console.log(`🔧 ${toolName}`);
+            }
+          }
+        }
+        break;
+        
+      case 'user':
+        // Tool results - show only success/failure
+        if (event.message?.content?.[0]?.type === 'tool_result') {
+          const result = event.message.content[0];
+          if (!result.is_error) {
+            console.log(`  ✅ Tool completed`);
+          } else {
+            console.log(`  ❌ Tool failed: ${result.error || 'Unknown error'}`);
+          }
+        }
+        break;
+        
+      case 'result':
+        if (event.subtype === 'success') {
+          console.log(`\n✅ ${this.agentName} - Completed (${this.formatDuration(event.duration_ms)})`);
+          if (event.total_cost_usd) {
+            console.log(`   💰 Cost: $${event.total_cost_usd.toFixed(4)}`);
+          }
+        } else if (event.is_error) {
+          console.log(`\n❌ ${this.agentName} - Failed: ${event.error || 'Unknown error'}`);
+        }
+        break;
+        
+      default:
+        // Only show important events in verbose mode
+        if (this.options.verbose && ['tool_call', 'error', 'warning'].includes(event.type)) {
+          console.log(`ℹ️  [${event.type}] ${event.message || JSON.stringify(event).substring(0, 80)}...`);
+        }
+    }
+  }
+  
+  /**
+   * Update the concurrent display instead of console
+   */
+  updateDisplay(event) {
+    switch (event.type) {
+      case 'system':
+        if (event.subtype === 'init') {
+          this.display.updateAgent(this.agentId, { status: 'active' });
+          this.display.addActivity(this.agentId, 'Initialized');
+        }
+        break;
+        
+      case 'assistant':
+        if (event.message?.content?.length > 0) {
+          const content = event.message.content[0];
+          if (content.type === 'text') {
+            const preview = content.text.substring(0, 80);
+            this.display.addActivity(this.agentId, preview);
+          } else if (content.type === 'tool_use') {
+            this.display.addActivity(this.agentId, `Using ${content.name}`, content.name);
+          }
+        }
+        break;
+        
+      case 'user':
+        // Tool results
+        if (event.message?.content?.[0]?.type === 'tool_result') {
+          const result = event.message.content[0];
+          if (!result.is_error) {
+            this.display.addActivity(this.agentId, 'Tool completed', null);
+          }
+        }
+        break;
+        
+      case 'result':
+        if (event.subtype === 'success') {
+          this.display.updateAgent(this.agentId, { 
+            status: 'completed',
+            progress: 100
+          });
+          this.display.addActivity(this.agentId, 'Task completed successfully');
+        } else if (event.is_error) {
+          this.display.updateAgent(this.agentId, { 
+            status: 'failed'
+          });
+          this.display.addActivity(this.agentId, `Failed: ${event.error || 'Unknown error'}`);
+        }
+        break;
+    }
+  }
+
+  updateProgress() {
+    // Don't show progress updates in interactive-style mode - events handle the display
+  }
+
+  showFinalStatus() {
+    const elapsed = this.formatDuration(Date.now() - this.startTime);
+    if (this.eventCount > 0) {
+      console.log(`\n📊 ${this.agentName} - Processed ${this.eventCount} events in ${elapsed}`);
+    }
+  }
+
+  getSpinner() {
+    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    return frames[Math.floor(Date.now() / 100) % frames.length];
+  }
+
+  getProgressBar(elapsed, expected) {
+    const progress = Math.min(elapsed / expected, 1);
+    const filled = Math.floor(progress * 10);
+    const empty = 10 - filled;
+    return '[' + '█'.repeat(filled) + '░'.repeat(empty) + ']';
+  }
+
+  formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    if (minutes > 0) {
+      return `${minutes}m ${seconds % 60}s`;
+    }
+    return `${seconds}s`;
+  }
+
+  formatToolParams(input) {
+    if (!input || typeof input !== 'object' || Object.keys(input).length === 0) {
+      return '';
+    }
+    
+    // Format key parameters for display
+    const keys = Object.keys(input);
+    if (keys.length === 1) {
+      const key = keys[0];
+      const value = input[key];
+      if (typeof value === 'string' && value.length < 30) {
+        return `(${key}: "${value}")`;
+      } else if (typeof value === 'number' || typeof value === 'boolean') {
+        return `(${key}: ${value})`;
+      }
+    } else if (keys.length <= 3) {
+      const params = keys.map(key => {
+        const value = input[key];
+        if (typeof value === 'string' && value.length < 20) {
+          return `${key}: "${value}"`;
+        } else if (typeof value === 'number' || typeof value === 'boolean') {
+          return `${key}: ${value}`;
+        } else {
+          return `${key}: ...`;
+        }
+      }).join(', ');
+      return `(${params})`;
+    }
+    
+    return '(...)';
+  }
+}
+
+/**
+ * Create a stream processor for an agent
+ */
+export function createStreamProcessor(agentName, agentIcon, options = {}) {
+  return new StreamJsonProcessor({
+    agentName,
+    agentIcon,
+    ...options
+  });
+}

package/src/cli/simple-commands/swarm.js

@@ -156,14 +156,17 @@ EXAMPLES:
   claude-flow swarm "Develop user registration feature" --mode distributed
   claude-flow swarm "Optimize React app performance" --strategy optimization
   claude-flow swarm "Create microservice" --executor  # Use built-in executor
+  claude-flow swarm "Build API" --claude  # Open Claude Code CLI
   claude-flow swarm "Build API endpoints" --output-format json  # Get JSON output
   claude-flow swarm "Research AI trends" --output-format json --output-file results.json
 
 DEFAULT BEHAVIOR:
-  Swarm now opens Claude Code by default with comprehensive MCP tool instructions
+  Swarm attempts to open Claude Code CLI with comprehensive MCP tool instructions
   including memory coordination, agent management, and task orchestration.
   
-  Use --executor flag to run with the built-in executor instead of Claude Code
+  If Claude CLI is not available:
+  • Use --claude flag to open Claude Code CLI
+  • Use --executor flag to run with the built-in executor
 
 STRATEGIES:
   auto           Automatically determine best approach (default)
@@ -210,6 +213,7 @@ OPTIONS:
   --verbose                  Enable detailed logging
   --dry-run                  Show configuration without executing
   --executor                 Use built-in executor instead of Claude Code
+  --claude                   Open Claude Code CLI
   --output-format <format>   Output format: json, text (default: text)
   --output-file <path>       Save output to file instead of stdout
   --no-interactive           Run in non-interactive mode (auto-enabled with --output-format json)
@@ -352,33 +356,7 @@ export async function swarmCommand(args, flags) {
     try {
       const { execSync, spawn } = await import('child_process');
 
-      // Check if claude command exists
-      let claudeAvailable = false;
-      try {
-        execSync('which claude', { stdio: 'ignore' });
-        claudeAvailable = true;
-      } catch {
-        console.log('⚠️  Claude Code CLI not found in PATH');
-        console.log('Install it with: npm install -g @anthropic-ai/claude-code');
-        console.log('\nWould spawn Claude Code with swarm objective:');
-        console.log(`📋 Objective: ${objective}`);
-        console.log(
-          '\nTo use the built-in executor instead: claude-flow swarm "objective" --executor',
-        );
-        return;
-      }
-
-      // Claude is available, use it to run swarm
-      console.log('🐝 Launching Claude Flow Swarm System...');
-      console.log(`📋 Objective: ${objective}`);
-      console.log(`🎯 Strategy: ${flags.strategy || 'auto'}`);
-      console.log(`🏗️  Mode: ${flags.mode || 'centralized'}`);
-      console.log(`🤖 Max Agents: ${flags['max-agents'] || 5}`);
-      if (isAnalysisMode) {
-        console.log(`🔍 Analysis Mode: ENABLED (Read-Only - No Code Changes)`);
-      }
-      console.log();
-
+      // Get configuration values first
       const strategy = flags.strategy || 'auto';
       const mode = flags.mode || 'centralized';
       const maxAgents = flags['max-agents'] || 5;
@@ -391,6 +369,7 @@ export async function swarmCommand(args, flags) {
       const enableSparc =
         flags.sparc !== false && (strategy === 'development' || strategy === 'auto');
 
+      // Build the complete swarm prompt before checking for claude
       const swarmPrompt = `You are orchestrating a Claude Flow Swarm with advanced MCP tool coordination.
 
 🎯 OBJECTIVE: ${objective}
@@ -787,6 +766,109 @@ Start by spawning a coordinator agent and creating the initial task structure. U
 
 The swarm should be self-documenting - use memory_store to save all important information, decisions, and results throughout the execution.`;
 
+      // If --claude flag is used, force Claude Code even if CLI not available
+      if (flags && flags.claude) {
+        console.log('🐝 Launching Claude Flow Swarm System...');
+        console.log(`📋 Objective: ${objective}`);
+        console.log(`🎯 Strategy: ${strategy}`);
+        console.log(`🏗️  Mode: ${mode}`);
+        console.log(`🤖 Max Agents: ${maxAgents}\n`);
+        
+        console.log('🚀 Launching Claude Code with Swarm Coordination');
+        console.log('─'.repeat(60));
+        
+        // Pass the prompt directly as an argument to claude
+        const claudeArgs = [swarmPrompt];
+        
+        // Add auto-permission flag by default for swarm mode (unless explicitly disabled)
+        if (flags['dangerously-skip-permissions'] !== false && !flags['no-auto-permissions']) {
+          claudeArgs.push('--dangerously-skip-permissions');
+          console.log('🔓 Using --dangerously-skip-permissions by default for seamless swarm execution');
+        }
+        
+        // Spawn claude with the prompt as the first argument (exactly like hive-mind does)
+        const claudeProcess = spawn('claude', claudeArgs, {
+          stdio: 'inherit',
+          shell: false,
+        });
+        
+        console.log('\n✓ Claude Code launched with swarm coordination prompt!');
+        console.log('  The swarm coordinator will orchestrate all agent tasks');
+        console.log('  Use MCP tools for coordination and memory sharing');
+        
+        console.log('\n💡 Pro Tips:');
+        console.log('─'.repeat(30));
+        console.log('• Use TodoWrite to track parallel tasks');
+        console.log('• Store results with mcp__claude-flow__memory_usage');
+        console.log('• Monitor progress with mcp__claude-flow__swarm_monitor');
+        console.log('• Check task status with mcp__claude-flow__task_status');
+        
+        // Set up clean termination
+        const cleanup = () => {
+          console.log('\n🛑 Shutting down swarm gracefully...');
+          if (claudeProcess && !claudeProcess.killed) {
+            claudeProcess.kill('SIGTERM');
+          }
+          process.exit(0);
+        };
+        
+        process.on('SIGINT', cleanup);
+        process.on('SIGTERM', cleanup);
+        
+        // Wait for claude to exit
+        claudeProcess.on('exit', (code) => {
+          if (code === 0) {
+            console.log('\n✓ Swarm execution completed successfully');
+          } else if (code !== null) {
+            console.log(`\n✗ Swarm execution exited with code ${code}`);
+          }
+          process.exit(code || 0);
+        });
+        
+        // Handle spawn errors (e.g., claude not found)
+        claudeProcess.on('error', (err) => {
+          if (err.code === 'ENOENT') {
+            console.error('\n❌ Claude Code CLI not found. Please install Claude Code:');
+            console.error('   https://claude.ai/download');
+          } else {
+            console.error('\n❌ Failed to launch Claude Code:', err.message);
+          }
+          process.exit(1);
+        });
+        
+        return;
+      }
+
+      // Check if claude command exists
+      let claudeAvailable = false;
+      try {
+        execSync('which claude', { stdio: 'ignore' });
+        claudeAvailable = true;
+      } catch {
+        console.log('⚠️  Claude Code CLI not found in PATH');
+        console.log('Install it with: npm install -g @anthropic-ai/claude-code');
+        console.log('Or use --claude flag to open Claude Code CLI');
+        console.log('\nWould spawn Claude Code with swarm objective:');
+        console.log(`📋 Objective: ${objective}`);
+        console.log('\nOptions:');
+        console.log('  • Use --executor flag for built-in executor: claude-flow swarm "objective" --executor');
+        console.log('  • Use --claude flag to open Claude Code CLI: claude-flow swarm "objective" --claude');
+        return;
+      }
+
+      // Claude is available, use it to run swarm
+      console.log('🐝 Launching Claude Flow Swarm System...');
+      console.log(`📋 Objective: ${objective}`);
+      console.log(`🎯 Strategy: ${flags.strategy || 'auto'}`);
+      console.log(`🏗️  Mode: ${flags.mode || 'centralized'}`);
+      console.log(`🤖 Max Agents: ${flags['max-agents'] || 5}`);
+      if (isAnalysisMode) {
+        console.log(`🔍 Analysis Mode: ENABLED (Read-Only - No Code Changes)`);
+      }
+      console.log();
+
+      // Continue with the default swarm behavior if not using --claude flag
+
       // Pass the prompt directly as an argument to claude
       const claudeArgs = [swarmPrompt];
 
@@ -812,8 +894,9 @@ The swarm should be self-documenting - use memory_store to save all important in
         claudeArgs.push('--output-format', 'stream-json'); // JSON streaming
         claudeArgs.push('--verbose'); // Verbose output
         
-        console.log('🤖 Running in non-interactive mode with Claude');
+        console.log('🤖 Running in non-interactive mode with Claude CLI');
         console.log('📋 Command: claude [prompt] -p --output-format stream-json --verbose');
+        console.log('💡 Tip: Use --claude flag to open Claude Code CLI instead');
       }
 
       // Spawn claude with the prompt as the first argument
@@ -1400,6 +1483,7 @@ OPTIONS:
   --verbose                  Enable detailed logging
   --dry-run                  Show configuration without executing
   --executor                 Use built-in executor instead of Claude Code
+  --claude                   Open Claude Code CLI
   --output-format <format>   Output format: json, text (default: text)
   --output-file <path>       Save output to file instead of stdout
   --no-interactive           Run in non-interactive mode (auto-enabled with --output-format json)