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

package/src/cli/commands/monitor.ts

@@ -1,4 +1,3 @@
-import { getErrorMessage } from '../../utils/error-handler.js';
 /**
  * Monitor command for Claude-Flow - Live dashboard mode
  */
@@ -89,17 +88,17 @@ class Dashboard {
       try {
         const data = await this.collectData();
         this.data.push(data);
-        
+
         // Keep only recent data points
         if (this.data.length > this.maxDataPoints) {
           this.data = this.data.slice(-this.maxDataPoints);
         }
 
         this.render();
-        await new Promise(resolve => setTimeout(resolve, this.options.interval * 1000));
+        await new Promise((resolve) => setTimeout(resolve, this.options.interval * 1000));
       } catch (error) {
         this.renderError(error);
-        await new Promise(resolve => setTimeout(resolve, this.options.interval * 1000));
+        await new Promise((resolve) => setTimeout(resolve, this.options.interval * 1000));
       }
     }
   }
@@ -109,53 +108,53 @@ class Dashboard {
     const timestamp = new Date();
     const cpuUsage = 10 + Math.random() * 20; // 10-30%
     const memoryUsage = 200 + Math.random() * 100; // 200-300MB
-    
+
     return {
       timestamp,
       system: {
         cpu: cpuUsage,
         memory: memoryUsage,
         agents: 3 + Math.floor(Math.random() * 3),
-        tasks: 5 + Math.floor(Math.random() * 10)
+        tasks: 5 + Math.floor(Math.random() * 10),
       },
       components: {
         orchestrator: { status: 'healthy', load: Math.random() * 100 },
         terminal: { status: 'healthy', load: Math.random() * 100 },
         memory: { status: 'healthy', load: Math.random() * 100 },
         coordination: { status: 'healthy', load: Math.random() * 100 },
-        mcp: { status: 'healthy', load: Math.random() * 100 }
+        mcp: { status: 'healthy', load: Math.random() * 100 },
       },
       agents: this.generateMockAgents(),
       tasks: this.generateMockTasks(),
-      events: this.generateMockEvents()
+      events: this.generateMockEvents(),
     };
   }
 
   private render(): void {
     console.clear();
-    
+
     const latest = this.data[this.data.length - 1];
     if (!latest) return;
 
     // Header
     this.renderHeader(latest);
-    
+
     if (this.options.focus) {
       this.renderFocusedComponent(latest, this.options.focus);
     } else {
       // System overview
       this.renderSystemOverview(latest);
-      
+
       // Components status
       this.renderComponentsStatus(latest);
-      
+
       if (!this.options.compact) {
         // Agents and tasks
         this.renderAgentsAndTasks(latest);
-        
+
         // Recent events
         this.renderRecentEvents(latest);
-        
+
         // Performance graphs
         if (!this.options.noGraphs) {
           this.renderPerformanceGraphs();
@@ -176,10 +175,10 @@ class Dashboard {
   private renderSystemOverview(data: MonitorData): void {
     console.log(chalk.white.bold('System Overview'));
     console.log('─'.repeat(40));
-    
+
     const cpuBar = formatProgressBar(data.system.cpu, 100, 20, 'CPU');
     const memoryBar = formatProgressBar(data.system.memory, 1024, 20, 'Memory');
-    
+
     console.log(`${cpuBar} ${data.system.cpu.toFixed(1)}%`);
     console.log(`${memoryBar} ${data.system.memory.toFixed(0)}MB`);
     console.log(`${chalk.white('Agents:')} ${data.system.agents} active`);
@@ -190,20 +189,20 @@ class Dashboard {
   private renderComponentsStatus(data: MonitorData): void {
     console.log(chalk.white.bold('Components'));
     console.log('─'.repeat(40));
-    
+
     const tableData: any[] = [];
 
     for (const [name, component] of Object.entries(data.components)) {
       const statusIcon = formatStatusIndicator(component.status);
       const loadBar = this.createMiniProgressBar(component.load, 100, 10);
-      
+
       tableData.push({
         Component: name,
         Status: `${statusIcon} ${component.status}`,
-        Load: `${loadBar} ${component.load.toFixed(0)}%`
+        Load: `${loadBar} ${component.load.toFixed(0)}%`,
       });
     }
-    
+
     console.table(tableData);
     console.log();
   }
@@ -212,24 +211,24 @@ class Dashboard {
     // Agents table
     console.log(chalk.white.bold('Active Agents'));
     console.log('─'.repeat(40));
-    
+
     if (data.agents.length > 0) {
       const agentTable = new Table({
         head: ['Agent ID', 'Type', 'Status', 'Tasks'],
-        style: { border: [], head: [] }
+        style: { border: [], head: [] },
       });
 
       for (const agent of data.agents.slice(0, 5)) {
         const statusIcon = formatStatusIndicator(agent.status);
-        
+
         agentTable.push([
           chalk.gray(agent.id.substring(0, 8) + '...'),
           chalk.cyan(agent.type),
           `${statusIcon} ${agent.status}`,
-          agent.activeTasks.toString()
+          agent.activeTasks.toString(),
         ]);
       }
-      
+
       console.log(agentTable.toString());
     } else {
       console.log(chalk.gray('No active agents'));
@@ -239,24 +238,24 @@ class Dashboard {
     // Recent tasks
     console.log(chalk.white.bold('Recent Tasks'));
     console.log('─'.repeat(40));
-    
+
     if (data.tasks.length > 0) {
       const taskTable = new Table({
         head: ['Task ID', 'Type', 'Status', 'Duration'],
-        style: { border: [], head: [] }
+        style: { border: [], head: [] },
       });
 
       for (const task of data.tasks.slice(0, 5)) {
         const statusIcon = formatStatusIndicator(task.status);
-        
+
         taskTable.push([
           chalk.gray(task.id.substring(0, 8) + '...'),
           chalk.white(task.type),
           `${statusIcon} ${task.status}`,
-          task.duration ? formatDuration(task.duration) : '-'
+          task.duration ? formatDuration(task.duration) : '-',
         ]);
       }
-      
+
       console.log(taskTable.toString());
     } else {
       console.log(chalk.gray('No recent tasks'));
@@ -267,7 +266,7 @@ class Dashboard {
   private renderRecentEvents(data: MonitorData): void {
     console.log(chalk.white.bold('Recent Events'));
     console.log('─'.repeat(40));
-    
+
     if (data.events.length > 0) {
       for (const event of data.events.slice(0, 3)) {
         const time = new Date(event.timestamp).toLocaleTimeString();
@@ -283,15 +282,25 @@ class Dashboard {
   private renderPerformanceGraphs(): void {
     console.log(chalk.white.bold('Performance (Last 60s)'));
     console.log('─'.repeat(40));
-    
+
     if (this.data.length >= 2) {
       // CPU graph
       console.log(chalk.cyan('CPU Usage:'));
-      console.log(this.createSparkline(this.data.map(d => d.system.cpu), 30));
-      
+      console.log(
+        this.createSparkline(
+          this.data.map((d) => d.system.cpu),
+          30,
+        ),
+      );
+
       // Memory graph
       console.log(chalk.cyan('Memory Usage:'));
-      console.log(this.createSparkline(this.data.map(d => d.system.memory), 30));
+      console.log(
+        this.createSparkline(
+          this.data.map((d) => d.system.memory),
+          30,
+        ),
+      );
     } else {
       console.log(chalk.gray('Collecting data...'));
     }
@@ -307,33 +316,37 @@ class Dashboard {
 
     console.log(chalk.white.bold(`${componentName} Details`));
     console.log('─'.repeat(40));
-    
+
     const statusIcon = formatStatusIndicator(component.status);
     console.log(`${statusIcon} Status: ${component.status}`);
-    console.log(`Load: ${formatProgressBar(component.load, 100, 30)} ${component.load.toFixed(1)}%`);
-    
+    console.log(
+      `Load: ${formatProgressBar(component.load, 100, 30)} ${component.load.toFixed(1)}%`,
+    );
+
     // Add component-specific metrics here
     console.log();
   }
 
   private renderFooter(): void {
     console.log('─'.repeat(80));
-    console.log(chalk.gray('Press Ctrl+C to exit • Update interval: ') + 
-               chalk.yellow(`${this.options.interval}s`));
+    console.log(
+      chalk.gray('Press Ctrl+C to exit • Update interval: ') +
+        chalk.yellow(`${this.options.interval}s`),
+    );
   }
 
   private renderError(error: any): void {
     console.clear();
     console.log(chalk.red.bold('Monitor Error'));
     console.log('─'.repeat(40));
-    
+
     if ((error as Error).message.includes('ECONNREFUSED')) {
       console.log(chalk.red('✗ Cannot connect to Claude-Flow'));
       console.log(chalk.gray('Make sure Claude-Flow is running with: claude-flow start'));
     } else {
       console.log(chalk.red('Error:'), (error as Error).message);
     }
-    
+
     console.log('\n' + chalk.gray('Retrying in ') + chalk.yellow(`${this.options.interval}s...`));
   }
 
@@ -345,19 +358,21 @@ class Dashboard {
 
   private createSparkline(data: number[], width: number): string {
     if (data.length < 2) return chalk.gray('▁'.repeat(width));
-    
+
     const max = Math.max(...data);
     const min = Math.min(...data);
     const range = max - min || 1;
-    
+
     const chars = ['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'];
     const recent = data.slice(-width);
-    
-    return recent.map(value => {
-      const normalized = (value - min) / range;
-      const charIndex = Math.floor(normalized * (chars.length - 1));
-      return chalk.cyan(chars[charIndex]);
-    }).join('');
+
+    return recent
+      .map((value) => {
+        const normalized = (value - min) / range;
+        const charIndex = Math.floor(normalized * (chars.length - 1));
+        return chalk.cyan(chars[charIndex]);
+      })
+      .join('');
   }
 
   private getEventIcon(type: string): string {
@@ -379,32 +394,32 @@ class Dashboard {
         id: 'agent-001',
         type: 'coordinator',
         status: 'active',
-        activeTasks: Math.floor(Math.random() * 5) + 1
+        activeTasks: Math.floor(Math.random() * 5) + 1,
       },
       {
         id: 'agent-002',
         type: 'researcher',
         status: 'active',
-        activeTasks: Math.floor(Math.random() * 8) + 1
+        activeTasks: Math.floor(Math.random() * 8) + 1,
       },
       {
         id: 'agent-003',
         type: 'implementer',
         status: Math.random() > 0.7 ? 'idle' : 'active',
-        activeTasks: Math.floor(Math.random() * 3)
-      }
+        activeTasks: Math.floor(Math.random() * 3),
+      },
     ];
   }
 
   private generateMockTasks(): any[] {
     const types = ['research', 'implementation', 'analysis', 'coordination'];
     const statuses = ['running', 'pending', 'completed', 'failed'];
-    
+
     return Array.from({ length: 8 }, (_, i) => ({
       id: `task-${String(i + 1).padStart(3, '0')}`,
       type: types[Math.floor(Math.random() * types.length)],
       status: statuses[Math.floor(Math.random() * statuses.length)],
-      duration: Math.random() > 0.5 ? Math.floor(Math.random() * 120000) : null
+      duration: Math.random() > 0.5 ? Math.floor(Math.random() * 120000) : null,
     }));
   }
 
@@ -413,32 +428,47 @@ class Dashboard {
       { type: 'task_completed', message: 'Research task completed successfully' },
       { type: 'agent_spawned', message: 'New implementer agent spawned' },
       { type: 'task_assigned', message: 'Task assigned to coordinator agent' },
-      { type: 'system_warning', message: 'High memory usage detected' }
+      { type: 'system_warning', message: 'High memory usage detected' },
     ];
-    
+
     const eventTypes = [
-      { type: 'task_completed', message: 'Research task completed successfully', level: 'info' as const },
+      {
+        type: 'task_completed',
+        message: 'Research task completed successfully',
+        level: 'info' as const,
+      },
       { type: 'agent_spawned', message: 'New implementer agent spawned', level: 'info' as const },
-      { type: 'task_assigned', message: 'Task assigned to coordinator agent', level: 'info' as const },
+      {
+        type: 'task_assigned',
+        message: 'Task assigned to coordinator agent',
+        level: 'info' as const,
+      },
       { type: 'system_warning', message: 'High memory usage detected', level: 'warn' as const },
-      { type: 'task_failed', message: 'Analysis task failed due to timeout', level: 'error' as const },
+      {
+        type: 'task_failed',
+        message: 'Analysis task failed due to timeout',
+        level: 'error' as const,
+      },
       { type: 'system_info', message: 'System health check completed', level: 'info' as const },
       { type: 'memory_gc', message: 'Garbage collection triggered', level: 'debug' as const },
-      { type: 'network_event', message: 'MCP connection established', level: 'info' as const }
+      { type: 'network_event', message: 'MCP connection established', level: 'info' as const },
     ];
-    
+
     const components = ['orchestrator', 'terminal', 'memory', 'coordination', 'mcp'];
-    
+
     return Array.from({ length: 6 + Math.floor(Math.random() * 4) }, (_, i) => {
       const event = eventTypes[Math.floor(Math.random() * eventTypes.length)];
       return {
         ...event,
-        timestamp: Date.now() - (i * Math.random() * 300000), // Random intervals up to 5 minutes
-        component: Math.random() > 0.3 ? components[Math.floor(Math.random() * components.length)] : undefined
+        timestamp: Date.now() - i * Math.random() * 300000, // Random intervals up to 5 minutes
+        component:
+          Math.random() > 0.3
+            ? components[Math.floor(Math.random() * components.length)]
+            : undefined,
       };
     }).sort((a, b) => b.timestamp - a.timestamp);
   }
-  
+
   private async checkSystemRunning(): Promise<boolean> {
     try {
       return await existsSync('.claude-flow.pid');
@@ -446,38 +476,38 @@ class Dashboard {
       return false;
     }
   }
-  
+
   private async getRealSystemData(): Promise<MonitorData | null> {
     // This would connect to the actual orchestrator for real data
     // For now, return null to use mock data
     return null;
   }
-  
+
   private generateComponentStatus(): Record<string, ComponentStatus> {
     const components = ['orchestrator', 'terminal', 'memory', 'coordination', 'mcp'];
     const statuses = ['healthy', 'degraded', 'error'];
-    
+
     const result: Record<string, ComponentStatus> = {};
-    
+
     for (const component of components) {
       const status = statuses[Math.floor(Math.random() * statuses.length)];
       const hasErrors = Math.random() > 0.8;
-      
+
       result[component] = {
         status: status as 'error' | 'healthy' | 'degraded',
         load: Math.random() * 100,
         uptime: Math.random() * 3600000, // Up to 1 hour
         errors: hasErrors ? Math.floor(Math.random() * 5) : 0,
-        lastError: hasErrors ? 'Connection timeout' : undefined
+        lastError: hasErrors ? 'Connection timeout' : undefined,
       };
     }
-    
+
     return result;
   }
-  
+
   private checkAlerts(data: MonitorData): void {
     const newAlerts: AlertData[] = [];
-    
+
     // Check system thresholds
     if (data.system.cpu > this.options.threshold) {
       newAlerts.push({
@@ -486,10 +516,10 @@ class Dashboard {
         message: `CPU usage high: ${data.system.cpu.toFixed(1)}%`,
         component: 'system',
         timestamp: Date.now(),
-        acknowledged: false
+        acknowledged: false,
       });
     }
-    
+
     if (data.system.memory > 800) {
       newAlerts.push({
         id: 'memory-high',
@@ -497,10 +527,10 @@ class Dashboard {
         message: `Memory usage high: ${data.system.memory.toFixed(0)}MB`,
         component: 'system',
         timestamp: Date.now(),
-        acknowledged: false
+        acknowledged: false,
       });
     }
-    
+
     // Check component status
     for (const [name, component] of Object.entries(data.components)) {
       if (component.status === 'error') {
@@ -510,10 +540,10 @@ class Dashboard {
           message: `Component ${name} is in error state`,
           component: name,
           timestamp: Date.now(),
-          acknowledged: false
+          acknowledged: false,
         });
       }
-      
+
       if (component.load > this.options.threshold) {
         newAlerts.push({
           id: `component-load-${name}`,
@@ -521,17 +551,17 @@ class Dashboard {
           message: `Component ${name} load high: ${component.load.toFixed(1)}%`,
           component: name,
           timestamp: Date.now(),
-          acknowledged: false
+          acknowledged: false,
         });
       }
     }
-    
+
     // Update alerts list (keep only recent ones)
     this.alerts = [...this.alerts, ...newAlerts]
-      .filter(alert => Date.now() - alert.timestamp < 300000) // 5 minutes
+      .filter((alert) => Date.now() - alert.timestamp < 300000) // 5 minutes
       .slice(-10); // Keep max 10 alerts
   }
-  
+
   private async exportMonitoringData(): Promise<void> {
     try {
       const exportData = {
@@ -539,12 +569,12 @@ class Dashboard {
           exportTime: new Date().toISOString(),
           duration: formatDuration(Date.now() - this.startTime),
           dataPoints: this.exportData.length,
-          interval: this.options.interval
+          interval: this.options.interval,
         },
         data: this.exportData,
-        alerts: this.alerts
+        alerts: this.alerts,
       };
-      
+
       await fs.writeFile(this.options.export, JSON.stringify(exportData, null, 2));
       console.log(chalk.green(`✓ Monitoring data exported to ${this.options.export}`));
     } catch (error) {
@@ -559,12 +589,12 @@ async function startMonitorDashboard(options: any): Promise<void> {
     console.error(chalk.red('Update interval must be at least 1 second'));
     return;
   }
-  
+
   if (options.threshold < 1 || options.threshold > 100) {
     console.error(chalk.red('Threshold must be between 1 and 100'));
     return;
   }
-  
+
   if (options.export) {
     // Check if export path is writable
     try {
@@ -575,7 +605,7 @@ async function startMonitorDashboard(options: any): Promise<void> {
       return;
     }
   }
-  
+
   const dashboard = new Dashboard(options);
   await dashboard.start();
-}
+}