claude-flow-novice 2.0.3 → 2.0.4

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

@@ -1,258 +1,206 @@
-import {
-  printSuccess,
-  printError,
-  printWarning,
-  callRuvSwarmMCP,
-  spawnSwarmAgent,
-  getSwarmStatus,
-  checkRuvSwarmAvailable,
-} from '../utils.js';
-
+import { printSuccess, printError, printWarning, callRuvSwarmMCP, 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) {
-    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}`);
+    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();
+        }
+    } 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`);
-
+    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`);
         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
+        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)`);
     }
-  }
-
-  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}`);
+    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: