claude-flow-novice 2.0.4 → 2.0.5

package/dist/src/cli/simple-commands/coordination.js

@@ -1,206 +1,258 @@
-import { printSuccess, printError, printWarning, callRuvSwarmMCP, checkRuvSwarmAvailable } from "../utils.js";
+import {
+  printSuccess,
+  printError,
+  printWarning,
+  callRuvSwarmMCP,
+  spawnSwarmAgent,
+  getSwarmStatus,
+  checkRuvSwarmAvailable,
+} from '../utils.js';
+
 // Simple ID generator
 function generateId(prefix = 'id') {
-    return `${prefix}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  return `${prefix}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
 }
+
 export async function coordinationAction(subArgs, flags) {
-    const subcommand = subArgs[0];
-    const options = flags;
-    if (options.help || options.h || !subcommand) {
+  const subcommand = subArgs[0];
+  const options = flags;
+
+  if (options.help || options.h || !subcommand) {
+    showCoordinationHelp();
+    return;
+  }
+
+  try {
+    switch (subcommand) {
+      case 'swarm-init':
+        await swarmInitCommand(subArgs, flags);
+        break;
+      case 'agent-spawn':
+        await agentSpawnCommand(subArgs, flags);
+        break;
+      case 'task-orchestrate':
+        await taskOrchestrateCommand(subArgs, flags);
+        break;
+      default:
+        printError(`Unknown coordination command: ${subcommand}`);
         showCoordinationHelp();
-        return;
-    }
-    try {
-        switch(subcommand){
-            case 'swarm-init':
-                await swarmInitCommand(subArgs, flags);
-                break;
-            case 'agent-spawn':
-                await agentSpawnCommand(subArgs, flags);
-                break;
-            case 'task-orchestrate':
-                await taskOrchestrateCommand(subArgs, flags);
-                break;
-            default:
-                printError(`Unknown coordination command: ${subcommand}`);
-                showCoordinationHelp();
-        }
-    } catch (err) {
-        printError(`Coordination command failed: ${err.message}`);
     }
+  } catch (err) {
+    printError(`Coordination command failed: ${err.message}`);
+  }
 }
+
 async function swarmInitCommand(subArgs, flags) {
-    const options = flags;
-    const swarmId = options['swarm-id'] || options.swarmId || generateId('swarm');
-    const topology = options.topology || 'hierarchical';
-    const maxAgents = parseInt(options['max-agents'] || options.maxAgents || '5');
-    const strategy = options.strategy || 'balanced';
-    console.log(`🐝 Initializing swarm coordination...`);
-    console.log(`🆔 Swarm ID: ${swarmId}`);
-    console.log(`🏗️  Topology: ${topology}`);
-    console.log(`🤖 Max agents: ${maxAgents}`);
-    // Check if ruv-swarm is available
-    const isAvailable = await checkRuvSwarmAvailable();
-    if (isAvailable) {
-        try {
-            console.log(`\n🔄 Initializing real swarm with ruv-swarm...`);
-            // Use real ruv-swarm initialization
-            const swarmResult = await callRuvSwarmMCP('swarm_init', {
-                swarmId: swarmId,
-                topology: topology,
-                maxAgents: maxAgents,
-                strategy: strategy,
-                timestamp: Date.now()
-            });
-            if (swarmResult.success) {
-                printSuccess(`✅ Swarm coordination initialized successfully`);
-                console.log(`\n🎯 COORDINATION SETUP COMPLETE:`);
-                console.log(`  🐝 Swarm: ${swarmId}`);
-                console.log(`  🏗️  Topology: ${topology}`);
-                console.log(`  📊 Capacity: ${maxAgents} agents`);
-                console.log(`  💾 Memory: ${swarmResult.memoryStatus || 'Active'}`);
-                console.log(`  🔗 Channels: ${swarmResult.communicationChannels || 'Established'}`);
-                console.log(`  📈 Performance: ${swarmResult.expectedPerformance || 'Optimized'}`);
-            } else {
-                printError(`Swarm initialization failed: ${swarmResult.error || 'Unknown error'}`);
-            }
-        } catch (err) {
-            printError(`Swarm initialization failed: ${err.message}`);
-            console.log('Falling back to local coordination...');
-            isAvailable = false; // Trigger fallback
-        }
-    }
-    if (!isAvailable) {
-        // Fallback: Initialize coordination without ruv-swarm
-        console.log(`\n🔄 Initializing local swarm coordination...`);
-        await new Promise((resolve)=>setTimeout(resolve, 1000));
-        printSuccess(`✅ Local swarm coordination initialized successfully`);
+  const options = flags;
+  const swarmId = options['swarm-id'] || options.swarmId || generateId('swarm');
+  const topology = options.topology || 'hierarchical';
+  const maxAgents = parseInt(options['max-agents'] || options.maxAgents || '5');
+  const strategy = options.strategy || 'balanced';
+
+  console.log(`🐝 Initializing swarm coordination...`);
+  console.log(`🆔 Swarm ID: ${swarmId}`);
+  console.log(`🏗️  Topology: ${topology}`);
+  console.log(`🤖 Max agents: ${maxAgents}`);
+
+  // Check if ruv-swarm is available
+  const isAvailable = await checkRuvSwarmAvailable();
+
+  if (isAvailable) {
+    try {
+      console.log(`\n🔄 Initializing real swarm with ruv-swarm...`);
+
+      // Use real ruv-swarm initialization
+      const swarmResult = await callRuvSwarmMCP('swarm_init', {
+        swarmId: swarmId,
+        topology: topology,
+        maxAgents: maxAgents,
+        strategy: strategy,
+        timestamp: Date.now(),
+      });
+
+      if (swarmResult.success) {
+        printSuccess(`✅ Swarm coordination initialized successfully`);
+
         console.log(`\n🎯 COORDINATION SETUP COMPLETE:`);
         console.log(`  🐝 Swarm: ${swarmId}`);
         console.log(`  🏗️  Topology: ${topology}`);
         console.log(`  📊 Capacity: ${maxAgents} agents`);
-        console.log(`  💾 Memory: Local (in-memory)`);
-        console.log(`  🔗 Channels: Local coordination`);
-        console.log(`  📈 Performance: Standard`);
-        console.log(`  ⚠️  Note: Using local coordination (ruv-swarm not available)`);
+        console.log(`  💾 Memory: ${swarmResult.memoryStatus || 'Active'}`);
+        console.log(`  🔗 Channels: ${swarmResult.communicationChannels || 'Established'}`);
+        console.log(`  📈 Performance: ${swarmResult.expectedPerformance || 'Optimized'}`);
+      } else {
+        printError(`Swarm initialization failed: ${swarmResult.error || 'Unknown error'}`);
+      }
+    } catch (err) {
+      printError(`Swarm initialization failed: ${err.message}`);
+      console.log('Falling back to local coordination...');
+      isAvailable = false; // Trigger fallback
     }
-    console.log(`\n📋 NEXT STEPS:`);
-    console.log(`  1. Spawn agents: claude-flow-novice coordination agent-spawn --type <type> --swarm-id ${swarmId}`);
-    console.log(`  2. Orchestrate tasks: claude-flow-novice coordination task-orchestrate --task "<description>" --swarm-id ${swarmId}`);
-    console.log(`  3. Monitor swarm: claude-flow-novice monitoring swarm-monitor --swarm-id ${swarmId}`);
+  }
+
+  if (!isAvailable) {
+    // Fallback: Initialize coordination without ruv-swarm
+    console.log(`\n🔄 Initializing local swarm coordination...`);
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+
+    printSuccess(`✅ Local swarm coordination initialized successfully`);
+
+    console.log(`\n🎯 COORDINATION SETUP COMPLETE:`);
+    console.log(`  🐝 Swarm: ${swarmId}`);
+    console.log(`  🏗️  Topology: ${topology}`);
+    console.log(`  📊 Capacity: ${maxAgents} agents`);
+    console.log(`  💾 Memory: Local (in-memory)`);
+    console.log(`  🔗 Channels: Local coordination`);
+    console.log(`  📈 Performance: Standard`);
+    console.log(`  ⚠️  Note: Using local coordination (ruv-swarm not available)`);
+  }
+
+  console.log(`\n📋 NEXT STEPS:`);
+  console.log(
+    `  1. Spawn agents: claude-flow-novice coordination agent-spawn --type <type> --swarm-id ${swarmId}`,
+  );
+  console.log(
+    `  2. Orchestrate tasks: claude-flow-novice coordination task-orchestrate --task "<description>" --swarm-id ${swarmId}`,
+  );
+  console.log(`  3. Monitor swarm: claude-flow-novice monitoring swarm-monitor --swarm-id ${swarmId}`);
 }
+
 async function agentSpawnCommand(subArgs, flags) {
-    const options = flags;
-    let agentType = options.type || subArgs[1] || 'general';
-    const swarmId = options['swarm-id'] || options.swarmId;
-    const capabilities = options.capabilities || null;
-    // Validate agent type
-    const validTypes = [
-        'coordinator',
-        'coder',
-        'developer',
-        'researcher',
-        'analyst',
-        'analyzer',
-        'tester',
-        'architect',
-        'reviewer',
-        'optimizer',
-        'general'
-    ];
-    if (!validTypes.includes(agentType)) {
-        printWarning(`⚠️  Unknown agent type '${agentType}'. Using 'general' instead.`);
-        agentType = 'general'; // Actually change the type to general
-    }
-    const agentName = options.name || `${agentType}-${generateId('agent')}`;
-    console.log(`🤖 Spawning coordinated agent...`);
-    console.log(`🏷️  Agent type: ${agentType}`);
-    console.log(`📛 Agent name: ${agentName}`);
-    if (swarmId) console.log(`🐝 Target swarm: ${swarmId}`);
-    // Simulate agent spawning process
-    console.log(`\n🔄 Initializing agent coordination protocols...`);
-    await new Promise((resolve)=>setTimeout(resolve, 800));
-    console.log(`🧠 Loading agent capabilities and neural patterns...`);
-    await new Promise((resolve)=>setTimeout(resolve, 600));
-    console.log(`🔗 Establishing swarm communication links...`);
-    await new Promise((resolve)=>setTimeout(resolve, 500));
-    console.log(`💾 Registering agent in coordination memory...`);
-    await new Promise((resolve)=>setTimeout(resolve, 400));
-    printSuccess(`✅ Agent spawned and coordinated successfully`);
-    console.log(`\n🤖 AGENT COORDINATION DETAILS:`);
-    console.log(`  🆔 Agent ID: ${generateId('agent')}`);
-    console.log(`  🏷️  Type: ${agentType}`);
-    console.log(`  📛 Name: ${agentName}`);
-    console.log(`  🎯 Capabilities: ${getAgentCapabilities(agentType)}`);
-    console.log(`  🔗 Coordination: Active`);
-    console.log(`  💾 Memory access: Enabled`);
-    console.log(`  📊 Status: Ready for task assignment`);
-    if (swarmId) {
-        console.log(`  🐝 Swarm membership: ${swarmId}`);
-    }
+  const options = flags;
+  let agentType = options.type || subArgs[1] || 'general';
+  const swarmId = options['swarm-id'] || options.swarmId;
+  const capabilities = options.capabilities || null;
+
+  // Validate agent type
+  const validTypes = [
+    'coordinator',
+    'coder',
+    'developer',
+    'researcher',
+    'analyst',
+    'analyzer',
+    'tester',
+    'architect',
+    'reviewer',
+    'optimizer',
+    'general',
+  ];
+  if (!validTypes.includes(agentType)) {
+    printWarning(`⚠️  Unknown agent type '${agentType}'. Using 'general' instead.`);
+    agentType = 'general'; // Actually change the type to general
+  }
+
+  const agentName = options.name || `${agentType}-${generateId('agent')}`;
+
+  console.log(`🤖 Spawning coordinated agent...`);
+  console.log(`🏷️  Agent type: ${agentType}`);
+  console.log(`📛 Agent name: ${agentName}`);
+  if (swarmId) console.log(`🐝 Target swarm: ${swarmId}`);
+
+  // Simulate agent spawning process
+  console.log(`\n🔄 Initializing agent coordination protocols...`);
+  await new Promise((resolve) => setTimeout(resolve, 800));
+
+  console.log(`🧠 Loading agent capabilities and neural patterns...`);
+  await new Promise((resolve) => setTimeout(resolve, 600));
+
+  console.log(`🔗 Establishing swarm communication links...`);
+  await new Promise((resolve) => setTimeout(resolve, 500));
+
+  console.log(`💾 Registering agent in coordination memory...`);
+  await new Promise((resolve) => setTimeout(resolve, 400));
+
+  printSuccess(`✅ Agent spawned and coordinated successfully`);
+
+  console.log(`\n🤖 AGENT COORDINATION DETAILS:`);
+  console.log(`  🆔 Agent ID: ${generateId('agent')}`);
+  console.log(`  🏷️  Type: ${agentType}`);
+  console.log(`  📛 Name: ${agentName}`);
+  console.log(`  🎯 Capabilities: ${getAgentCapabilities(agentType)}`);
+  console.log(`  🔗 Coordination: Active`);
+  console.log(`  💾 Memory access: Enabled`);
+  console.log(`  📊 Status: Ready for task assignment`);
+
+  if (swarmId) {
+    console.log(`  🐝 Swarm membership: ${swarmId}`);
+  }
 }
+
 async function taskOrchestrateCommand(subArgs, flags) {
-    const options = flags;
-    const task = options.task || subArgs.slice(1).join(' ');
-    const swarmId = options['swarm-id'] || options.swarmId;
-    const strategy = options.strategy || 'adaptive';
-    const shareResults = options['share-results'] || false;
-    if (!task) {
-        printError('Task description is required');
-        return;
-    }
-    console.log(`🎯 Orchestrating task coordination...`);
-    console.log(`📋 Task: ${task}`);
-    console.log(`📊 Strategy: ${strategy}`);
-    if (swarmId) console.log(`🐝 Swarm: ${swarmId}`);
-    // Simulate task orchestration
-    console.log(`\n🔄 Analyzing task requirements...`);
-    await new Promise((resolve)=>setTimeout(resolve, 1000));
-    console.log(`🤖 Selecting optimal agents for task execution...`);
-    await new Promise((resolve)=>setTimeout(resolve, 800));
-    console.log(`📊 Configuring coordination strategy: ${strategy}...`);
-    await new Promise((resolve)=>setTimeout(resolve, 600));
-    console.log(`🔗 Establishing task communication channels...`);
-    await new Promise((resolve)=>setTimeout(resolve, 500));
-    console.log(`💾 Setting up shared task memory...`);
-    await new Promise((resolve)=>setTimeout(resolve, 400));
-    printSuccess(`✅ Task orchestration configured successfully`);
-    console.log(`\n🎯 ORCHESTRATION DETAILS:`);
-    console.log(`  📋 Task: ${task}`);
-    console.log(`  🆔 Task ID: ${generateId('task')}`);
-    console.log(`  📊 Strategy: ${strategy}`);
-    console.log(`  🤖 Assigned agents: 3 (coordinator, developer, researcher)`);
-    console.log(`  🔗 Coordination: Active`);
-    console.log(`  💾 Shared memory: Configured`);
-    console.log(`  📈 Progress tracking: Enabled`);
-    if (shareResults) {
-        console.log(`  🔄 Result sharing: Enabled across swarm`);
-    }
-    console.log(`\n📋 COORDINATION WORKFLOW:`);
-    console.log(`  1. ✅ Task analysis and decomposition complete`);
-    console.log(`  2. ✅ Agent selection and assignment complete`);
-    console.log(`  3. ✅ Communication channels established`);
-    console.log(`  4. 🔄 Task execution coordination in progress...`);
-    console.log(`  5. ⏳ Results aggregation and sharing pending`);
+  const options = flags;
+  const task = options.task || subArgs.slice(1).join(' ');
+  const swarmId = options['swarm-id'] || options.swarmId;
+  const strategy = options.strategy || 'adaptive';
+  const shareResults = options['share-results'] || false;
+
+  if (!task) {
+    printError('Task description is required');
+    return;
+  }
+
+  console.log(`🎯 Orchestrating task coordination...`);
+  console.log(`📋 Task: ${task}`);
+  console.log(`📊 Strategy: ${strategy}`);
+  if (swarmId) console.log(`🐝 Swarm: ${swarmId}`);
+
+  // Simulate task orchestration
+  console.log(`\n🔄 Analyzing task requirements...`);
+  await new Promise((resolve) => setTimeout(resolve, 1000));
+
+  console.log(`🤖 Selecting optimal agents for task execution...`);
+  await new Promise((resolve) => setTimeout(resolve, 800));
+
+  console.log(`📊 Configuring coordination strategy: ${strategy}...`);
+  await new Promise((resolve) => setTimeout(resolve, 600));
+
+  console.log(`🔗 Establishing task communication channels...`);
+  await new Promise((resolve) => setTimeout(resolve, 500));
+
+  console.log(`💾 Setting up shared task memory...`);
+  await new Promise((resolve) => setTimeout(resolve, 400));
+
+  printSuccess(`✅ Task orchestration configured successfully`);
+
+  console.log(`\n🎯 ORCHESTRATION DETAILS:`);
+  console.log(`  📋 Task: ${task}`);
+  console.log(`  🆔 Task ID: ${generateId('task')}`);
+  console.log(`  📊 Strategy: ${strategy}`);
+  console.log(`  🤖 Assigned agents: 3 (coordinator, developer, researcher)`);
+  console.log(`  🔗 Coordination: Active`);
+  console.log(`  💾 Shared memory: Configured`);
+  console.log(`  📈 Progress tracking: Enabled`);
+
+  if (shareResults) {
+    console.log(`  🔄 Result sharing: Enabled across swarm`);
+  }
+
+  console.log(`\n📋 COORDINATION WORKFLOW:`);
+  console.log(`  1. ✅ Task analysis and decomposition complete`);
+  console.log(`  2. ✅ Agent selection and assignment complete`);
+  console.log(`  3. ✅ Communication channels established`);
+  console.log(`  4. 🔄 Task execution coordination in progress...`);
+  console.log(`  5. ⏳ Results aggregation and sharing pending`);
 }
+
 function getAgentCapabilities(type) {
-    const capabilities = {
-        coordinator: 'Task orchestration, agent management, workflow coordination',
-        coder: 'Code implementation, debugging, technical development',
-        developer: 'Code implementation, debugging, technical development',
-        researcher: 'Information gathering, analysis, documentation',
-        analyst: 'Data analysis, performance monitoring, metrics',
-        analyzer: 'Data analysis, performance monitoring, metrics',
-        tester: 'Quality assurance, test automation, validation',
-        architect: 'System design, architecture planning, technical strategy',
-        reviewer: 'Code review, quality assessment, best practices',
-        optimizer: 'Performance optimization, efficiency improvement, bottleneck analysis',
-        general: 'Multi-purpose coordination and development'
-    };
-    return capabilities[type] || capabilities.general;
+  const capabilities = {
+    coordinator: 'Task orchestration, agent management, workflow coordination',
+    coder: 'Code implementation, debugging, technical development',
+    developer: 'Code implementation, debugging, technical development',
+    researcher: 'Information gathering, analysis, documentation',
+    analyst: 'Data analysis, performance monitoring, metrics',
+    analyzer: 'Data analysis, performance monitoring, metrics',
+    tester: 'Quality assurance, test automation, validation',
+    architect: 'System design, architecture planning, technical strategy',
+    reviewer: 'Code review, quality assessment, best practices',
+    optimizer: 'Performance optimization, efficiency improvement, bottleneck analysis',
+    general: 'Multi-purpose coordination and development',
+  };
+  return capabilities[type] || capabilities.general;
 }
+
 function showCoordinationHelp() {
-    console.log(`
+  console.log(`
 🐝 Coordination Commands - Swarm & Agent Orchestration
 
 USAGE: