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

package/src/coordination/advanced-task-executor.ts

@@ -5,7 +5,13 @@ import { getErrorMessage, getErrorStack } from '../utils/type-guards.js';
 
 import { EventEmitter } from 'node:events';
 import { spawn, ChildProcess } from 'node:child_process';
-import type { TaskDefinition, TaskResult, TaskStatus, AgentState, TaskError } from '../swarm/types.js';
+import type {
+  TaskDefinition,
+  TaskResult,
+  TaskStatus,
+  AgentState,
+  TaskError,
+} from '../swarm/types.js';
 import type { ILogger } from '../core/logger.js';
 import type { IEventBus } from '../core/event-bus.js';
 import { CircuitBreaker, CircuitBreakerManager } from './circuit-breaker.js';
@@ -67,15 +73,11 @@ export class AdvancedTaskExecutor extends EventEmitter {
   private queuedTasks: TaskDefinition[] = [];
   private isShuttingDown = false;
 
-  constructor(
-    config: Partial<TaskExecutorConfig>,
-    logger: ILogger,
-    eventBus: IEventBus
-  ) {
+  constructor(config: Partial<TaskExecutorConfig>, logger: ILogger, eventBus: IEventBus) {
     super();
     this.logger = logger;
     this.eventBus = eventBus;
-    
+
     this.config = {
       maxConcurrentTasks: 10,
       defaultTimeout: 300000, // 5 minutes
@@ -90,7 +92,7 @@ export class AdvancedTaskExecutor extends EventEmitter {
       enableCircuitBreaker: true,
       enableResourceMonitoring: true,
       killTimeout: 5000,
-      ...config
+      ...config,
     };
 
     // Initialize circuit breaker manager
@@ -102,7 +104,7 @@ export class AdvancedTaskExecutor extends EventEmitter {
         halfOpenLimit: 2,
       },
       this.logger,
-      this.eventBus
+      this.eventBus,
     );
 
     this.setupEventHandlers();
@@ -124,7 +126,7 @@ export class AdvancedTaskExecutor extends EventEmitter {
     this.logger.info('Initializing advanced task executor', {
       maxConcurrentTasks: this.config.maxConcurrentTasks,
       defaultTimeout: this.config.defaultTimeout,
-      resourceLimits: this.config.resourceLimits
+      resourceLimits: this.config.resourceLimits,
     });
 
     if (this.config.enableResourceMonitoring) {
@@ -144,8 +146,8 @@ export class AdvancedTaskExecutor extends EventEmitter {
     }
 
     // Cancel all running tasks
-    const cancelPromises = Array.from(this.runningTasks.values()).map(ctx =>
-      this.cancelTask(ctx.taskId, 'Shutdown requested')
+    const cancelPromises = Array.from(this.runningTasks.values()).map((ctx) =>
+      this.cancelTask(ctx.taskId, 'Shutdown requested'),
     );
 
     await Promise.all(cancelPromises);
@@ -163,7 +165,7 @@ export class AdvancedTaskExecutor extends EventEmitter {
       timeout?: number;
       retryAttempts?: number;
       priority?: number;
-    } = {}
+    } = {},
   ): Promise<TaskExecutionResult> {
     const startTime = Date.now();
     let retryCount = 0;
@@ -175,7 +177,7 @@ export class AdvancedTaskExecutor extends EventEmitter {
       agentId: agent.id.id,
       type: task.type,
       timeout,
-      maxRetries
+      maxRetries,
     });
 
     // Check if we have capacity
@@ -183,9 +185,9 @@ export class AdvancedTaskExecutor extends EventEmitter {
       this.queuedTasks.push(task);
       this.logger.info('Task queued due to capacity limits', {
         taskId: task.id.id,
-        queueSize: this.queuedTasks.length
+        queueSize: this.queuedTasks.length,
       });
-      
+
       // Wait for capacity
       await this.waitForCapacity();
     }
@@ -193,11 +195,11 @@ export class AdvancedTaskExecutor extends EventEmitter {
     while (retryCount <= maxRetries) {
       try {
         const result = await this.executeSingleAttempt(task, agent, timeout, retryCount);
-        
+
         this.logger.info('Task completed successfully', {
           taskId: task.id.id,
           executionTime: Date.now() - startTime,
-          retryCount
+          retryCount,
         });
 
         return {
@@ -205,17 +207,16 @@ export class AdvancedTaskExecutor extends EventEmitter {
           result: result.result,
           executionTime: Date.now() - startTime,
           resourcesUsed: result.resourcesUsed,
-          retryCount
+          retryCount,
         };
-
       } catch (error) {
         retryCount++;
-        
+
         this.logger.warn('Task attempt failed', {
           taskId: task.id.id,
           attempt: retryCount,
           maxRetries,
-          error: getErrorMessage(error)
+          error: getErrorMessage(error),
         });
 
         // Check if we should retry
@@ -227,10 +228,10 @@ export class AdvancedTaskExecutor extends EventEmitter {
             context: {
               retryCount,
               maxRetries,
-              taskType: task.type
+              taskType: task.type,
             },
             recoverable: false,
-            retryable: false
+            retryable: false,
           };
 
           return {
@@ -238,20 +239,20 @@ export class AdvancedTaskExecutor extends EventEmitter {
             error: taskError,
             executionTime: Date.now() - startTime,
             resourcesUsed: this.getDefaultResourceUsage(),
-            retryCount
+            retryCount,
           };
         }
 
         // Calculate backoff delay
         const backoffDelay = Math.min(
           this.config.retryBackoffBase * Math.pow(2, retryCount - 1),
-          this.config.retryBackoffMax
+          this.config.retryBackoffMax,
         );
 
         this.logger.info('Retrying task after backoff', {
           taskId: task.id.id,
           backoffDelay,
-          attempt: retryCount + 1
+          attempt: retryCount + 1,
         });
 
         await this.delay(backoffDelay);
@@ -266,13 +267,13 @@ export class AdvancedTaskExecutor extends EventEmitter {
     task: TaskDefinition,
     agent: AgentState,
     timeout: number,
-    retryCount: number
+    retryCount: number,
   ): Promise<{ result: TaskResult; resourcesUsed: ResourceUsage }> {
     const executionContext: ExecutionContext = {
       taskId: task.id.id,
       agentId: agent.id.id,
       startTime: new Date(),
-      resources: this.getDefaultResourceUsage()
+      resources: this.getDefaultResourceUsage(),
     };
 
     this.runningTasks.set(task.id.id, executionContext);
@@ -288,14 +289,17 @@ export class AdvancedTaskExecutor extends EventEmitter {
       // Set up circuit breaker if enabled
       if (this.config.enableCircuitBreaker) {
         executionContext.circuitBreaker = this.circuitBreakerManager.getBreaker(
-          `agent-${agent.id.id}`
+          `agent-${agent.id.id}`,
         );
       }
 
       // Execute task with circuit breaker protection
-      const executionPromise = this.config.enableCircuitBreaker && executionContext.circuitBreaker
-        ? executionContext.circuitBreaker.execute(() => this.performTaskExecution(task, agent, executionContext))
-        : this.performTaskExecution(task, agent, executionContext);
+      const executionPromise =
+        this.config.enableCircuitBreaker && executionContext.circuitBreaker
+          ? executionContext.circuitBreaker.execute(() =>
+              this.performTaskExecution(task, agent, executionContext),
+            )
+          : this.performTaskExecution(task, agent, executionContext);
 
       // Race between execution and timeout
       const result = await Promise.race([executionPromise, timeoutPromise]);
@@ -306,11 +310,10 @@ export class AdvancedTaskExecutor extends EventEmitter {
       }
 
       return result;
-
     } finally {
       // Cleanup
       this.runningTasks.delete(task.id.id);
-      
+
       // Process queued tasks
       this.processQueuedTasks();
     }
@@ -319,17 +322,17 @@ export class AdvancedTaskExecutor extends EventEmitter {
   private async performTaskExecution(
     task: TaskDefinition,
     agent: AgentState,
-    context: ExecutionContext
+    context: ExecutionContext,
   ): Promise<{ result: TaskResult; resourcesUsed: ResourceUsage }> {
     const startTime = Date.now();
 
     // Create task execution command
     const command = this.buildExecutionCommand(task, agent);
-    
+
     this.logger.debug('Executing task command', {
       taskId: task.id.id,
       command: command.cmd,
-      args: command.args
+      args: command.args,
     });
 
     // Spawn process
@@ -340,8 +343,8 @@ export class AdvancedTaskExecutor extends EventEmitter {
         ...command.env,
         TASK_ID: task.id.id,
         AGENT_ID: agent.id.id,
-        TASK_TYPE: task.type
-      }
+        TASK_TYPE: task.type,
+      },
     });
 
     context.process = childProcess;
@@ -360,11 +363,13 @@ export class AdvancedTaskExecutor extends EventEmitter {
 
     // Send input if provided
     if (task.input && childProcess.stdin) {
-      childProcess.stdin.write(JSON.stringify({
-        task: task,
-        agent: agent,
-        input: task.input
-      }));
+      childProcess.stdin.write(
+        JSON.stringify({
+          task: task,
+          agent: agent,
+          input: task.input,
+        }),
+      );
       childProcess.stdin.end();
     }
 
@@ -383,7 +388,7 @@ export class AdvancedTaskExecutor extends EventEmitter {
 
     // Parse result
     let taskResult: TaskResult;
-    
+
     if (exitCode === 0) {
       try {
         const output = JSON.parse(stdout);
@@ -396,7 +401,7 @@ export class AdvancedTaskExecutor extends EventEmitter {
           accuracy: output.accuracy || 0.9,
           executionTime,
           resourcesUsed: context.resources,
-          validated: false
+          validated: false,
         };
       } catch (error) {
         taskResult = {
@@ -408,7 +413,7 @@ export class AdvancedTaskExecutor extends EventEmitter {
           accuracy: 0.7,
           executionTime,
           resourcesUsed: context.resources,
-          validated: false
+          validated: false,
         };
       }
     } else {
@@ -417,18 +422,21 @@ export class AdvancedTaskExecutor extends EventEmitter {
 
     return {
       result: taskResult,
-      resourcesUsed: context.resources
+      resourcesUsed: context.resources,
     };
   }
 
-  private buildExecutionCommand(task: TaskDefinition, agent: AgentState): {
+  private buildExecutionCommand(
+    task: TaskDefinition,
+    agent: AgentState,
+  ): {
     cmd: string;
     args: string[];
     env: Record<string, string>;
   } {
     // This would be customized based on task type and agent capabilities
     // For now, return a default Claude execution command
-    
+
     const cmd = 'deno';
     const args = [
       'run',
@@ -438,13 +446,13 @@ export class AdvancedTaskExecutor extends EventEmitter {
       '--task-type',
       task.type,
       '--agent-type',
-      agent.type
+      agent.type,
     ];
 
     const env = {
       TASK_TIMEOUT: (task.constraints.timeoutAfter || this.config.defaultTimeout).toString(),
       MEMORY_LIMIT: this.config.resourceLimits.memory.toString(),
-      CPU_LIMIT: this.config.resourceLimits.cpu.toString()
+      CPU_LIMIT: this.config.resourceLimits.cpu.toString(),
     };
 
     return { cmd, args, env };
@@ -494,7 +502,7 @@ export class AdvancedTaskExecutor extends EventEmitter {
           const usage = await this.getProcessResourceUsage(context.process.pid);
           context.resources = {
             ...usage,
-            lastUpdated: new Date()
+            lastUpdated: new Date(),
           };
 
           // Check resource limits
@@ -502,7 +510,7 @@ export class AdvancedTaskExecutor extends EventEmitter {
         } catch (error) {
           this.logger.warn('Failed to get resource usage', {
             taskId,
-            error: getErrorMessage(error)
+            error: getErrorMessage(error),
           });
         }
       }
@@ -520,7 +528,7 @@ export class AdvancedTaskExecutor extends EventEmitter {
       cpu: Math.random() * 100,
       disk: Math.random() * this.config.resourceLimits.disk,
       network: Math.random() * 1024 * 1024,
-      lastUpdated: new Date()
+      lastUpdated: new Date(),
     };
   }
 
@@ -532,17 +540,18 @@ export class AdvancedTaskExecutor extends EventEmitter {
       this.logger.warn('Task exceeding memory limit', {
         taskId,
         current: memory,
-        limit: limits.memory
+        limit: limits.memory,
       });
-      
+
       this.cancelTask(taskId, 'Memory limit exceeded');
     }
 
-    if (cpu > limits.cpu * 100) { // CPU is in percentage
+    if (cpu > limits.cpu * 100) {
+      // CPU is in percentage
       this.logger.warn('Task exceeding CPU limit', {
         taskId,
         current: cpu,
-        limit: limits.cpu * 100
+        limit: limits.cpu * 100,
       });
     }
   }
@@ -553,7 +562,7 @@ export class AdvancedTaskExecutor extends EventEmitter {
       cpu: 0,
       disk: 0,
       network: 0,
-      lastUpdated: new Date()
+      lastUpdated: new Date(),
     };
   }
 
@@ -571,10 +580,7 @@ export class AdvancedTaskExecutor extends EventEmitter {
   }
 
   private processQueuedTasks(): void {
-    while (
-      this.queuedTasks.length > 0 &&
-      this.runningTasks.size < this.config.maxConcurrentTasks
-    ) {
+    while (this.queuedTasks.length > 0 && this.runningTasks.size < this.config.maxConcurrentTasks) {
       const task = this.queuedTasks.shift();
       if (task) {
         this.emit('task-dequeued', { taskId: task.id.id });
@@ -583,7 +589,7 @@ export class AdvancedTaskExecutor extends EventEmitter {
   }
 
   private async delay(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms));
+    return new Promise((resolve) => setTimeout(resolve, ms));
   }
 
   private async gracefulShutdown(): Promise<void> {
@@ -620,7 +626,7 @@ export class AdvancedTaskExecutor extends EventEmitter {
       maxConcurrentTasks: this.config.maxConcurrentTasks,
       totalCapacity: this.config.maxConcurrentTasks,
       resourceLimits: this.config.resourceLimits,
-      circuitBreakers: this.circuitBreakerManager.getAllMetrics()
+      circuitBreakers: this.circuitBreakerManager.getAllMetrics(),
     };
   }
 
@@ -632,4 +638,4 @@ export class AdvancedTaskExecutor extends EventEmitter {
     this.config = { ...this.config, ...newConfig };
     this.logger.info('Task executor configuration updated', { newConfig });
   }
-}
+}

package/src/coordination/background-executor.ts

@@ -1,4 +1,3 @@
-import { getErrorMessage } from '../utils/error-handler.js';
 import { spawn, ChildProcess } from 'node:child_process';
 import { EventEmitter } from 'node:events';
 import { Logger } from '../core/logger.js';
@@ -58,7 +57,7 @@ export class BackgroundExecutor extends EventEmitter {
       checkInterval: 1000, // 1 second
       cleanupInterval: 60000, // 1 minute
       maxRetries: 3,
-      ...config
+      ...config,
     };
 
     this.tasks = new Map();
@@ -121,7 +120,7 @@ export class BackgroundExecutor extends EventEmitter {
     type: BackgroundTask['type'],
     command: string,
     args: string[] = [],
-    options: BackgroundTask['options'] = {}
+    options: BackgroundTask['options'] = {},
   ): Promise<string> {
     const taskId = generateId('bgtask');
     const task: BackgroundTask = {
@@ -132,10 +131,10 @@ export class BackgroundExecutor extends EventEmitter {
       options: {
         timeout: this.config.defaultTimeout,
         retries: this.config.maxRetries,
-        ...options
+        ...options,
       },
       status: 'pending',
-      retryCount: 0
+      retryCount: 0,
     };
 
     this.tasks.set(taskId, task);
@@ -163,11 +162,11 @@ export class BackgroundExecutor extends EventEmitter {
       timeout: number;
       model?: string;
       maxTokens?: number;
-    }> = {}
+    }> = {},
   ): Promise<string> {
     // Build claude command arguments
     const args = ['-p', prompt];
-    
+
     if (tools.length > 0) {
       args.push('--allowedTools', tools.join(','));
     }
@@ -184,7 +183,7 @@ export class BackgroundExecutor extends EventEmitter {
 
     return this.submitTask('claude-spawn', 'claude', args, {
       ...options,
-      detached: true // Run in background
+      detached: true, // Run in background
     });
   }
 
@@ -192,8 +191,9 @@ export class BackgroundExecutor extends EventEmitter {
     if (!this.isRunning) return;
 
     // Check how many tasks are running
-    const runningTasks = Array.from(this.tasks.values())
-      .filter(t => t.status === 'running').length;
+    const runningTasks = Array.from(this.tasks.values()).filter(
+      (t) => t.status === 'running',
+    ).length;
 
     const availableSlots = this.config.maxConcurrentTasks - runningTasks;
 
@@ -227,7 +227,7 @@ export class BackgroundExecutor extends EventEmitter {
         cwd: task.options?.cwd,
         env: { ...process.env, ...task.options?.env },
         detached: task.options?.detached,
-        stdio: ['ignore', 'pipe', 'pipe']
+        stdio: ['ignore', 'pipe', 'pipe'],
       });
 
       task.pid = process.pid;
@@ -260,13 +260,15 @@ export class BackgroundExecutor extends EventEmitter {
         } else {
           task.status = 'failed';
           this.logger.error(`Task ${task.id} failed with code ${code}`);
-          
+
           // Retry logic
           if (task.retryCount < (task.options?.retries || 0)) {
             task.retryCount++;
             task.status = 'pending';
             this.queue.push(task.id);
-            this.logger.info(`Retrying task ${task.id} (${task.retryCount}/${task.options?.retries})`);
+            this.logger.info(
+              `Retrying task ${task.id} (${task.retryCount}/${task.options?.retries})`,
+            );
             this.emit('task:retry', task);
           } else {
             this.emit('task:failed', task);
@@ -300,12 +302,11 @@ export class BackgroundExecutor extends EventEmitter {
       if (this.config.enablePersistence) {
         await this.saveTaskState(task);
       }
-
     } catch (error) {
       task.status = 'failed';
       task.error = String(error);
       task.endTime = new Date();
-      
+
       this.logger.error(`Failed to execute task ${task.id}:`, error);
       this.emit('task:failed', task);
 
@@ -330,7 +331,7 @@ export class BackgroundExecutor extends EventEmitter {
         if (process) {
           this.logger.warn(`Killing timed out task ${taskId}`);
           process.kill('SIGTERM');
-          
+
           // Force kill after 5 seconds
           setTimeout(() => {
             if (this.processes.has(taskId)) {
@@ -371,11 +372,11 @@ export class BackgroundExecutor extends EventEmitter {
 
     try {
       const logDir = path.join(this.config.logPath, task.id);
-      
+
       if (task.output) {
         await fs.writeFile(path.join(logDir, 'stdout.log'), task.output);
       }
-      
+
       if (task.error) {
         await fs.writeFile(path.join(logDir, 'stderr.log'), task.error);
       }
@@ -394,7 +395,7 @@ export class BackgroundExecutor extends EventEmitter {
 
   getTasks(status?: BackgroundTask['status']): BackgroundTask[] {
     const tasks = Array.from(this.tasks.values());
-    return status ? tasks.filter(t => t.status === status) : tasks;
+    return status ? tasks.filter((t) => t.status === status) : tasks;
   }
 
   async waitForTask(taskId: string, timeout?: number): Promise<BackgroundTask> {
@@ -410,9 +411,11 @@ export class BackgroundExecutor extends EventEmitter {
         return;
       }
 
-      const timeoutHandle = timeout ? setTimeout(() => {
-        reject(new Error('Wait timeout'));
-      }, timeout) : undefined;
+      const timeoutHandle = timeout
+        ? setTimeout(() => {
+            reject(new Error('Wait timeout'));
+          }, timeout)
+        : undefined;
 
       const checkTask = () => {
         const currentTask = this.tasks.get(taskId);
@@ -444,7 +447,7 @@ export class BackgroundExecutor extends EventEmitter {
     if (process) {
       this.logger.info(`Killing task ${taskId}`);
       process.kill('SIGTERM');
-      
+
       // Force kill after 5 seconds
       setTimeout(() => {
         if (this.processes.has(taskId)) {
@@ -456,7 +459,7 @@ export class BackgroundExecutor extends EventEmitter {
     task.status = 'failed';
     task.error = 'Task killed by user';
     task.endTime = new Date();
-    
+
     this.emit('task:killed', task);
   }
 
@@ -469,11 +472,11 @@ export class BackgroundExecutor extends EventEmitter {
   } {
     const tasks = Array.from(this.tasks.values());
     return {
-      running: tasks.filter(t => t.status === 'running').length,
-      pending: tasks.filter(t => t.status === 'pending').length,
-      completed: tasks.filter(t => t.status === 'completed').length,
-      failed: tasks.filter(t => t.status === 'failed').length,
-      queueLength: this.queue.length
+      running: tasks.filter((t) => t.status === 'running').length,
+      pending: tasks.filter((t) => t.status === 'pending').length,
+      completed: tasks.filter((t) => t.status === 'completed').length,
+      failed: tasks.filter((t) => t.status === 'failed').length,
+      queueLength: this.queue.length,
     };
   }
-}
+}