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

package/src/cli/commands/hive-mind/ps.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 /**
  * Hive Mind PS (Process Status) Command
- * 
+ *
  * Show active sessions and their processes
  */
 
@@ -16,25 +16,25 @@ export const psCommand = new Command('ps')
   .option('-v, --verbose', 'Show detailed process information')
   .action(async (options) => {
     const sessionManager = new HiveMindSessionManager();
-    
+
     try {
-      const sessions = options.all 
+      const sessions = options.all
         ? sessionManager.getActiveSessionsWithProcessInfo()
-        : sessionManager.getActiveSessionsWithProcessInfo().filter(s => 
-            s.status === 'active' || s.status === 'paused'
-          );
-      
+        : sessionManager
+            .getActiveSessionsWithProcessInfo()
+            .filter((s) => s.status === 'active' || s.status === 'paused');
+
       if (sessions.length === 0) {
         console.log(chalk.yellow('No sessions found'));
         return;
       }
-      
+
       // Clean up orphaned processes first
       const cleanedCount = sessionManager.cleanupOrphanedProcesses();
       if (cleanedCount > 0) {
         console.log(chalk.blue(`Cleaned up ${cleanedCount} orphaned session(s)\n`));
       }
-      
+
       // Create table
       const table = new Table({
         head: [
@@ -44,24 +44,27 @@ export const psCommand = new Command('ps')
           chalk.cyan('Parent PID'),
           chalk.cyan('Child PIDs'),
           chalk.cyan('Progress'),
-          chalk.cyan('Duration')
+          chalk.cyan('Duration'),
         ],
         style: {
           head: [],
-          border: ['gray']
-        }
+          border: ['gray'],
+        },
       });
-      
+
       for (const session of sessions) {
-        const duration = new Date() - new Date(session.created_at);
+        const duration = new Date().getTime() - new Date(session.created_at).getTime();
         const durationStr = formatDuration(duration);
-        
-        const statusColor = 
-          session.status === 'active' ? chalk.green :
-          session.status === 'paused' ? chalk.yellow :
-          session.status === 'stopped' ? chalk.red :
-          chalk.gray;
-        
+
+        const statusColor =
+          session.status === 'active'
+            ? chalk.green
+            : session.status === 'paused'
+              ? chalk.yellow
+              : session.status === 'stopped'
+                ? chalk.red
+                : chalk.gray;
+
         table.push([
           session.id.substring(0, 20) + '...',
           session.swarm_name,
@@ -69,28 +72,32 @@ export const psCommand = new Command('ps')
           session.parent_pid || '-',
           session.child_pids.length > 0 ? session.child_pids.join(', ') : '-',
           `${session.completion_percentage}%`,
-          durationStr
+          durationStr,
         ]);
       }
-      
+
       console.log(table.toString());
-      
+
       if (options.verbose) {
         console.log('\n' + chalk.bold('Detailed Session Information:'));
-        
+
         for (const session of sessions) {
           console.log('\n' + chalk.cyan(`Session: ${session.id}`));
           console.log(chalk.gray(`  Objective: ${session.objective || 'N/A'}`));
           console.log(chalk.gray(`  Created: ${new Date(session.created_at).toLocaleString()}`));
           console.log(chalk.gray(`  Updated: ${new Date(session.updated_at).toLocaleString()}`));
-          
+
           if (session.paused_at) {
             console.log(chalk.gray(`  Paused: ${new Date(session.paused_at).toLocaleString()}`));
           }
-          
+
           console.log(chalk.gray(`  Agents: ${session.agent_count || 0}`));
-          console.log(chalk.gray(`  Tasks: ${session.task_count || 0} (${session.completed_tasks || 0} completed)`));
-          
+          console.log(
+            chalk.gray(
+              `  Tasks: ${session.task_count || 0} (${session.completed_tasks || 0} completed)`,
+            ),
+          );
+
           if (session.child_pids.length > 0) {
             console.log(chalk.gray(`  Active Processes:`));
             for (const pid of session.child_pids) {
@@ -99,19 +106,18 @@ export const psCommand = new Command('ps')
           }
         }
       }
-      
+
       // Summary
-      const activeSessions = sessions.filter(s => s.status === 'active').length;
-      const pausedSessions = sessions.filter(s => s.status === 'paused').length;
+      const activeSessions = sessions.filter((s) => s.status === 'active').length;
+      const pausedSessions = sessions.filter((s) => s.status === 'paused').length;
       const totalProcesses = sessions.reduce((sum, s) => sum + s.total_processes, 0);
-      
+
       console.log('\n' + chalk.bold('Summary:'));
       console.log(chalk.gray(`  Active sessions: ${activeSessions}`));
       console.log(chalk.gray(`  Paused sessions: ${pausedSessions}`));
       console.log(chalk.gray(`  Total processes: ${totalProcesses}`));
-      
     } catch (error) {
-      console.error(chalk.red('Error listing sessions:'), error.message);
+      console.error(chalk.red('Error listing sessions:'), (error as Error).message);
       process.exit(1);
     } finally {
       sessionManager.close();
@@ -122,7 +128,7 @@ function formatDuration(ms: number) {
   const seconds = Math.floor(ms / 1000);
   const minutes = Math.floor(seconds / 60);
   const hours = Math.floor(minutes / 60);
-  
+
   if (hours > 0) {
     return `${hours}h ${minutes % 60}m`;
   } else if (minutes > 0) {
@@ -130,4 +136,4 @@ function formatDuration(ms: number) {
   } else {
     return `${seconds}s`;
   }
-}
+}

package/src/cli/commands/hive-mind/resume.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 /**
  * Hive Mind Resume Command
- * 
+ *
  * Resume paused swarm sessions
  */
 
@@ -15,52 +15,52 @@ export const resumeCommand = new Command('resume')
   .option('-s, --session <id>', 'Resume specific session by ID')
   .action(async (options) => {
     const sessionManager = new HiveMindSessionManager();
-    
+
     try {
       if (options.session) {
         // Resume specific session
         const sessionId = options.session;
-        
+
         console.log(chalk.cyan(`Resuming session ${sessionId}...`));
         const session = await sessionManager.resumeSession(sessionId);
-        
+
         console.log(chalk.green(`✓ Session ${sessionId} resumed successfully`));
-        console.log(chalk.gray(`Swarm: ${session.swarm_name}`));
-        console.log(chalk.gray(`Objective: ${session.objective}`));
+        console.log(chalk.gray(`Swarm: ${(session as any).swarm_name || 'N/A'}`));
+        console.log(chalk.gray(`Objective: ${(session as any).objective || 'N/A'}`));
         console.log(chalk.gray(`Progress: ${session.statistics.completionPercentage}%`));
-        
       } else {
         // Interactive selection
-        const sessions = sessionManager.getActiveSessions().filter(s => s.status === 'paused');
-        
+        const sessions = sessionManager.getActiveSessions().filter((s) => s.status === 'paused');
+
         if (sessions.length === 0) {
           console.log(chalk.yellow('No paused sessions found to resume'));
           return;
         }
-        
-        const { sessionId } = await inquirer.prompt([{
-          type: 'list',
-          name: 'sessionId',
-          message: 'Select session to resume:',
-          choices: sessions.map(s => ({
-            name: `${s.swarm_name} (${s.id}) - ${s.completion_percentage}% complete`,
-            value: s.id
-          }))
-        }]);
-        
+
+        const { sessionId } = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'sessionId',
+            message: 'Select session to resume:',
+            choices: sessions.map((s) => ({
+              name: `${s.swarm_name} (${s.id}) - ${s.completion_percentage}% complete`,
+              value: s.id,
+            })),
+          },
+        ]);
+
         console.log(chalk.cyan(`Resuming session ${sessionId}...`));
         const session = await sessionManager.resumeSession(sessionId);
-        
+
         console.log(chalk.green(`✓ Session resumed successfully`));
-        console.log(chalk.gray(`Swarm: ${session.swarm_name}`));
-        console.log(chalk.gray(`Objective: ${session.objective}`));
+        console.log(chalk.gray(`Swarm: ${(session as any).swarm_name || 'N/A'}`));
+        console.log(chalk.gray(`Objective: ${(session as any).objective || 'N/A'}`));
         console.log(chalk.gray(`Progress: ${session.statistics.completionPercentage}%`));
       }
-      
     } catch (error) {
-      console.error(chalk.red('Error resuming session:'), error.message);
+      console.error(chalk.red('Error resuming session:'), (error as Error).message);
       process.exit(1);
     } finally {
       sessionManager.close();
     }
-  });
+  });

package/src/cli/commands/hive-mind/spawn.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 /**
  * Hive Mind Agent Spawn Command
- * 
+ *
  * Spawns specialized agents into the Hive Mind swarm
  * with automatic capability assignment and coordination.
  */
@@ -15,8 +15,17 @@ import { AgentType, AgentCapability } from '../../../hive-mind/types.js';
 import { formatSuccess, formatError, formatInfo, formatWarning } from '../../formatter.js';
 
 const AGENT_TYPES: AgentType[] = [
-  'coordinator', 'researcher', 'coder', 'analyst', 'architect',
-  'tester', 'reviewer', 'optimizer', 'documenter', 'monitor', 'specialist'
+  'coordinator',
+  'researcher',
+  'coder',
+  'analyst',
+  'architect',
+  'tester',
+  'reviewer',
+  'optimizer',
+  'documenter',
+  'monitor',
+  'specialist',
 ];
 
 const CAPABILITY_MAP: Record<AgentType, AgentCapability[]> = {
@@ -30,7 +39,7 @@ const CAPABILITY_MAP: Record<AgentType, AgentCapability[]> = {
   optimizer: ['performance_optimization', 'resource_optimization', 'algorithm_improvement'],
   documenter: ['documentation_generation', 'api_docs', 'user_guides'],
   monitor: ['system_monitoring', 'health_checks', 'alerting'],
-  specialist: ['domain_expertise', 'custom_capabilities', 'problem_solving']
+  specialist: ['domain_expertise', 'custom_capabilities', 'problem_solving'],
 };
 
 export const spawnCommand = new Command('spawn')
@@ -44,14 +53,14 @@ export const spawnCommand = new Command('spawn')
   .option('--auto-assign', 'Automatically assign to available tasks', false)
   .action(async (type, options) => {
     const spinner = ora('Spawning agent...').start();
-    
+
     try {
       // Get or prompt for swarm ID
-      const swarmId = options.swarmId || await getActiveSwarmId();
+      const swarmId = options.swarmId || (await getActiveSwarmId());
       if (!swarmId) {
         throw new Error('No active swarm found. Initialize a Hive Mind first.');
       }
-      
+
       // Interactive mode
       if (options.interactive || !type) {
         const answers = await inquirer.prompt([
@@ -60,7 +69,7 @@ export const spawnCommand = new Command('spawn')
             name: 'type',
             message: 'Select agent type:',
             choices: AGENT_TYPES,
-            when: !type
+            when: !type,
           },
           {
             type: 'checkbox',
@@ -70,60 +79,60 @@ export const spawnCommand = new Command('spawn')
             when: (answers) => {
               const agentType = type || answers.type;
               return agentType === 'specialist';
-            }
+            },
           },
           {
             type: 'input',
             name: 'customName',
             message: 'Enter custom agent name (optional):',
-            when: !options.name
-          }
+            when: !options.name,
+          },
         ]);
-        
+
         type = type || answers.type;
         options.name = options.name || answers.customName;
         if (answers.additionalCapabilities) {
           options.capabilities = answers.additionalCapabilities.join(',');
         }
       }
-      
+
       // Validate agent type
       if (!AGENT_TYPES.includes(type as AgentType)) {
         throw new Error(`Invalid agent type: ${type}`);
       }
-      
+
       // Load Hive Mind
       const hiveMind = await HiveMind.load(swarmId);
-      
+
       // Determine capabilities
       const baseCapabilities = CAPABILITY_MAP[type as AgentType] || [];
-      const additionalCapabilities = options.capabilities 
+      const additionalCapabilities = options.capabilities
         ? options.capabilities.split(',').map((c: string) => c.trim())
         : [];
       const capabilities = [...baseCapabilities, ...additionalCapabilities];
-      
+
       // Spawn agents
       const batchSize = parseInt(options.batch, 10);
       const spawnedAgents = [];
-      
+
       for (let i = 0; i < batchSize; i++) {
         const agentName = options.name || `${type}-${Date.now()}-${i}`;
         const agent = await hiveMind.spawnAgent({
           type: type as AgentType,
           name: agentName,
           capabilities,
-          autoAssign: options.autoAssign
+          autoAssign: options.autoAssign,
         });
-        
+
         spawnedAgents.push(agent);
-        
+
         if (batchSize > 1) {
           spinner.text = `Spawning agents... (${i + 1}/${batchSize})`;
         }
       }
-      
+
       spinner.succeed(formatSuccess(`Successfully spawned ${batchSize} ${type} agent(s)!`));
-      
+
       // Display spawned agents
       console.log('\n' + chalk.bold('🤖 Spawned Agents:'));
       spawnedAgents.forEach((agent) => {
@@ -133,18 +142,17 @@ export const spawnCommand = new Command('spawn')
           console.log(chalk.yellow(`  Assigned to: ${agent.currentTask}`));
         }
       });
-      
+
       // Show swarm stats
       const stats = await hiveMind.getStats();
       console.log('\n' + chalk.bold('📊 Swarm Statistics:'));
       console.log(formatInfo(`Total Agents: ${stats.totalAgents}`));
       console.log(formatInfo(`Active Agents: ${stats.activeAgents}`));
       console.log(formatInfo(`Available Capacity: ${stats.availableCapacity}%`));
-      
+
       if (options.autoAssign && stats.pendingTasks > 0) {
         console.log(formatWarning(`Auto-assigned to ${stats.pendingTasks} pending task(s)`));
       }
-      
     } catch (error) {
       spinner.fail(formatError('Failed to spawn agent'));
       console.error(formatError((error as Error).message));
@@ -160,8 +168,8 @@ async function getActiveSwarmId(): Promise<string | null> {
 
 function getAllCapabilities(): string[] {
   const allCapabilities = new Set<string>();
-  Object.values(CAPABILITY_MAP).forEach(caps => {
-    caps.forEach(cap => allCapabilities.add(cap));
+  Object.values(CAPABILITY_MAP).forEach((caps) => {
+    caps.forEach((cap) => allCapabilities.add(cap));
   });
   return Array.from(allCapabilities);
-}
+}

package/src/cli/commands/hive-mind/status.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 /**
  * Hive Mind Status Command
- * 
+ *
  * Displays comprehensive status of the Hive Mind swarm
  * including agents, tasks, memory, and performance metrics.
  */
@@ -25,24 +25,24 @@ export const statusCommand = new Command('status')
   .action(async (options) => {
     try {
       // Get swarm ID
-      const swarmId = options.swarmId || await getActiveSwarmId();
+      const swarmId = options.swarmId || (await getActiveSwarmId());
       if (!swarmId) {
         throw new Error('No active swarm found. Initialize a Hive Mind first.');
       }
-      
+
       // Load Hive Mind
       const hiveMind = await HiveMind.load(swarmId);
       const status = await hiveMind.getFullStatus();
-      
+
       if (options.json) {
         console.log(JSON.stringify(status, null, 2));
         return;
       }
-      
+
       // Display swarm header
       console.log('\n' + chalk.bold.yellow('🐝 Hive Mind Status'));
       console.log(chalk.gray('━'.repeat(60)));
-      
+
       // Basic info
       console.log(formatInfo(`Swarm ID: ${status.swarmId}`));
       console.log(formatInfo(`Name: ${status.name}`));
@@ -50,115 +50,116 @@ export const statusCommand = new Command('status')
       console.log(formatInfo(`Queen Mode: ${status.queenMode}`));
       console.log(formatInfo(`Status: ${getStatusEmoji(status.health)} ${status.health}`));
       console.log(formatInfo(`Uptime: ${formatUptime(status.uptime)}`));
-      
+
       // Agent summary
       console.log('\n' + chalk.bold('👥 Agent Summary'));
       const agentTable = new Table({
         head: ['Type', 'Total', 'Active', 'Idle', 'Busy'],
-        style: { head: ['cyan'] }
+        style: { head: ['cyan'] },
       });
-      
+
       Object.entries(status.agentsByType).forEach(([type, count]) => {
-        const active = status.agents.filter(a => a.type === type && a.status === 'active').length;
-        const idle = status.agents.filter(a => a.type === type && a.status === 'idle').length;
-        const busy = status.agents.filter(a => a.type === type && a.status === 'busy').length;
-        
+        const active = status.agents.filter((a) => a.type === type && a.status === 'active').length;
+        const idle = status.agents.filter((a) => a.type === type && a.status === 'idle').length;
+        const busy = status.agents.filter((a) => a.type === type && a.status === 'busy').length;
+
         agentTable.push([type, count, active, idle, busy]);
       });
-      
+
       console.log(agentTable.toString());
-      
+
       // Detailed agent info
       if (options.detailed) {
         console.log('\n' + chalk.bold('🤖 Agent Details'));
         const detailTable = new Table({
           head: ['Name', 'Type', 'Status', 'Task', 'Messages', 'Uptime'],
-          style: { head: ['cyan'] }
+          style: { head: ['cyan'] },
         });
-        
-        status.agents.forEach(agent => {
+
+        status.agents.forEach((agent) => {
           detailTable.push([
             agent.name,
             agent.type,
             getAgentStatusBadge(agent.status),
             agent.currentTask || '-',
             agent.messageCount,
-            formatUptime(Date.now() - agent.createdAt)
+            formatUptime(Date.now() - agent.createdAt),
           ]);
         });
-        
+
         console.log(detailTable.toString());
       }
-      
+
       // Task queue
       if (options.tasks || status.tasks.length > 0) {
         console.log('\n' + chalk.bold('📋 Task Queue'));
         const taskTable = new Table({
           head: ['ID', 'Description', 'Status', 'Assigned To', 'Progress'],
-          style: { head: ['cyan'] }
+          style: { head: ['cyan'] },
         });
-        
-        status.tasks.forEach(task => {
+
+        status.tasks.forEach((task) => {
           taskTable.push([
             task.id.substring(0, 8),
             task.description.substring(0, 40) + (task.description.length > 40 ? '...' : ''),
             getTaskStatusBadge(task.status),
             task.assignedAgent || '-',
-            `${task.progress}%`
+            `${task.progress}%`,
           ]);
         });
-        
+
         console.log(taskTable.toString());
         console.log(formatInfo(`Total Tasks: ${status.taskStats.total}`));
-        console.log(formatInfo(`Completed: ${status.taskStats.completed} | In Progress: ${status.taskStats.inProgress} | Pending: ${status.taskStats.pending}`));
+        console.log(
+          formatInfo(
+            `Completed: ${status.taskStats.completed} | In Progress: ${status.taskStats.inProgress} | Pending: ${status.taskStats.pending}`,
+          ),
+        );
       }
-      
+
       // Memory statistics
       if (options.memory) {
         console.log('\n' + chalk.bold('💾 Memory Statistics'));
         const memTable = new Table({
           head: ['Namespace', 'Entries', 'Size', 'Avg TTL'],
-          style: { head: ['cyan'] }
+          style: { head: ['cyan'] },
         });
-        
+
         Object.entries(status.memoryStats.byNamespace).forEach(([ns, stats]) => {
-          memTable.push([
-            ns,
-            stats.entries,
-            formatBytes(stats.size),
-            `${stats.avgTTL}s`
-          ]);
+          memTable.push([ns, stats.entries, formatBytes(stats.size), `${stats.avgTTL}s`]);
         });
-        
+
         console.log(memTable.toString());
         console.log(formatInfo(`Total Memory Usage: ${formatBytes(status.memoryStats.totalSize)}`));
         console.log(formatInfo(`Total Entries: ${status.memoryStats.totalEntries}`));
       }
-      
+
       // Performance metrics
       if (options.performance) {
         console.log('\n' + chalk.bold('📊 Performance Metrics'));
         console.log(formatInfo(`Avg Task Completion: ${status.performance.avgTaskCompletion}ms`));
         console.log(formatInfo(`Message Throughput: ${status.performance.messageThroughput}/min`));
-        console.log(formatInfo(`Consensus Success Rate: ${status.performance.consensusSuccessRate}%`));
+        console.log(
+          formatInfo(`Consensus Success Rate: ${status.performance.consensusSuccessRate}%`),
+        );
         console.log(formatInfo(`Memory Hit Rate: ${status.performance.memoryHitRate}%`));
         console.log(formatInfo(`Agent Utilization: ${status.performance.agentUtilization}%`));
       }
-      
+
       // Communications
       console.log('\n' + chalk.bold('📡 Recent Communications'));
       console.log(formatInfo(`Total Messages: ${status.communicationStats.totalMessages}`));
       console.log(formatInfo(`Avg Latency: ${status.communicationStats.avgLatency}ms`));
       console.log(formatInfo(`Active Channels: ${status.communicationStats.activeChannels}`));
-      
+
       // Health warnings
       if (status.warnings.length > 0) {
         console.log('\n' + chalk.bold.yellow('⚠️  Warnings'));
-        status.warnings.forEach(warning => {
+        status.warnings.forEach((warning) => {
           console.log(formatWarning(warning));
         });
       }
-      
+
       // Watch mode
       if (options.watch) {
         console.log('\n' + chalk.gray('Refreshing every 2 seconds... (Ctrl+C to exit)'));
@@ -167,7 +168,6 @@ export const statusCommand = new Command('status')
           await statusCommand.parseAsync([...process.argv.slice(0, 2), ...process.argv.slice(3)]);
         }, 2000);
       }
-      
     } catch (error) {
       console.error(formatError('Failed to get swarm status'));
       console.error(formatError((error as Error).message));
@@ -185,7 +185,7 @@ function getStatusEmoji(health: string): string {
     healthy: '🟢',
     degraded: '🟡',
     critical: '🔴',
-    unknown: '⚪'
+    unknown: '⚪',
   };
   return emojis[health] || '⚪';
 }
@@ -195,7 +195,7 @@ function getAgentStatusBadge(status: string): string {
     active: chalk.green('● Active'),
     idle: chalk.yellow('● Idle'),
     busy: chalk.blue('● Busy'),
-    error: chalk.red('● Error')
+    error: chalk.red('● Error'),
   };
   return badges[status] || chalk.gray('● Unknown');
 }
@@ -206,7 +206,7 @@ function getTaskStatusBadge(status: string): string {
     assigned: chalk.yellow('🔄 Assigned'),
     in_progress: chalk.blue('▶️  In Progress'),
     completed: chalk.green('✅ Completed'),
-    failed: chalk.red('❌ Failed')
+    failed: chalk.red('❌ Failed'),
   };
   return badges[status] || chalk.gray('❓ Unknown');
 }
@@ -216,7 +216,7 @@ function formatUptime(ms: number): string {
   const minutes = Math.floor(seconds / 60);
   const hours = Math.floor(minutes / 60);
   const days = Math.floor(hours / 24);
-  
+
   if (days > 0) return `${days}d ${hours % 24}h`;
   if (hours > 0) return `${hours}h ${minutes % 60}m`;
   if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
@@ -227,11 +227,11 @@ function formatBytes(bytes: number): string {
   const units = ['B', 'KB', 'MB', 'GB'];
   let size = bytes;
   let unitIndex = 0;
-  
+
   while (size > 1024 && unitIndex < units.length - 1) {
     size /= 1024;
     unitIndex++;
   }
-  
+
   return `${size.toFixed(2)} ${units[unitIndex]}`;
-}
+}