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

package/src/coordination/swarm-monitor.ts

@@ -1,4 +1,3 @@
-import { getErrorMessage } from '../utils/error-handler.js';
 import { EventEmitter } from 'node:events';
 import * as os from 'node:os';
 import * as fs from 'node:fs/promises';
@@ -45,7 +44,13 @@ interface Alert {
   id: string;
   timestamp: number;
   level: 'info' | 'warning' | 'error' | 'critical';
-  type: 'agent_failure' | 'high_cpu' | 'high_memory' | 'stalled_agent' | 'low_throughput' | 'error_rate';
+  type:
+    | 'agent_failure'
+    | 'high_cpu'
+    | 'high_memory'
+    | 'stalled_agent'
+    | 'low_throughput'
+    | 'error_rate';
   message: string;
   details?: any;
 }
@@ -90,7 +95,7 @@ export class SwarmMonitor extends EventEmitter {
       enableAlerts: true,
       enableHistory: true,
       historyPath: './monitoring/history',
-      ...config
+      ...config,
     };
     this.startTime = Date.now();
     this.lastThroughputCheck = Date.now();
@@ -132,7 +137,7 @@ export class SwarmMonitor extends EventEmitter {
       failureCount: 0,
       averageTaskDuration: 0,
       lastActivity: Date.now(),
-      errorRate: 0
+      errorRate: 0,
     });
     this.logger.debug(`Registered agent: ${name} (${agentId})`);
   }
@@ -162,7 +167,7 @@ export class SwarmMonitor extends EventEmitter {
   taskCompleted(agentId: string, taskId: string, outputSize?: number): void {
     const metrics = this.agentMetrics.get(agentId);
     const startTime = this.taskStartTimes.get(taskId);
-    
+
     if (metrics && startTime) {
       const duration = Date.now() - startTime;
       metrics.status = 'completed';
@@ -171,18 +176,18 @@ export class SwarmMonitor extends EventEmitter {
       metrics.lastActivity = Date.now();
       metrics.successCount++;
       metrics.outputSize = outputSize;
-      
+
       // Update average duration
       const totalDuration = metrics.averageTaskDuration * (metrics.successCount - 1) + duration;
       metrics.averageTaskDuration = totalDuration / metrics.successCount;
-      
+
       // Update error rate
       metrics.errorRate = (metrics.failureCount / metrics.taskCount) * 100;
-      
+
       // Track for throughput calculation
       this.taskCompletionTimes.push(Date.now());
       this.tasksInLastMinute++;
-      
+
       this.taskStartTimes.delete(taskId);
       this.emit('task:completed', { agentId, taskId, duration, outputSize });
     }
@@ -191,7 +196,7 @@ export class SwarmMonitor extends EventEmitter {
   taskFailed(agentId: string, taskId: string, error: string): void {
     const metrics = this.agentMetrics.get(agentId);
     const startTime = this.taskStartTimes.get(taskId);
-    
+
     if (metrics) {
       const duration = startTime ? Date.now() - startTime : 0;
       metrics.status = 'failed';
@@ -199,17 +204,20 @@ export class SwarmMonitor extends EventEmitter {
       metrics.duration = duration;
       metrics.lastActivity = Date.now();
       metrics.failureCount++;
-      
+
       // Update error rate
       metrics.errorRate = (metrics.failureCount / metrics.taskCount) * 100;
-      
+
       this.taskStartTimes.delete(taskId);
       this.emit('task:failed', { agentId, taskId, error, duration });
-      
+
       // Check error rate threshold
       if (metrics.errorRate > this.config.errorRateThreshold) {
-        this.createAlert('error_rate', 'critical', 
-          `Agent ${metrics.name} has high error rate: ${metrics.errorRate.toFixed(1)}%`);
+        this.createAlert(
+          'error_rate',
+          'critical',
+          `Agent ${metrics.name} has high error rate: ${metrics.errorRate.toFixed(1)}%`,
+        );
       }
     }
   }
@@ -221,13 +229,13 @@ export class SwarmMonitor extends EventEmitter {
       const cpuUsage = this.getCPUUsage();
       const memInfo = this.getMemoryInfo();
       const loadAvg = os.loadavg();
-      
+
       // Calculate throughput
       const now = Date.now();
       const minuteAgo = now - 60000;
-      this.taskCompletionTimes = this.taskCompletionTimes.filter(time => time > minuteAgo);
+      this.taskCompletionTimes = this.taskCompletionTimes.filter((time) => time > minuteAgo);
       const throughput = this.taskCompletionTimes.length;
-      
+
       // Calculate task statistics
       let totalTasks = 0;
       let completedTasks = 0;
@@ -235,34 +243,37 @@ export class SwarmMonitor extends EventEmitter {
       let activeAgents = 0;
       let totalDuration = 0;
       let durationCount = 0;
-      
+
       // Check for stalled agents
       for (const [agentId, metrics] of this.agentMetrics) {
         if (metrics.status === 'running') {
           activeAgents++;
-          
+
           // Check for stalled agent
           const stallTime = now - metrics.lastActivity;
           if (stallTime > this.config.stallTimeout) {
             metrics.status = 'stalled';
-            this.createAlert('stalled_agent', 'warning', 
-              `Agent ${metrics.name} appears to be stalled (${Math.round(stallTime / 1000)}s inactive)`);
+            this.createAlert(
+              'stalled_agent',
+              'warning',
+              `Agent ${metrics.name} appears to be stalled (${Math.round(stallTime / 1000)}s inactive)`,
+            );
           }
         }
-        
+
         totalTasks += metrics.taskCount;
         completedTasks += metrics.successCount;
         failedTasks += metrics.failureCount;
-        
+
         if (metrics.averageTaskDuration > 0) {
           totalDuration += metrics.averageTaskDuration * metrics.successCount;
           durationCount += metrics.successCount;
         }
       }
-      
+
       const avgDuration = durationCount > 0 ? totalDuration / durationCount : 0;
       const pendingTasks = totalTasks - completedTasks - failedTasks;
-      
+
       // Create system metrics
       const systemMetrics: SystemMetrics = {
         timestamp: now,
@@ -277,30 +288,29 @@ export class SwarmMonitor extends EventEmitter {
         failedTasks,
         pendingTasks,
         averageTaskDuration: avgDuration,
-        throughput
+        throughput,
       };
-      
+
       this.systemMetrics.push(systemMetrics);
-      
+
       // Check system thresholds
       if (this.config.enableAlerts) {
         this.checkThresholds(systemMetrics);
       }
-      
+
       // Clean old metrics
       this.cleanOldMetrics();
-      
+
       // Save history if enabled
       if (this.config.enableHistory) {
         await this.saveHistory(systemMetrics);
       }
-      
+
       // Emit metrics update
       this.emit('metrics:updated', {
         system: systemMetrics,
-        agents: Array.from(this.agentMetrics.values())
+        agents: Array.from(this.agentMetrics.values()),
       });
-      
     } catch (error) {
       this.logger.error('Error collecting metrics:', error);
     }
@@ -310,15 +320,15 @@ export class SwarmMonitor extends EventEmitter {
     const cpus = os.cpus();
     let totalIdle = 0;
     let totalTick = 0;
-    
-    cpus.forEach(cpu => {
+
+    cpus.forEach((cpu) => {
       for (const type in cpu.times) {
         totalTick += cpu.times[type as keyof typeof cpu.times];
       }
       totalIdle += cpu.times.idle;
     });
-    
-    return 100 - Math.floor(totalIdle / totalTick * 100);
+
+    return 100 - Math.floor((totalIdle / totalTick) * 100);
   }
 
   private getMemoryInfo(): { total: number; free: number; used: number; usagePercent: number } {
@@ -326,40 +336,50 @@ export class SwarmMonitor extends EventEmitter {
     const free = os.freemem();
     const used = total - free;
     const usagePercent = (used / total) * 100;
-    
+
     return { total, free, used, usagePercent };
   }
 
   private checkThresholds(metrics: SystemMetrics): void {
     // CPU threshold
     if (metrics.cpuUsage > this.config.cpuThreshold) {
-      this.createAlert('high_cpu', 'warning', 
-        `High CPU usage detected: ${metrics.cpuUsage}%`);
+      this.createAlert('high_cpu', 'warning', `High CPU usage detected: ${metrics.cpuUsage}%`);
     }
-    
+
     // Memory threshold
     if (metrics.memoryUsage > this.config.memoryThreshold) {
-      this.createAlert('high_memory', 'warning', 
-        `High memory usage detected: ${metrics.memoryUsage.toFixed(1)}%`);
+      this.createAlert(
+        'high_memory',
+        'warning',
+        `High memory usage detected: ${metrics.memoryUsage.toFixed(1)}%`,
+      );
     }
-    
+
     // Throughput threshold
     if (metrics.activeAgents > 0 && metrics.throughput < this.config.throughputThreshold) {
-      this.createAlert('low_throughput', 'warning', 
-        `Low throughput detected: ${metrics.throughput} tasks/min`);
+      this.createAlert(
+        'low_throughput',
+        'warning',
+        `Low throughput detected: ${metrics.throughput} tasks/min`,
+      );
     }
   }
 
-  private createAlert(type: Alert['type'], level: Alert['level'], message: string, details?: any): void {
+  private createAlert(
+    type: Alert['type'],
+    level: Alert['level'],
+    message: string,
+    details?: any,
+  ): void {
     const alert: Alert = {
       id: `${type}_${Date.now()}`,
       timestamp: Date.now(),
       level,
       type,
       message,
-      details
+      details,
     };
-    
+
     this.alerts.push(alert);
     this.emit('alert', alert);
     this.logger[level](message);
@@ -368,24 +388,25 @@ export class SwarmMonitor extends EventEmitter {
   private cleanOldMetrics(): void {
     const retentionTime = this.config.metricsRetention * 60 * 60 * 1000;
     const cutoff = Date.now() - retentionTime;
-    
-    this.systemMetrics = this.systemMetrics.filter(m => m.timestamp > cutoff);
-    this.alerts = this.alerts.filter(a => a.timestamp > cutoff);
+
+    this.systemMetrics = this.systemMetrics.filter((m) => m.timestamp > cutoff);
+    this.alerts = this.alerts.filter((a) => a.timestamp > cutoff);
   }
 
   private async saveHistory(metrics: SystemMetrics): Promise<void> {
     if (!this.config.historyPath) return;
-    
+
     try {
       const date = new Date();
       const filename = `metrics_${date.toISOString().split('T')[0]}.jsonl`;
       const filepath = path.join(this.config.historyPath, filename);
-      
-      const line = JSON.stringify({
-        ...metrics,
-        agents: Array.from(this.agentMetrics.values())
-      }) + '\n';
-      
+
+      const line =
+        JSON.stringify({
+          ...metrics,
+          agents: Array.from(this.agentMetrics.values()),
+        }) + '\n';
+
       await fs.appendFile(filepath, line);
     } catch (error) {
       this.logger.error('Error saving history:', error);
@@ -406,14 +427,14 @@ export class SwarmMonitor extends EventEmitter {
 
   getAlerts(since?: number): Alert[] {
     if (since) {
-      return this.alerts.filter(a => a.timestamp > since);
+      return this.alerts.filter((a) => a.timestamp > since);
     }
     return this.alerts;
   }
 
   getHistoricalMetrics(hours: number = 1): SystemMetrics[] {
-    const since = Date.now() - (hours * 60 * 60 * 1000);
-    return this.systemMetrics.filter(m => m.timestamp > since);
+    const since = Date.now() - hours * 60 * 60 * 1000;
+    return this.systemMetrics.filter((m) => m.timestamp > since);
   }
 
   // Summary statistics
@@ -439,8 +460,8 @@ export class SwarmMonitor extends EventEmitter {
     const successRate = totalTasks > 0 ? (completedTasks / totalTasks) * 100 : 0;
     const averageDuration = current?.averageTaskDuration || 0;
     const currentThroughput = current?.throughput || 0;
-    const alerts = this.alerts.filter(a => a.timestamp > Date.now() - 3600000).length; // Last hour
-    
+    const alerts = this.alerts.filter((a) => a.timestamp > Date.now() - 3600000).length; // Last hour
+
     return {
       uptime,
       totalAgents,
@@ -451,7 +472,7 @@ export class SwarmMonitor extends EventEmitter {
       successRate,
       averageDuration,
       currentThroughput,
-      alerts
+      alerts,
     };
   }
 
@@ -462,13 +483,13 @@ export class SwarmMonitor extends EventEmitter {
       systemMetrics: this.systemMetrics,
       agentMetrics: Array.from(this.agentMetrics.values()),
       alerts: this.alerts,
-      exported: new Date().toISOString()
+      exported: new Date().toISOString(),
     };
-    
+
     await fs.writeFile(filepath, JSON.stringify(data, null, 2));
     this.logger.info(`Exported metrics to ${filepath}`);
   }
 }
 
 // Export types for external use
-export type { AgentMetrics, SystemMetrics, Alert, MonitoringConfig };
+export type { AgentMetrics, SystemMetrics, Alert, MonitoringConfig };

package/src/coordination/work-stealing.ts

@@ -1,4 +1,3 @@
-import { getErrorMessage } from '../utils/error-handler.js';
 /**
  * Work stealing algorithm for load balancing between agents
  */
@@ -45,19 +44,16 @@ export class WorkStealingCoordinator {
     }
 
     this.logger.info('Initializing work stealing coordinator');
-    
+
     // Start periodic steal checks
-    this.stealInterval = setInterval(
-      () => this.checkAndSteal(),
-      this.config.stealInterval,
-    );
+    this.stealInterval = setInterval(() => this.checkAndSteal(), this.config.stealInterval);
   }
 
   async shutdown(): Promise<void> {
     if (this.stealInterval) {
       clearInterval(this.stealInterval);
     }
-    
+
     this.workloads.clear();
     this.taskDurations.clear();
   }
@@ -113,10 +109,7 @@ export class WorkStealingCoordinator {
     }
 
     // Calculate how many tasks to steal
-    const tasksToSteal = Math.min(
-      Math.floor(difference / 2),
-      this.config.maxStealBatch,
-    );
+    const tasksToSteal = Math.min(Math.floor(difference / 2), this.config.maxStealBatch);
 
     this.logger.info('Initiating work stealing', {
       from: maxLoaded.agentId,
@@ -182,7 +175,7 @@ export class WorkStealingCoordinator {
 
     // Sort by score (descending) and return best
     candidates.sort((a, b) => b.score - a.score);
-    
+
     this.logger.debug('Agent selection scores', {
       taskId: task.id,
       candidates: candidates.slice(0, 5), // Top 5
@@ -222,4 +215,4 @@ export class WorkStealingCoordinator {
 
     return stats;
   }
-}
+}