claude-flow 2.0.0-alpha.60 → 2.0.0-alpha.62

package/src/cli/commands/ruv-swarm.ts

@@ -1,20 +1,19 @@
-import { getErrorMessage } from '../../utils/error-handler.js';
 /**
  * ruv-swarm CLI commands for Claude Code integration
- * 
+ *
  * This module provides CLI commands that interact with the ruv-swarm
  * package to enable advanced swarm coordination and neural capabilities.
  */
 
-import { success, error, warning, info } from "../cli-core.js";
-import type { CommandContext } from "../cli-core.js";
+import { success, error, warning, info } from '../cli-core.js';
+import type { CommandContext } from '../cli-core.js';
 import { getRuvSwarmConfigManager } from '../../config/ruv-swarm-config.js';
 import { execAsync } from '../../utils/helpers.js';
 import { Logger } from '../../core/logger.js';
 import { isRuvSwarmAvailable, initializeRuvSwarmIntegration } from '../../mcp/ruv-swarm-tools.js';
 
 // Create logger for CLI commands
-const logger = new Logger({ level: "info", format: "text", destination: "console" });
+const logger = new Logger({ level: 'info', format: 'text', destination: 'console' });
 
 /**
  * Main ruv-swarm command handler
@@ -24,14 +23,14 @@ export async function ruvSwarmAction(ctx: CommandContext) {
     showRuvSwarmHelp();
     return;
   }
-  
+
   const subcommand = ctx.args[0];
   const subArgs = ctx.args.slice(1);
   const subCtx: CommandContext = {
     ...ctx,
-    args: subArgs
+    args: subArgs,
   };
-  
+
   try {
     // Check if ruv-swarm is available first
     const available = await isRuvSwarmAvailable(logger);
@@ -41,7 +40,7 @@ export async function ruvSwarmAction(ctx: CommandContext) {
       console.log('Or locally: npm install ruv-swarm');
       return;
     }
-    
+
     switch (subcommand) {
       case 'init':
         await handleInit(subCtx);
@@ -87,13 +86,17 @@ export async function ruvSwarmAction(ctx: CommandContext) {
  * Show ruv-swarm help
  */
 function showRuvSwarmHelp() {
-  console.log('ruv-swarm - Advanced AI swarm coordination with neural capabilities\
-');
-  
+  console.log(
+    'ruv-swarm - Advanced AI swarm coordination with neural capabilities\
+',
+  );
+
   console.log('Usage:');
-  console.log('  claude-flow ruv-swarm <command> [options]\
-');
-  
+  console.log(
+    '  claude-flow ruv-swarm <command> [options]\
+',
+  );
+
   console.log('Commands:');
   console.log('  init                       Initialize a new ruv-swarm');
   console.log('  status [--verbose]         Get swarm status');
@@ -104,9 +107,11 @@ function showRuvSwarmHelp() {
   console.log('  neural <subcommand>        Neural capabilities management');
   console.log('  benchmark [--type]         Run performance benchmarks');
   console.log('  config <subcommand>        Configuration management');
-  console.log('  memory [--detail]          Memory usage and management\
-');
-  
+  console.log(
+    '  memory [--detail]          Memory usage and management\
+',
+  );
+
   console.log('Examples:');
   console.log('  claude-flow ruv-swarm init --topology mesh --max-agents 8');
   console.log('  claude-flow ruv-swarm spawn researcher --name \"AI Researcher\"');
@@ -119,31 +124,31 @@ function showRuvSwarmHelp() {
  * Handle swarm initialization
  */
 async function handleInit(ctx: CommandContext) {
-  const topology = ctx.flags.topology as string || 'mesh';
-  const maxAgents = ctx.flags.maxAgents as number || ctx.flags['max-agents'] as number || 5;
-  const strategy = ctx.flags.strategy as string || 'balanced';
-  
+  const topology = (ctx.flags.topology as string) || 'mesh';
+  const maxAgents = (ctx.flags.maxAgents as number) || (ctx.flags['max-agents'] as number) || 5;
+  const strategy = (ctx.flags.strategy as string) || 'balanced';
+
   if (!['mesh', 'hierarchical', 'ring', 'star'].includes(topology)) {
     error('Invalid topology. Use: mesh, hierarchical, ring, or star');
     return;
   }
-  
+
   if (maxAgents < 1 || maxAgents > 100) {
     error('Max agents must be between 1 and 100');
     return;
   }
-  
+
   info(`Initializing ruv-swarm with ${topology} topology...`);
-  
+
   try {
     const command = `npx ruv-swarm swarm init --topology ${topology} --max-agents ${maxAgents} --strategy ${strategy}`;
     const result = await execAsync(command);
-    
+
     if (result.stdout) {
       success('Swarm initialized successfully!');
       console.log(result.stdout);
     }
-    
+
     // Initialize integration
     const integration = await initializeRuvSwarmIntegration(process.cwd(), logger);
     if (integration.success) {
@@ -151,7 +156,6 @@ async function handleInit(ctx: CommandContext) {
     } else {
       warning(`Integration warning: ${integration.error}`);
     }
-    
   } catch (err) {
     error(`Failed to initialize swarm: ${(err as Error).message}`);
   }
@@ -161,21 +165,23 @@ async function handleInit(ctx: CommandContext) {
  * Handle swarm status
  */
 async function handleStatus(ctx: CommandContext) {
-  const verbose = ctx.flags.verbose as boolean || ctx.flags.v as boolean || false;
-  
+  const verbose = (ctx.flags.verbose as boolean) || (ctx.flags.v as boolean) || false;
+
   try {
     const command = `npx ruv-swarm swarm status${verbose ? ' --verbose' : ''}`;
     const result = await execAsync(command);
-    
+
     if (result.stdout) {
       // Try to parse as JSON for better formatting
       try {
         const statusData = JSON.parse(result.stdout);
-        
+
         if (statusData.success && statusData.data) {
-          console.log('🐝 Swarm Status:\
-');
-          
+          console.log(
+            '🐝 Swarm Status:\
+',
+          );
+
           const data = statusData.data;
           if (data.swarmId) {
             console.log(`  Swarm ID: ${data.swarmId}`);
@@ -187,15 +193,19 @@ async function handleStatus(ctx: CommandContext) {
             console.log(`  Active Agents: ${data.agents.active || 0}/${data.agents.total || 0}`);
           }
           if (data.tasks !== undefined) {
-            console.log(`  Tasks: ${data.tasks.completed || 0} completed, ${data.tasks.running || 0} running`);
+            console.log(
+              `  Tasks: ${data.tasks.completed || 0} completed, ${data.tasks.running || 0} running`,
+            );
           }
           if (data.memory) {
             console.log(`  Memory Usage: ${data.memory.used || 'N/A'}`);
           }
-          
+
           if (verbose && data.details) {
-            console.log('\
-📋 Detailed Status:');
+            console.log(
+              '\
+📋 Detailed Status:',
+            );
             console.log(JSON.stringify(data.details, null, 2));
           }
         } else {
@@ -206,11 +216,10 @@ async function handleStatus(ctx: CommandContext) {
         console.log(result.stdout);
       }
     }
-    
+
     if (result.stderr) {
       warning(result.stderr);
     }
-    
   } catch (err) {
     error(`Failed to get swarm status: ${(err as Error).message}`);
   }
@@ -226,32 +235,32 @@ async function handleSpawn(ctx: CommandContext) {
     console.log('Types: researcher, coder, analyst, optimizer, coordinator');
     return;
   }
-  
+
   const type = ctx.args[0];
   const name = ctx.flags.name as string;
   const capabilities = ctx.flags.capabilities as string;
-  
+
   if (!['researcher', 'coder', 'analyst', 'optimizer', 'coordinator'].includes(type)) {
     error('Invalid agent type');
     console.log('Valid types: researcher, coder, analyst, optimizer, coordinator');
     return;
   }
-  
+
   info(`Spawning ${type} agent...`);
-  
+
   try {
     let command = `npx ruv-swarm agent spawn --type ${type}`;
-    
+
     if (name) {
       command += ` --name \"${name}\"`;
     }
-    
+
     if (capabilities) {
       command += ` --capabilities \"${capabilities}\"`;
     }
-    
+
     const result = await execAsync(command);
-    
+
     if (result.stdout) {
       try {
         const spawnData = JSON.parse(result.stdout);
@@ -269,7 +278,6 @@ async function handleSpawn(ctx: CommandContext) {
         console.log(result.stdout);
       }
     }
-    
   } catch (err) {
     error(`Failed to spawn agent: ${(err as Error).message}`);
   }
@@ -279,23 +287,23 @@ async function handleSpawn(ctx: CommandContext) {
  * Handle agent listing
  */
 async function handleList(ctx: CommandContext) {
-  const filter = ctx.flags.filter as string || 'all';
-  
+  const filter = (ctx.flags.filter as string) || 'all';
+
   try {
     const command = `npx ruv-swarm agent list --filter ${filter}`;
     const result = await execAsync(command);
-    
+
     if (result.stdout) {
       try {
         const listData = JSON.parse(result.stdout);
         if (listData.success && listData.data.agents) {
           console.log(`🤖 Agents (${listData.data.count}):`);
-          
+
           if (listData.data.count === 0) {
             console.log('  No agents found');
             return;
           }
-          
+
           listData.data.agents.forEach((agent: any, index: number) => {
             console.log(`\
   ${index + 1}. ${agent.id || agent.agentId}`);
@@ -315,7 +323,6 @@ async function handleList(ctx: CommandContext) {
         console.log(result.stdout);
       }
     }
-    
   } catch (err) {
     error(`Failed to list agents: ${(err as Error).message}`);
   }
@@ -330,23 +337,23 @@ async function handleOrchestrate(ctx: CommandContext) {
     console.log('Usage: claude-flow ruv-swarm orchestrate \"<task description>\" [options]');
     return;
   }
-  
+
   const task = ctx.args.join(' ');
-  const strategy = ctx.flags.strategy as string || 'adaptive';
-  const priority = ctx.flags.priority as string || 'medium';
-  const maxAgents = ctx.flags.maxAgents as number || ctx.flags['max-agents'] as number;
-  
+  const strategy = (ctx.flags.strategy as string) || 'adaptive';
+  const priority = (ctx.flags.priority as string) || 'medium';
+  const maxAgents = (ctx.flags.maxAgents as number) || (ctx.flags['max-agents'] as number);
+
   info(`Orchestrating task: ${task}`);
-  
+
   try {
     let command = `npx ruv-swarm task orchestrate --task \"${task}\" --strategy ${strategy} --priority ${priority}`;
-    
+
     if (maxAgents) {
       command += ` --max-agents ${maxAgents}`;
     }
-    
+
     const result = await execAsync(command);
-    
+
     if (result.stdout) {
       try {
         const taskData = JSON.parse(result.stdout);
@@ -355,7 +362,7 @@ async function handleOrchestrate(ctx: CommandContext) {
           console.log(`  Task ID: ${taskData.data.taskId}`);
           console.log(`  Strategy: ${strategy}`);
           console.log(`  Priority: ${priority}`);
-          
+
           if (taskData.data.assignedAgents) {
             console.log(`  Assigned Agents: ${taskData.data.assignedAgents}`);
           }
@@ -366,7 +373,6 @@ async function handleOrchestrate(ctx: CommandContext) {
         console.log(result.stdout);
       }
     }
-    
   } catch (err) {
     error(`Failed to orchestrate task: ${(err as Error).message}`);
   }
@@ -376,19 +382,18 @@ async function handleOrchestrate(ctx: CommandContext) {
  * Handle swarm monitoring
  */
 async function handleMonitor(ctx: CommandContext) {
-  const duration = ctx.flags.duration as number || 30;
-  const interval = ctx.flags.interval as number || 5;
-  
+  const duration = (ctx.flags.duration as number) || 30;
+  const interval = (ctx.flags.interval as number) || 5;
+
   info(`Monitoring swarm for ${duration} seconds...`);
-  
+
   try {
     const command = `npx ruv-swarm swarm monitor --duration ${duration} --interval ${interval}`;
     const result = await execAsync(command);
-    
+
     if (result.stdout) {
       console.log(result.stdout);
     }
-    
   } catch (err) {
     error(`Failed to monitor swarm: ${(err as Error).message}`);
   }
@@ -405,56 +410,56 @@ async function handleNeural(ctx: CommandContext) {
     console.log('  patterns   - View cognitive patterns');
     return;
   }
-  
+
   const subcommand = ctx.args[0];
-  
+
   try {
     switch (subcommand) {
       case 'status': {
-        const agentId = ctx.flags.agentId as string || ctx.flags['agent-id'] as string;
+        const agentId = (ctx.flags.agentId as string) || (ctx.flags['agent-id'] as string);
         let command = 'npx ruv-swarm neural status';
-        
+
         if (agentId) {
           command += ` --agent-id ${agentId}`;
         }
-        
+
         const result = await execAsync(command);
         if (result.stdout) {
           console.log(result.stdout);
         }
         break;
       }
-      
+
       case 'train': {
-        const agentId = ctx.flags.agentId as string || ctx.flags['agent-id'] as string;
-        const iterations = ctx.flags.iterations as number || 10;
-        
+        const agentId = (ctx.flags.agentId as string) || (ctx.flags['agent-id'] as string);
+        const iterations = (ctx.flags.iterations as number) || 10;
+
         let command = `npx ruv-swarm neural train --iterations ${iterations}`;
-        
+
         if (agentId) {
           command += ` --agent-id ${agentId}`;
         }
-        
+
         info(`Training neural agents for ${iterations} iterations...`);
-        
+
         const result = await execAsync(command);
         if (result.stdout) {
           console.log(result.stdout);
         }
         break;
       }
-      
+
       case 'patterns': {
-        const pattern = ctx.flags.pattern as string || 'all';
+        const pattern = (ctx.flags.pattern as string) || 'all';
         const command = `npx ruv-swarm neural patterns --pattern ${pattern}`;
-        
+
         const result = await execAsync(command);
         if (result.stdout) {
           console.log(result.stdout);
         }
         break;
       }
-      
+
       default:
         error(`Unknown neural subcommand: ${subcommand}`);
         break;
@@ -468,19 +473,18 @@ async function handleNeural(ctx: CommandContext) {
  * Handle benchmarking
  */
 async function handleBenchmark(ctx: CommandContext) {
-  const type = ctx.flags.type as string || 'all';
-  const iterations = ctx.flags.iterations as number || 10;
-  
+  const type = (ctx.flags.type as string) || 'all';
+  const iterations = (ctx.flags.iterations as number) || 10;
+
   info(`Running ${type} benchmark with ${iterations} iterations...`);
-  
+
   try {
     const command = `npx ruv-swarm benchmark run --type ${type} --iterations ${iterations}`;
     const result = await execAsync(command);
-    
+
     if (result.stdout) {
       console.log(result.stdout);
     }
-    
   } catch (err) {
     error(`Benchmark failed: ${(err as Error).message}`);
   }
@@ -498,66 +502,68 @@ async function handleConfig(ctx: CommandContext) {
     console.log('  validate   - Validate configuration');
     return;
   }
-  
+
   const subcommand = ctx.args[0];
   const configManager = getRuvSwarmConfigManager(logger);
-  
+
   try {
     switch (subcommand) {
       case 'show': {
         const config = configManager.getConfig();
-        console.log('🔧 ruv-swarm Configuration:\
-');
+        console.log(
+          '🔧 ruv-swarm Configuration:\
+',
+        );
         console.log(JSON.stringify(config, null, 2));
         break;
       }
-      
+
       case 'set': {
         if (ctx.args.length < 3) {
           error('Usage: config set <section>.<key> <value>');
           console.log('Example: config set swarm.maxAgents 10');
           return;
         }
-        
+
         const path = ctx.args[1];
         const value = ctx.args[2];
         const [section, key] = path.split('.');
-        
+
         if (!section || !key) {
           error('Invalid path format. Use: section.key');
           return;
         }
-        
+
         // Parse value
         let parsedValue: any = value;
         if (value === 'true') parsedValue = true;
         else if (value === 'false') parsedValue = false;
         else if (!isNaN(Number(value))) parsedValue = Number(value);
-        
+
         const updates = { [section]: { [key]: parsedValue } };
         configManager.updateConfig(updates);
-        
+
         success(`Configuration updated: ${path} = ${value}`);
         break;
       }
-      
+
       case 'reset': {
         configManager.resetConfig();
         success('Configuration reset to defaults');
         break;
       }
-      
+
       case 'validate': {
         const validation = configManager.validateConfig();
         if (validation.valid) {
           success('Configuration is valid');
         } else {
           error('Configuration validation failed:');
-          validation.errors.forEach(err => console.log(`  - ${err}`));
+          validation.errors.forEach((err) => console.log(`  - ${err}`));
         }
         break;
       }
-      
+
       default:
         error(`Unknown config subcommand: ${subcommand}`);
         break;
@@ -571,19 +577,21 @@ async function handleConfig(ctx: CommandContext) {
  * Handle memory management
  */
 async function handleMemory(ctx: CommandContext) {
-  const detail = ctx.flags.detail as string || 'summary';
-  
+  const detail = (ctx.flags.detail as string) || 'summary';
+
   try {
     const command = `npx ruv-swarm memory usage --detail ${detail}`;
     const result = await execAsync(command);
-    
+
     if (result.stdout) {
       try {
         const memoryData = JSON.parse(result.stdout);
         if (memoryData.success) {
-          console.log('💾 Memory Usage:\
-');
-          
+          console.log(
+            '💾 Memory Usage:\
+',
+          );
+
           const data = memoryData.data;
           if (data.total !== undefined) {
             console.log(`  Total Memory: ${formatBytes(data.total)}`);
@@ -597,10 +605,12 @@ async function handleMemory(ctx: CommandContext) {
           if (data.swarmUsage !== undefined) {
             console.log(`  Swarm Usage: ${formatBytes(data.swarmUsage)}`);
           }
-          
+
           if (detail === 'detailed' && data.breakdown) {
-            console.log('\
-📊 Memory Breakdown:');
+            console.log(
+              '\
+📊 Memory Breakdown:',
+            );
             console.log(JSON.stringify(data.breakdown, null, 2));
           }
         } else {
@@ -610,7 +620,6 @@ async function handleMemory(ctx: CommandContext) {
         console.log(result.stdout);
       }
     }
-    
   } catch (err) {
     error(`Failed to get memory usage: ${(err as Error).message}`);
   }
@@ -623,9 +632,9 @@ function formatBytes(bytes: number): string {
   const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
   if (bytes === 0) return '0 B';
   const i = Math.floor(Math.log(bytes) / Math.log(1024));
-  return Math.round(bytes / Math.pow(1024, i) * 100) / 100 + ' ' + sizes[i];
+  return Math.round((bytes / Math.pow(1024, i)) * 100) / 100 + ' ' + sizes[i];
 }
 
 export default {
-  ruvSwarmAction
-};
+  ruvSwarmAction,
+};