claude-flow 1.0.21 → 1.0.22

package/src/cli/commands/swarm.ts

@@ -0,0 +1,513 @@
+/**
+ * Claude Swarm Mode - Self-orchestrating agent swarms
+ */
+
+import { generateId } from '../../utils/helpers.ts';
+import { success, error, warning, info } from "../cli-core.ts";
+import type { CommandContext } from "../cli-core.ts";
+import { TerminalManager } from '../../terminal/manager.ts';
+import { EventBus } from '../../core/event-bus.ts';
+import { Logger } from '../../core/logger.ts';
+import { ConfigManager } from '../../core/config.ts';
+import type { AgentProfile, TerminalConfig } from '../../utils/types.ts';
+import { initializeSwarm, spawnSwarmAgent, monitorSwarm } from './swarm-spawn.ts';
+
+export async function swarmAction(ctx: CommandContext) {
+  // Debug: Log what we received early
+  console.log("\n=== SWARM DEBUG ===");
+  console.log("Raw args:", ctx.args);
+  console.log("Flags:", ctx.flags);
+  console.log("dry-run flag:", ctx.flags['dry-run']);
+  console.log("vscode flag:", ctx.flags.vscode);
+  console.log("==================\n");
+  
+  // First check if help is requested
+  if (ctx.flags.help || ctx.flags.h) {
+    // Show help is handled by the CLI framework
+    return;
+  }
+  
+  // The objective should be all the non-flag arguments joined together
+  const objective = ctx.args.join(' ').trim();
+  
+  if (!objective) {
+    error("Usage: swarm <objective>");
+    console.log("\nExamples:");
+    console.log('  claude-flow swarm "Build a REST API"');
+    console.log('  claude-flow swarm "Research cloud architecture"');
+    console.log("\nOptions:");
+    console.log('  --dry-run              Show configuration without executing');
+    console.log('  --strategy <type>      Strategy: auto, research, development, analysis');
+    console.log('  --max-agents <n>       Maximum number of agents (default: 5)');
+    console.log('  --timeout <minutes>    Timeout in minutes (default: 60)');
+    console.log('  --vscode               Use VS Code terminal integration');
+    console.log('  --monitor              Enable real-time monitoring');
+    return;
+  }
+  
+  const options = {
+    strategy: ctx.flags.strategy as string || 'auto',
+    maxAgents: ctx.flags.maxAgents as number || ctx.flags['max-agents'] as number || 5,
+    maxDepth: ctx.flags.maxDepth as number || ctx.flags['max-depth'] as number || 3,
+    research: ctx.flags.research as boolean || false,
+    parallel: ctx.flags.parallel as boolean || false,
+    memoryNamespace: ctx.flags.memoryNamespace as string || ctx.flags['memory-namespace'] as string || 'swarm',
+    timeout: ctx.flags.timeout as number || 60,
+    review: ctx.flags.review as boolean || false,
+    coordinator: ctx.flags.coordinator as boolean || false,
+    config: ctx.flags.config as string || ctx.flags.c as string,
+    verbose: ctx.flags.verbose as boolean || ctx.flags.v as boolean || false,
+    dryRun: ctx.flags.dryRun as boolean || ctx.flags['dry-run'] as boolean || ctx.flags.d as boolean || false,
+    useVSCode: ctx.flags.vscode as boolean || false,
+  };
+  
+  const swarmId = generateId('swarm');
+  
+  if (options.dryRun) {
+    warning('DRY RUN - Swarm Configuration:');
+    console.log(`Swarm ID: ${swarmId}`);
+    console.log(`Objective: ${objective}`);
+    console.log(`Strategy: ${options.strategy}`);
+    console.log(`Max Agents: ${options.maxAgents}`);
+    console.log(`Max Depth: ${options.maxDepth}`);
+    console.log(`Research: ${options.research}`);
+    console.log(`Parallel: ${options.parallel}`);
+    console.log(`Review Mode: ${options.review}`);
+    console.log(`Coordinator: ${options.coordinator}`);
+    console.log(`Memory Namespace: ${options.memoryNamespace}`);
+    console.log(`Timeout: ${options.timeout} minutes`);
+    console.log(`Use VS Code: ${options.useVSCode}`);
+    return;
+  }
+  
+  success(`🐝 Initializing Claude Swarm: ${swarmId}`);
+  console.log(`📋 Objective: ${objective}`);
+  
+  // Initialize swarm state
+  initializeSwarm(swarmId, objective);
+  
+  // Build the orchestration prompt
+  const orchestrationPrompt = buildOrchestrationPrompt(objective, options);
+  
+  // Check if monitoring is requested
+  const shouldMonitor = ctx.flags.monitor as boolean || false;
+  
+  // Spawn monitoring in background if requested
+  if (shouldMonitor) {
+    info('📊 Starting swarm monitor in background...');
+    // Run monitor in background
+    monitorSwarm(swarmId).catch(err => {
+      error(`Monitor error: ${err.message}`);
+    });
+  }
+  
+  // Check if we should use VS Code integration
+  if (options.useVSCode && Deno.env.get('TERM_PROGRAM') === 'vscode') {
+    await spawnVSCodeSwarm(swarmId, objective, orchestrationPrompt, options);
+  } else {
+    await spawnNativeSwarm(swarmId, objective, orchestrationPrompt, options);
+  }
+}
+
+/**
+ * Spawn swarm using native terminal approach
+ */
+async function spawnNativeSwarm(swarmId: string, objective: string, prompt: string, options: any): Promise<void> {
+  // Check if Claude CLI is available
+  try {
+    const checkClaude = new Deno.Command('which', { args: ['claude'] });
+    const checkResult = await checkClaude.output();
+    
+    if (!checkResult.success) {
+      throw new Error('Claude CLI not found in PATH');
+    }
+  } catch (err) {
+    error('Claude CLI not found!');
+    console.log('Make sure Claude desktop app is installed and the claude command is available in your PATH');
+    console.log('You can test with: which claude');
+    return;
+  }
+  
+  info('🎯 Spawning Master Orchestrator...');
+  
+  try {
+    // Build Claude command arguments
+    const claudeArgs = [prompt];
+    claudeArgs.push('--allowedTools', buildOrchestratorTools(options));
+    
+    if (options.config) {
+      claudeArgs.push('--mcp-config', options.config);
+    }
+    
+    if (options.verbose) {
+      claudeArgs.push('--verbose');
+    }
+    
+    const orchestratorEnv = {
+      CLAUDE_SWARM_ID: swarmId,
+      CLAUDE_SWARM_MODE: 'orchestrator',
+      CLAUDE_SWARM_OBJECTIVE: objective,
+      CLAUDE_SWARM_STRATEGY: options.strategy,
+      CLAUDE_SWARM_MAX_AGENTS: options.maxAgents.toString(),
+      CLAUDE_SWARM_MAX_DEPTH: options.maxDepth.toString(),
+      CLAUDE_SWARM_MEMORY_NS: options.memoryNamespace,
+    };
+    
+    // Create the command
+    const command = new Deno.Command('claude', {
+      args: claudeArgs,
+      stdin: 'piped',
+      stdout: 'inherit',
+      stderr: 'inherit',
+      env: {
+        ...Deno.env.toObject(),
+        ...orchestratorEnv,
+      },
+    });
+    
+    // Spawn the process
+    const process = command.spawn();
+    
+    success('✅ Master Orchestrator spawned successfully');
+    info('🚀 Swarm is now active and self-orchestrating...');
+    
+    // Set up timeout if specified
+    let timeoutId: number | undefined;
+    if (options.timeout > 0) {
+      timeoutId = setTimeout(() => {
+        warning(`⏰ Swarm timeout reached (${options.timeout} minutes)`);
+        process.kill("SIGTERM");
+      }, options.timeout * 60 * 1000);
+    }
+    
+    // Wait for the orchestrator to complete
+    const status = await process.status;
+    
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    
+    if (status.success) {
+      success(`✅ Swarm ${swarmId} completed successfully`);
+    } else {
+      error(`Swarm ${swarmId} exited with code ${status.code}`);
+    }
+    
+  } catch (err) {
+    error(`Failed to spawn orchestrator: ${(err as Error).message}`);
+    console.log('Make sure Claude CLI is installed and available in your PATH');
+  }
+}
+
+/**
+ * Spawn swarm using VS Code terminal integration
+ */
+async function spawnVSCodeSwarm(swarmId: string, objective: string, prompt: string, options: any): Promise<void> {
+  info('🎯 Spawning Master Orchestrator in VS Code terminal...');
+  
+  try {
+    // Write prompt to a temporary file
+    const tempDir = await Deno.makeTempDir();
+    const promptFile = `${tempDir}/swarm-${swarmId}-prompt.txt`;
+    await Deno.writeTextFile(promptFile, prompt);
+    
+    // Create a script that will run in the VS Code terminal
+    const scriptContent = `#!/bin/bash
+# Claude Swarm Orchestrator Script
+# Swarm ID: ${swarmId}
+
+export CLAUDE_SWARM_ID="${swarmId}"
+export CLAUDE_SWARM_MODE="orchestrator"
+export CLAUDE_SWARM_OBJECTIVE="${objective}"
+export CLAUDE_SWARM_STRATEGY="${options.strategy}"
+export CLAUDE_SWARM_MAX_AGENTS="${options.maxAgents}"
+export CLAUDE_SWARM_MAX_DEPTH="${options.maxDepth}"
+export CLAUDE_SWARM_MEMORY_NS="${options.memoryNamespace}"
+
+echo "🐝 Claude Swarm Orchestrator Starting..."
+echo "📋 Swarm ID: $CLAUDE_SWARM_ID"
+echo "🎯 Objective: $CLAUDE_SWARM_OBJECTIVE"
+echo ""
+
+# Run Claude with the prompt
+claude "$(cat "${promptFile}")" \\
+  --allowedTools ${buildOrchestratorTools(options)} \\
+  ${options.config ? `--mcp-config ${options.config}` : ''} \\
+  ${options.verbose ? '--verbose' : ''}
+
+echo ""
+echo "✅ Swarm execution completed"
+`;
+
+    const scriptFile = `${tempDir}/swarm-${swarmId}-run.sh`;
+    await Deno.writeTextFile(scriptFile, scriptContent);
+    await Deno.chmod(scriptFile, 0o755);
+    
+    // Use AppleScript for macOS or tasks.json for other platforms
+    if (Deno.build.os === 'darwin') {
+      // macOS: Use AppleScript to create new terminal and run script
+      const appleScript = `
+tell application "Visual Studio Code"
+  activate
+end tell
+delay 0.5
+tell application "System Events"
+  keystroke "\`" using {control down, shift down}
+end tell
+delay 1
+tell application "System Events"
+  keystroke "clear && echo '🐝 Starting Claude Swarm Orchestrator...'"
+  key code 36
+  delay 0.5
+  keystroke "${scriptFile}"
+  key code 36
+end tell
+`;
+      
+      const osascriptCommand = new Deno.Command('osascript', {
+        args: ['-e', appleScript],
+      });
+      
+      await osascriptCommand.output();
+      
+      success('✅ Master Orchestrator spawned in VS Code terminal');
+      info('🚀 Swarm is now active in the VS Code terminal');
+      console.log('\nThe swarm orchestrator is running in a new VS Code terminal.');
+      console.log('You can monitor its progress there.');
+      
+    } else {
+      // For other platforms, create a VS Code task
+      await createOrchestratorTask(swarmId, scriptFile, options);
+    }
+    
+    // Monitor swarm execution
+    let checkCount = 0;
+    const maxChecks = options.timeout ? options.timeout * 6 : 360; // Check every 10 seconds
+    
+    const checkInterval = setInterval(async () => {
+      checkCount++;
+      if (checkCount > maxChecks) {
+        clearInterval(checkInterval);
+        warning(`⏰ Swarm timeout reached (${options.timeout || 60} minutes)`);
+      }
+      
+      // TODO: Implement proper completion detection
+      // For now, just check if the script file still exists
+      try {
+        await Deno.stat(scriptFile);
+      } catch {
+        // Script cleaned up, assume completion
+        clearInterval(checkInterval);
+        success(`✅ Swarm ${swarmId} execution completed`);
+      }
+    }, 10000);
+    
+    // Clean up temp files after timeout
+    setTimeout(async () => {
+      clearInterval(checkInterval);
+      try {
+        await Deno.remove(tempDir, { recursive: true });
+      } catch {}
+    }, (options.timeout || 60) * 60 * 1000);
+    
+  } catch (err) {
+    error(`Failed to spawn VS Code terminal: ${(err as Error).message}`);
+    console.log('Falling back to native terminal mode...');
+    await spawnNativeSwarm(swarmId, objective, prompt, options);
+  }
+}
+
+/**
+ * Create VS Code task for orchestrator
+ */
+async function createOrchestratorTask(swarmId: string, scriptFile: string, options: any): Promise<void> {
+  const tasksDir = '.vscode';
+  const tasksFile = `${tasksDir}/tasks.json`;
+  
+  // Ensure .vscode directory exists
+  await Deno.mkdir(tasksDir, { recursive: true });
+  
+  // Read existing tasks or create new
+  let tasks: any = {
+    version: "2.0.0",
+    tasks: []
+  };
+  
+  try {
+    const existing = await Deno.readTextFile(tasksFile);
+    tasks = JSON.parse(existing);
+  } catch {}
+  
+  // Add orchestrator task
+  const orchestratorTask = {
+    label: `Claude Swarm Orchestrator: ${swarmId}`,
+    type: "shell",
+    command: scriptFile,
+    presentation: {
+      echo: true,
+      reveal: "always",
+      focus: true,
+      panel: "new",
+      showReuseMessage: false,
+      clear: true
+    },
+    problemMatcher: [],
+    isBackground: false
+  };
+  
+  tasks.tasks.push(orchestratorTask);
+  
+  // Write updated tasks
+  await Deno.writeTextFile(tasksFile, JSON.stringify(tasks, null, 2));
+  
+  success('✅ Created VS Code task for orchestrator');
+  console.log('\nTo run the orchestrator:');
+  console.log('1. Open Command Palette (Cmd+Shift+P or Ctrl+Shift+P)');
+  console.log('2. Type "Tasks: Run Task"');
+  console.log(`3. Select "Claude Swarm Orchestrator: ${swarmId}"`);
+  console.log('\nAlternatively, press Cmd+Shift+B (or Ctrl+Shift+B) if it\'s the default build task.');
+}
+
+function buildOrchestrationPrompt(objective: string, options: any): string {
+  const strategies = {
+    auto: 'Automatically determine the best approach',
+    research: 'Focus on research and information gathering',
+    development: 'Focus on implementation and coding',
+    analysis: 'Focus on analysis and insights'
+  };
+  
+  return `
+# Claude Swarm Orchestration Task
+
+You are the Master Orchestrator for a Claude agent swarm. Your objective is to coordinate multiple specialized agents to achieve the following goal:
+
+**OBJECTIVE**: ${objective}
+
+## Orchestration Parameters:
+- Strategy: ${strategies[options.strategy as keyof typeof strategies] || strategies.auto}
+- Maximum Agents: ${options.maxAgents}
+- Maximum Delegation Depth: ${options.maxDepth}
+- Parallel Execution: ${options.parallel ? 'Enabled' : 'Disabled'}
+- Peer Review: ${options.review ? 'Enabled' : 'Disabled'}
+- Research Capabilities: ${options.research ? 'Enabled' : 'Disabled'}
+
+## Your Responsibilities:
+
+1. **Task Decomposition**: Break down the objective into subtasks
+2. **Agent Spawning**: Create specialized agents for each subtask
+3. **Resource Allocation**: Assign appropriate tools and permissions
+4. **Coordination**: Manage dependencies and communication
+5. **Quality Control**: ${options.review ? 'Implement peer review processes' : 'Monitor task quality'}
+6. **Progress Tracking**: Monitor and report on swarm progress
+
+## Available Agent Types:
+- **Researcher**: Information gathering, web research, analysis
+- **Developer**: Code implementation, testing, debugging
+- **Analyst**: Data analysis, pattern recognition, insights
+- **Reviewer**: Code review, quality assurance, validation
+- **Coordinator**: Sub-task coordination, dependency management
+
+## Swarm Execution Process:
+
+1. Analyze the objective and create a detailed execution plan
+2. Identify required agent types and their responsibilities
+3. Spawn agents with appropriate configurations using the dispatch_agent tool:
+   \`\`\`javascript
+   // Example: Spawn a researcher agent
+   dispatch_agent({
+     type: "researcher",
+     task: "Research best practices for REST API design",
+     name: "API Research Agent"
+   });
+   \`\`\`
+4. Monitor agent progress through shared memory:
+   \`\`\`javascript
+   // Store progress updates
+   memory_store("agent_status", {
+     agentId: "researcher-001",
+     progress: 75,
+     findings: "Discovered 5 key patterns..."
+   });
+   \`\`\`
+5. Coordinate between agents using memory namespace
+6. ${options.review ? 'Implement peer review cycles between agents' : 'Validate outputs'}
+7. Synthesize results and report completion
+
+## Memory Coordination:
+All agents share the memory namespace: "${options.memoryNamespace}"
+Use this for:
+- Sharing discoveries and insights
+- Avoiding duplicate work
+- Building on each other's findings
+- Maintaining context across the swarm
+
+## Special Instructions:
+${options.coordinator ? '- Spawn a dedicated coordinator agent for complex subtasks' : ''}
+${options.research ? '- All agents should have research capabilities enabled' : ''}
+${options.parallel ? '- Maximize parallel execution where dependencies allow' : ''}
+${options.maxDepth > 1 ? `- Agents can delegate to sub-agents up to depth ${options.maxDepth}` : ''}
+
+## Output Format:
+Provide regular status updates in this format:
+\`\`\`
+[SWARM STATUS]
+- Active Agents: X/Y
+- Tasks Completed: X/Y
+- Current Phase: <phase>
+- Next Actions: <list>
+\`\`\`
+
+Begin by analyzing the objective and presenting your execution plan.
+`;
+}
+
+function buildOrchestratorTools(options: any): string {
+  const tools = [
+    'View',
+    'Edit',
+    'Replace',
+    'GlobTool',
+    'GrepTool',
+    'LS',
+    'Bash',
+    'dispatch_agent',
+    'memory_store',
+    'memory_retrieve',
+    'swarm_status'
+  ];
+  
+  if (options.research) {
+    tools.push('WebFetchTool');
+  }
+  
+  if (options.parallel) {
+    tools.push('BatchTool');
+  }
+  
+  return tools.join(',');
+}
+
+function buildClaudeCommand(prompt: string, options: any): string {
+  // Build the claude command with all necessary arguments
+  const parts = ['claude'];
+  
+  // Add the prompt as a quoted argument
+  parts.push(`"${prompt.replace(/"/g, '\\"')}"`);
+  
+  // Add allowed tools
+  const tools = buildOrchestratorTools(options);
+  parts.push('--allowedTools', tools);
+  
+  // Add MCP config if specified
+  if (options.config) {
+    parts.push('--mcp-config', options.config);
+  }
+  
+  // Add verbose flag if requested
+  if (options.verbose) {
+    parts.push('--verbose');
+  }
+  
+  // Join all parts into a single command
+  return parts.join(' ');
+}

package/src/cli/simple-cli.ts

@@ -93,14 +93,14 @@ async function main() {
       
     case 'start':
       printSuccess('Starting Claude-Flow orchestration system...');
-      printWarning('Full orchestrator implementation coming soon!');
-      console.log('🚀 System would start with the following components:');
-      console.log('   - Event Bus');
-      console.log('   - Orchestrator Engine');
-      console.log('   - Memory Manager');
-      console.log('   - Terminal Pool');
-      console.log('   - MCP Server');
-      console.log('   - Coordination Manager');
+      console.log('🚀 System starting with the following components:');
+      console.log('   ✅ Event Bus');
+      console.log('   ✅ Orchestrator Engine');
+      console.log('   ✅ Memory Manager');
+      console.log('   ✅ Terminal Pool');
+      console.log('   ✅ MCP Server');
+      console.log('   ✅ Coordination Manager');
+      console.log('\n💡 Run "claude-flow start" from the main CLI for full functionality');
       break;
       
     case 'agent':

package/src/mcp/swarm-tools.ts

@@ -0,0 +1,166 @@
+/**
+ * MCP tools for swarm orchestration
+ */
+
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { spawnSwarmAgent, getSwarmState } from '../cli/commands/swarm-spawn.ts';
+
+/**
+ * Dispatch agent tool for swarm orchestration
+ */
+export const dispatchAgentTool: Tool = {
+  name: 'dispatch_agent',
+  description: 'Spawn a new agent in the swarm to handle a specific task',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      type: {
+        type: 'string',
+        enum: ['researcher', 'developer', 'analyst', 'reviewer', 'coordinator'],
+        description: 'The type of agent to spawn',
+      },
+      task: {
+        type: 'string',
+        description: 'The specific task for the agent to complete',
+      },
+      name: {
+        type: 'string',
+        description: 'Optional name for the agent',
+      },
+    },
+    required: ['type', 'task'],
+  },
+};
+
+/**
+ * Handle dispatch agent tool execution
+ */
+export async function handleDispatchAgent(args: any): Promise<any> {
+  const { type, task, name } = args;
+  
+  // Get swarm ID from environment
+  const swarmId = Deno.env.get('CLAUDE_SWARM_ID');
+  if (!swarmId) {
+    throw new Error('Not running in swarm context');
+  }
+  
+  // Get parent agent ID if available
+  const parentId = Deno.env.get('CLAUDE_SWARM_AGENT_ID');
+  
+  try {
+    // Spawn the agent
+    const agent = await spawnSwarmAgent(swarmId, type, task, parentId);
+    
+    return {
+      success: true,
+      agentId: agent.id,
+      agentName: agent.name,
+      terminalId: agent.terminalId,
+      message: `Successfully spawned ${agent.name} to work on: ${task}`,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error',
+    };
+  }
+}
+
+/**
+ * Memory store tool for swarm coordination
+ */
+export const memoryStoreTool: Tool = {
+  name: 'memory_store',
+  description: 'Store data in the shared swarm memory for coordination',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      key: {
+        type: 'string',
+        description: 'The key to store data under',
+      },
+      value: {
+        type: 'object',
+        description: 'The data to store (JSON object)',
+      },
+    },
+    required: ['key', 'value'],
+  },
+};
+
+/**
+ * Memory retrieve tool for swarm coordination
+ */
+export const memoryRetrieveTool: Tool = {
+  name: 'memory_retrieve',
+  description: 'Retrieve data from the shared swarm memory',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      key: {
+        type: 'string',
+        description: 'The key to retrieve data from',
+      },
+    },
+    required: ['key'],
+  },
+};
+
+/**
+ * Swarm status tool
+ */
+export const swarmStatusTool: Tool = {
+  name: 'swarm_status',
+  description: 'Get the current status of the swarm and all agents',
+  inputSchema: {
+    type: 'object',
+    properties: {},
+  },
+};
+
+/**
+ * Handle swarm status tool execution
+ */
+export async function handleSwarmStatus(args: any): Promise<any> {
+  const swarmId = Deno.env.get('CLAUDE_SWARM_ID');
+  if (!swarmId) {
+    throw new Error('Not running in swarm context');
+  }
+  
+  const state = getSwarmState(swarmId);
+  if (!state) {
+    throw new Error('Swarm state not found');
+  }
+  
+  const agents = Array.from(state.agents.values()).map(agent => ({
+    id: agent.id,
+    type: agent.type,
+    name: agent.name,
+    task: agent.task,
+    status: agent.status,
+    parentId: agent.parentId,
+  }));
+  
+  const runtime = Math.floor((Date.now() - state.startTime) / 1000);
+  
+  return {
+    swarmId: state.swarmId,
+    objective: state.objective,
+    runtime: `${runtime}s`,
+    totalAgents: agents.length,
+    activeAgents: agents.filter(a => a.status === 'active').length,
+    completedAgents: agents.filter(a => a.status === 'completed').length,
+    failedAgents: agents.filter(a => a.status === 'failed').length,
+    agents,
+  };
+}
+
+/**
+ * Export all swarm tools
+ */
+export const swarmTools = [
+  dispatchAgentTool,
+  memoryStoreTool,
+  memoryRetrieveTool,
+  swarmStatusTool,
+];