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

package/src/cli/simple-commands/sparc/coordinator.js

@@ -14,14 +14,14 @@ export class SparcCoordinator {
       strategy: 'adaptive',
       topology: 'hierarchical',
       communication: 'event-driven',
-      loadBalancing: 'capability-based'
+      loadBalancing: 'capability-based',
     };
     this.metrics = {
       phaseExecutions: 0,
       agentUtilization: {},
       coordinationEfficiency: 0,
       qualityGates: [],
-      learningData: []
+      learningData: [],
     };
     this.neuralContext = null;
     this.swarmEnabled = options.swarmEnabled || false;
@@ -45,7 +45,7 @@ export class SparcCoordinator {
         maxAgents: this.calculateOptimalAgentCount(),
         strategy: 'sparc_methodology',
         communication: this.coordination.communication,
-        loadBalancing: this.coordination.loadBalancing
+        loadBalancing: this.coordination.loadBalancing,
       };
 
       this.swarmId = await this.executeSwarmHook('swarm_init', swarmConfig);
@@ -72,7 +72,7 @@ export class SparcCoordinator {
     const baseAgents = Object.keys(this.phases).length; // One per phase
     const complexityMultiplier = this.assessTaskComplexity();
     const parallelismFactor = this.options.parallelExecution ? 2 : 1;
-    
+
     return Math.min(20, Math.max(5, baseAgents * complexityMultiplier * parallelismFactor));
   }
 
@@ -81,11 +81,18 @@ export class SparcCoordinator {
    */
   assessTaskComplexity() {
     const taskDescription = this.options.taskDescription || '';
-    const complexityKeywords = ['complex', 'enterprise', 'scalable', 'distributed', 'microservice', 'integration'];
-    const matchedKeywords = complexityKeywords.filter(keyword => 
-      taskDescription.toLowerCase().includes(keyword)
+    const complexityKeywords = [
+      'complex',
+      'enterprise',
+      'scalable',
+      'distributed',
+      'microservice',
+      'integration',
+    ];
+    const matchedKeywords = complexityKeywords.filter((keyword) =>
+      taskDescription.toLowerCase().includes(keyword),
     );
-    
+
     if (matchedKeywords.length >= 3) return 3; // High complexity
     if (matchedKeywords.length >= 1) return 2; // Medium complexity
     return 1; // Low complexity
@@ -96,12 +103,36 @@ export class SparcCoordinator {
    */
   async spawnSparcAgents() {
     const agentTypes = [
-      { type: 'sparc_specification', role: 'Requirements Analyst', capabilities: ['analysis', 'documentation', 'validation'] },
-      { type: 'sparc_pseudocode', role: 'Logic Designer', capabilities: ['design', 'flowcharts', 'algorithms'] },
-      { type: 'sparc_architecture', role: 'System Architect', capabilities: ['architecture', 'design_patterns', 'scalability'] },
-      { type: 'sparc_refinement', role: 'TDD Engineer', capabilities: ['testing', 'refactoring', 'code_quality'] },
-      { type: 'sparc_completion', role: 'Integration Specialist', capabilities: ['integration', 'deployment', 'validation'] },
-      { type: 'sparc_coordinator', role: 'SPARC Orchestrator', capabilities: ['coordination', 'monitoring', 'optimization'] }
+      {
+        type: 'sparc_specification',
+        role: 'Requirements Analyst',
+        capabilities: ['analysis', 'documentation', 'validation'],
+      },
+      {
+        type: 'sparc_pseudocode',
+        role: 'Logic Designer',
+        capabilities: ['design', 'flowcharts', 'algorithms'],
+      },
+      {
+        type: 'sparc_architecture',
+        role: 'System Architect',
+        capabilities: ['architecture', 'design_patterns', 'scalability'],
+      },
+      {
+        type: 'sparc_refinement',
+        role: 'TDD Engineer',
+        capabilities: ['testing', 'refactoring', 'code_quality'],
+      },
+      {
+        type: 'sparc_completion',
+        role: 'Integration Specialist',
+        capabilities: ['integration', 'deployment', 'validation'],
+      },
+      {
+        type: 'sparc_coordinator',
+        role: 'SPARC Orchestrator',
+        capabilities: ['coordination', 'monitoring', 'optimization'],
+      },
     ];
 
     for (const agentSpec of agentTypes) {
@@ -111,7 +142,7 @@ export class SparcCoordinator {
           role: agentSpec.role,
           capabilities: agentSpec.capabilities,
           maxConcurrentTasks: this.getAgentConcurrency(agentSpec.type),
-          specialization: 'sparc_methodology'
+          specialization: 'sparc_methodology',
         });
 
         const agent = {
@@ -126,8 +157,8 @@ export class SparcCoordinator {
             tasksCompleted: 0,
             averageTime: 0,
             qualityScore: 1.0,
-            efficiency: 1.0
-          }
+            efficiency: 1.0,
+          },
         };
 
         this.agents.push(agent);
@@ -143,14 +174,14 @@ export class SparcCoordinator {
    */
   getAgentConcurrency(agentType) {
     const concurrencyMap = {
-      'sparc_specification': 2,
-      'sparc_pseudocode': 1,
-      'sparc_architecture': 3,
-      'sparc_refinement': 4,
-      'sparc_completion': 2,
-      'sparc_coordinator': 1
+      sparc_specification: 2,
+      sparc_pseudocode: 1,
+      sparc_architecture: 3,
+      sparc_refinement: 4,
+      sparc_completion: 2,
+      sparc_coordinator: 1,
     };
-    
+
     return concurrencyMap[agentType] || 2;
   }
 
@@ -173,11 +204,11 @@ export class SparcCoordinator {
     await this.executeSwarmHook('setup_dependencies', {
       phases: Object.keys(this.phases),
       dependencies: {
-        'pseudocode': ['specification'],
-        'architecture': ['specification', 'pseudocode'],
-        'refinement': ['specification', 'pseudocode', 'architecture'],
-        'completion': ['specification', 'pseudocode', 'architecture', 'refinement']
-      }
+        pseudocode: ['specification'],
+        architecture: ['specification', 'pseudocode'],
+        refinement: ['specification', 'pseudocode', 'architecture'],
+        completion: ['specification', 'pseudocode', 'architecture', 'refinement'],
+      },
     });
 
     // Setup quality gates between phases
@@ -192,28 +223,28 @@ export class SparcCoordinator {
       {
         phase: 'specification',
         criteria: ['requirements_complete', 'acceptance_criteria_defined'],
-        threshold: 0.9
+        threshold: 0.9,
       },
       {
         phase: 'pseudocode',
         criteria: ['flow_diagram_complete', 'algorithms_defined'],
-        threshold: 0.85
+        threshold: 0.85,
       },
       {
         phase: 'architecture',
         criteria: ['components_defined', 'patterns_selected'],
-        threshold: 0.85
+        threshold: 0.85,
       },
       {
         phase: 'refinement',
         criteria: ['tests_passing', 'code_quality_acceptable'],
-        threshold: 0.8
+        threshold: 0.8,
       },
       {
         phase: 'completion',
         criteria: ['validation_passed', 'deployment_successful'],
-        threshold: 0.9
-      }
+        threshold: 0.9,
+      },
     ];
 
     for (const gate of qualityGates) {
@@ -244,11 +275,10 @@ export class SparcCoordinator {
         key: `sparc_phase_${phaseName}_start`,
         value: {
           timestamp: Date.now(),
-          agents: this.phaseAgents.get(phaseName)?.map(a => a.id) || [],
-          neuralContext: this.neuralContext
-        }
+          agents: this.phaseAgents.get(phaseName)?.map((a) => a.id) || [],
+          neuralContext: this.neuralContext,
+        },
       });
-
     } catch (error) {
       console.warn(`⚠️ Pre-phase coordination failed for ${phaseName}: ${error.message}`);
     }
@@ -262,7 +292,7 @@ export class SparcCoordinator {
       const neuralData = await this.executeSwarmHook('neural_load_context', {
         phase: phaseName,
         methodology: 'sparc',
-        taskType: this.classifyTaskType()
+        taskType: this.classifyTaskType(),
       });
 
       this.neuralContext = {
@@ -270,13 +300,21 @@ export class SparcCoordinator {
         patterns: neuralData.patterns || [],
         insights: neuralData.insights || [],
         recommendations: neuralData.recommendations || [],
-        confidence: neuralData.confidence || 0.5
+        confidence: neuralData.confidence || 0.5,
       };
 
-      console.log(`🧠 Neural context loaded for ${phaseName} (confidence: ${this.neuralContext.confidence.toFixed(2)})`);
+      console.log(
+        `🧠 Neural context loaded for ${phaseName} (confidence: ${this.neuralContext.confidence.toFixed(2)})`,
+      );
     } catch (error) {
       console.warn(`⚠️ Neural context loading failed: ${error.message}`);
-      this.neuralContext = { phase: phaseName, patterns: [], insights: [], recommendations: [], confidence: 0.5 };
+      this.neuralContext = {
+        phase: phaseName,
+        patterns: [],
+        insights: [],
+        recommendations: [],
+        confidence: 0.5,
+      };
     }
   }
 
@@ -286,13 +324,13 @@ export class SparcCoordinator {
   classifyTaskType() {
     const taskDescription = this.options.taskDescription || '';
     const taskLower = taskDescription.toLowerCase();
-    
+
     if (taskLower.includes('api') || taskLower.includes('service')) return 'api_development';
     if (taskLower.includes('ui') || taskLower.includes('frontend')) return 'frontend_development';
     if (taskLower.includes('data') || taskLower.includes('database')) return 'data_management';
     if (taskLower.includes('test') || taskLower.includes('testing')) return 'testing';
     if (taskLower.includes('deploy') || taskLower.includes('infrastructure')) return 'deployment';
-    
+
     return 'general_development';
   }
 
@@ -301,31 +339,31 @@ export class SparcCoordinator {
    */
   async assignAgentsToPhase(phaseName) {
     const phaseAgents = this.phaseAgents.get(phaseName) || [];
-    
+
     for (const agent of phaseAgents) {
       agent.currentPhase = phaseName;
       agent.status = 'assigned';
-      
+
       await this.executeSwarmHook('agent_assign', {
         agentId: agent.id,
         phase: phaseName,
         priority: this.getPhasePriority(phaseName),
-        context: this.neuralContext
+        context: this.neuralContext,
       });
     }
 
     // If no dedicated agents, assign general coordinator
     if (phaseAgents.length === 0) {
-      const coordinator = this.agents.find(a => a.type === 'sparc_coordinator');
+      const coordinator = this.agents.find((a) => a.type === 'sparc_coordinator');
       if (coordinator) {
         coordinator.currentPhase = phaseName;
         coordinator.status = 'assigned';
-        
+
         await this.executeSwarmHook('agent_assign', {
           agentId: coordinator.id,
           phase: phaseName,
           priority: this.getPhasePriority(phaseName),
-          context: this.neuralContext
+          context: this.neuralContext,
         });
       }
     }
@@ -336,13 +374,13 @@ export class SparcCoordinator {
    */
   getPhasePriority(phaseName) {
     const priorities = {
-      'specification': 5, // Highest priority
-      'pseudocode': 4,
-      'architecture': 4,
-      'refinement': 3,
-      'completion': 2
+      specification: 5, // Highest priority
+      pseudocode: 4,
+      architecture: 4,
+      refinement: 3,
+      completion: 2,
     };
-    
+
     return priorities[phaseName] || 1;
   }
 
@@ -354,7 +392,7 @@ export class SparcCoordinator {
     await this.executeSwarmHook('create_workspace', {
       phase: phaseName,
       namespace: this.options.namespace || 'sparc',
-      isolation: true
+      isolation: true,
     });
 
     // Load previous phase artifacts
@@ -363,7 +401,7 @@ export class SparcCoordinator {
       await this.executeSwarmHook('load_artifacts', {
         fromPhase: dependency,
         toPhase: phaseName,
-        artifactTypes: ['outputs', 'decisions', 'validations']
+        artifactTypes: ['outputs', 'decisions', 'validations'],
       });
     }
   }
@@ -373,13 +411,13 @@ export class SparcCoordinator {
    */
   getPhaseDependencies(phaseName) {
     const dependencies = {
-      'specification': [],
-      'pseudocode': ['specification'],
-      'architecture': ['specification', 'pseudocode'],
-      'refinement': ['specification', 'pseudocode', 'architecture'],
-      'completion': ['specification', 'pseudocode', 'architecture', 'refinement']
+      specification: [],
+      pseudocode: ['specification'],
+      architecture: ['specification', 'pseudocode'],
+      refinement: ['specification', 'pseudocode', 'architecture'],
+      completion: ['specification', 'pseudocode', 'architecture', 'refinement'],
     };
-    
+
     return dependencies[phaseName] || [];
   }
 
@@ -405,11 +443,12 @@ export class SparcCoordinator {
           timestamp: Date.now(),
           result: result,
           validation: validation,
-          agents: this.phaseAgents.get(phaseName)?.map(a => ({
-            id: a.id,
-            performance: a.performance
-          })) || []
-        }
+          agents:
+            this.phaseAgents.get(phaseName)?.map((a) => ({
+              id: a.id,
+              performance: a.performance,
+            })) || [],
+        },
       });
 
       // Neural learning from phase execution
@@ -422,7 +461,6 @@ export class SparcCoordinator {
 
       // Update metrics
       this.updateCoordinationMetrics(phaseName, result, validation);
-
     } catch (error) {
       console.warn(`⚠️ Post-phase coordination failed for ${phaseName}: ${error.message}`);
     }
@@ -437,7 +475,7 @@ export class SparcCoordinator {
       passed: true,
       score: 0,
       issues: [],
-      recommendations: []
+      recommendations: [],
     };
 
     try {
@@ -445,14 +483,13 @@ export class SparcCoordinator {
       const swarmValidation = await this.executeSwarmHook('validate_phase', {
         phase: phaseName,
         result: result,
-        criteria: this.getValidationCriteria(phaseName)
+        criteria: this.getValidationCriteria(phaseName),
       });
 
       validation.passed = swarmValidation.passed;
       validation.score = swarmValidation.score;
       validation.issues = swarmValidation.issues || [];
       validation.recommendations = swarmValidation.recommendations || [];
-
     } catch (error) {
       console.warn(`⚠️ Swarm validation failed: ${error.message}`);
       // Fallback to basic validation
@@ -468,26 +505,26 @@ export class SparcCoordinator {
    */
   getValidationCriteria(phaseName) {
     const criteria = {
-      'specification': {
+      specification: {
         requiredFields: ['requirements', 'acceptanceCriteria', 'userStories'],
-        qualityThresholds: { completeness: 0.9, clarity: 0.8 }
+        qualityThresholds: { completeness: 0.9, clarity: 0.8 },
       },
-      'pseudocode': {
+      pseudocode: {
         requiredFields: ['flowDiagram', 'pseudocode', 'algorithms'],
-        qualityThresholds: { completeness: 0.85, complexity: 0.7 }
+        qualityThresholds: { completeness: 0.85, complexity: 0.7 },
       },
-      'architecture': {
+      architecture: {
         requiredFields: ['systemDesign', 'components', 'designPatterns'],
-        qualityThresholds: { modularity: 0.8, scalability: 0.75 }
+        qualityThresholds: { modularity: 0.8, scalability: 0.75 },
       },
-      'refinement': {
+      refinement: {
         requiredFields: ['testResults', 'codeQuality', 'implementations'],
-        qualityThresholds: { testCoverage: 0.8, codeQuality: 0.75 }
+        qualityThresholds: { testCoverage: 0.8, codeQuality: 0.75 },
       },
-      'completion': {
+      completion: {
         requiredFields: ['validation', 'deployment', 'documentation'],
-        qualityThresholds: { completeness: 0.9, readiness: 0.85 }
-      }
+        qualityThresholds: { completeness: 0.9, readiness: 0.85 },
+      },
     };
 
     return criteria[phaseName] || { requiredFields: [], qualityThresholds: {} };
@@ -498,20 +535,20 @@ export class SparcCoordinator {
    */
   async updateAgentPerformance(phaseName, result, validation) {
     const phaseAgents = this.phaseAgents.get(phaseName) || [];
-    
+
     for (const agent of phaseAgents) {
       agent.performance.tasksCompleted += 1;
-      
+
       // Update quality score based on validation
       const qualityScore = validation.score / 100;
       agent.performance.qualityScore = (agent.performance.qualityScore + qualityScore) / 2;
-      
+
       // Update efficiency based on execution time
       const executionTime = Date.now() - this.getPhaseStartTime(phaseName);
       const expectedTime = this.getExpectedPhaseTime(phaseName);
       const efficiency = Math.min(1, expectedTime / executionTime);
       agent.performance.efficiency = (agent.performance.efficiency + efficiency) / 2;
-      
+
       // Update average time
       agent.performance.averageTime = (agent.performance.averageTime + executionTime) / 2;
 
@@ -519,7 +556,7 @@ export class SparcCoordinator {
       await this.executeSwarmHook('update_agent_performance', {
         agentId: agent.id,
         performance: agent.performance,
-        phase: phaseName
+        phase: phaseName,
       });
     }
   }
@@ -529,7 +566,7 @@ export class SparcCoordinator {
    */
   getPhaseStartTime(phaseName) {
     // This would typically be stored in memory or agent state
-    return Date.now() - (5 * 60 * 1000); // Default to 5 minutes ago
+    return Date.now() - 5 * 60 * 1000; // Default to 5 minutes ago
   }
 
   /**
@@ -537,13 +574,13 @@ export class SparcCoordinator {
    */
   getExpectedPhaseTime(phaseName) {
     const expectedTimes = {
-      'specification': 10 * 60 * 1000,  // 10 minutes
-      'pseudocode': 5 * 60 * 1000,      // 5 minutes
-      'architecture': 15 * 60 * 1000,   // 15 minutes
-      'refinement': 20 * 60 * 1000,     // 20 minutes
-      'completion': 10 * 60 * 1000      // 10 minutes
+      specification: 10 * 60 * 1000, // 10 minutes
+      pseudocode: 5 * 60 * 1000, // 5 minutes
+      architecture: 15 * 60 * 1000, // 15 minutes
+      refinement: 20 * 60 * 1000, // 20 minutes
+      completion: 10 * 60 * 1000, // 10 minutes
     };
-    
+
     return expectedTimes[phaseName] || 10 * 60 * 1000;
   }
 
@@ -559,28 +596,28 @@ export class SparcCoordinator {
         execution: {
           result: result,
           validation: validation,
-          timestamp: Date.now()
+          timestamp: Date.now(),
         },
         context: {
           taskDescription: this.options.taskDescription,
           neuralContext: this.neuralContext,
-          agentPerformance: this.getAgentPerformanceData(phaseName)
+          agentPerformance: this.getAgentPerformanceData(phaseName),
         },
         outcomes: {
           success: validation.passed,
           quality: validation.score,
           efficiency: this.calculatePhaseEfficiency(phaseName),
-          learnings: this.extractLearnings(phaseName, result, validation)
-        }
+          learnings: this.extractLearnings(phaseName, result, validation),
+        },
       };
 
       await this.executeSwarmHook('neural_record_learning', learningData);
-      
+
       // Train neural patterns based on this execution
       await this.executeSwarmHook('neural_train', {
         data: learningData,
         updateWeights: true,
-        savePattern: true
+        savePattern: true,
       });
 
       console.log(`🧠 Neural learning recorded for ${phaseName}`);
@@ -594,10 +631,10 @@ export class SparcCoordinator {
    */
   getAgentPerformanceData(phaseName) {
     const phaseAgents = this.phaseAgents.get(phaseName) || [];
-    return phaseAgents.map(agent => ({
+    return phaseAgents.map((agent) => ({
       id: agent.id,
       type: agent.type,
-      performance: agent.performance
+      performance: agent.performance,
     }));
   }
 
@@ -607,8 +644,10 @@ export class SparcCoordinator {
   calculatePhaseEfficiency(phaseName) {
     const phaseAgents = this.phaseAgents.get(phaseName) || [];
     if (phaseAgents.length === 0) return 0.5;
-    
-    const avgEfficiency = phaseAgents.reduce((sum, agent) => sum + agent.performance.efficiency, 0) / phaseAgents.length;
+
+    const avgEfficiency =
+      phaseAgents.reduce((sum, agent) => sum + agent.performance.efficiency, 0) /
+      phaseAgents.length;
     return avgEfficiency;
   }
 
@@ -617,7 +656,7 @@ export class SparcCoordinator {
    */
   extractLearnings(phaseName, result, validation) {
     const learnings = [];
-    
+
     if (validation.passed) {
       learnings.push(`${phaseName} phase executed successfully`);
       if (validation.score > 90) {
@@ -626,11 +665,11 @@ export class SparcCoordinator {
     } else {
       learnings.push(`${phaseName} phase encountered issues: ${validation.issues.join(', ')}`);
     }
-    
+
     if (validation.recommendations.length > 0) {
       learnings.push(`Recommendations for ${phaseName}: ${validation.recommendations.join(', ')}`);
     }
-    
+
     return learnings;
   }
 
@@ -648,8 +687,8 @@ export class SparcCoordinator {
       artifacts: {
         outputs: result,
         decisions: this.extractDecisions(result),
-        context: this.neuralContext
-      }
+        context: this.neuralContext,
+      },
     });
 
     // Pre-warm next phase agents
@@ -658,7 +697,7 @@ export class SparcCoordinator {
       await this.executeSwarmHook('agent_prewarm', {
         agentId: agent.id,
         phase: nextPhase,
-        context: result
+        context: result,
       });
     }
   }
@@ -669,7 +708,9 @@ export class SparcCoordinator {
   getNextPhase(currentPhase) {
     const sequence = ['specification', 'pseudocode', 'architecture', 'refinement', 'completion'];
     const currentIndex = sequence.indexOf(currentPhase);
-    return currentIndex >= 0 && currentIndex < sequence.length - 1 ? sequence[currentIndex + 1] : null;
+    return currentIndex >= 0 && currentIndex < sequence.length - 1
+      ? sequence[currentIndex + 1]
+      : null;
   }
 
   /**
@@ -677,23 +718,25 @@ export class SparcCoordinator {
    */
   extractDecisions(result) {
     const decisions = [];
-    
+
     if (result.architecturalDecisions) {
       decisions.push(...result.architecturalDecisions);
     }
-    
+
     if (result.designDecisions) {
       decisions.push(...result.designDecisions);
     }
-    
+
     if (result.qualityGates) {
-      decisions.push(...result.qualityGates.map(gate => ({
-        decision: `Quality gate: ${gate.name}`,
-        rationale: gate.rationale || 'Quality assurance',
-        impact: gate.impact || 'process'
-      })));
+      decisions.push(
+        ...result.qualityGates.map((gate) => ({
+          decision: `Quality gate: ${gate.name}`,
+          rationale: gate.rationale || 'Quality assurance',
+          impact: gate.impact || 'process',
+        })),
+      );
     }
-    
+
     return decisions;
   }
 
@@ -702,7 +745,7 @@ export class SparcCoordinator {
    */
   updateCoordinationMetrics(phaseName, result, validation) {
     this.metrics.phaseExecutions += 1;
-    
+
     // Update agent utilization
     const phaseAgents = this.phaseAgents.get(phaseName) || [];
     for (const agent of phaseAgents) {
@@ -712,26 +755,26 @@ export class SparcCoordinator {
       this.metrics.agentUtilization[agent.id].phases += 1;
       this.metrics.agentUtilization[agent.id].quality += validation.score;
     }
-    
+
     // Update coordination efficiency
     const efficiency = this.calculatePhaseEfficiency(phaseName);
     this.metrics.coordinationEfficiency = (this.metrics.coordinationEfficiency + efficiency) / 2;
-    
+
     // Record quality gate
     this.metrics.qualityGates.push({
       phase: phaseName,
       passed: validation.passed,
       score: validation.score,
-      timestamp: Date.now()
+      timestamp: Date.now(),
     });
-    
+
     // Record learning data
     if (validation.passed) {
       this.metrics.learningData.push({
         phase: phaseName,
         success: true,
         quality: validation.score,
-        patterns: this.neuralContext?.patterns || []
+        patterns: this.neuralContext?.patterns || [],
       });
     }
   }
@@ -754,22 +797,22 @@ export class SparcCoordinator {
         value: {
           metrics: this.metrics,
           report: report,
-          timestamp: Date.now()
-        }
+          timestamp: Date.now(),
+        },
       });
 
       // Shutdown agents
       for (const agent of this.agents) {
         await this.executeSwarmHook('agent_shutdown', {
           agentId: agent.id,
-          graceful: true
+          graceful: true,
         });
       }
 
       // Shutdown swarm
       await this.executeSwarmHook('swarm_shutdown', {
         swarmId: this.swarmId,
-        preserveData: true
+        preserveData: true,
       });
 
       console.log('✅ SPARC coordination finalized');
@@ -787,13 +830,13 @@ export class SparcCoordinator {
         phasesExecuted: this.metrics.phaseExecutions,
         agentsUtilized: Object.keys(this.metrics.agentUtilization).length,
         coordinationEfficiency: this.metrics.coordinationEfficiency,
-        qualityGatesPassed: this.metrics.qualityGates.filter(g => g.passed).length,
-        totalQualityGates: this.metrics.qualityGates.length
+        qualityGatesPassed: this.metrics.qualityGates.filter((g) => g.passed).length,
+        totalQualityGates: this.metrics.qualityGates.length,
       },
       agentPerformance: this.calculateAgentPerformanceSummary(),
       phaseAnalysis: this.analyzePhasePerformance(),
       recommendations: this.generateRecommendations(),
-      neuralInsights: this.extractNeuralInsights()
+      neuralInsights: this.extractNeuralInsights(),
     };
 
     return report;
@@ -804,7 +847,7 @@ export class SparcCoordinator {
    */
   calculateAgentPerformanceSummary() {
     const summary = {};
-    
+
     for (const agent of this.agents) {
       summary[agent.id] = {
         type: agent.type,
@@ -812,10 +855,10 @@ export class SparcCoordinator {
         tasksCompleted: agent.performance.tasksCompleted,
         averageQuality: agent.performance.qualityScore,
         efficiency: agent.performance.efficiency,
-        averageTime: agent.performance.averageTime
+        averageTime: agent.performance.averageTime,
       };
     }
-    
+
     return summary;
   }
 
@@ -824,28 +867,28 @@ export class SparcCoordinator {
    */
   analyzePhasePerformance() {
     const analysis = {};
-    
+
     for (const gate of this.metrics.qualityGates) {
       if (!analysis[gate.phase]) {
         analysis[gate.phase] = {
           executions: 0,
           passed: 0,
           averageScore: 0,
-          totalScore: 0
+          totalScore: 0,
         };
       }
-      
+
       analysis[gate.phase].executions += 1;
       if (gate.passed) analysis[gate.phase].passed += 1;
       analysis[gate.phase].totalScore += gate.score;
     }
-    
+
     // Calculate averages
     for (const phase of Object.keys(analysis)) {
       analysis[phase].averageScore = analysis[phase].totalScore / analysis[phase].executions;
       analysis[phase].successRate = analysis[phase].passed / analysis[phase].executions;
     }
-    
+
     return analysis;
   }
 
@@ -854,28 +897,30 @@ export class SparcCoordinator {
    */
   generateRecommendations() {
     const recommendations = [];
-    
+
     // Analyze agent utilization
-    const avgUtilization = Object.values(this.metrics.agentUtilization).reduce((sum, agent) => 
-      sum + agent.phases, 0) / Object.keys(this.metrics.agentUtilization).length;
-    
+    const avgUtilization =
+      Object.values(this.metrics.agentUtilization).reduce((sum, agent) => sum + agent.phases, 0) /
+      Object.keys(this.metrics.agentUtilization).length;
+
     if (avgUtilization < 2) {
       recommendations.push('Consider reducing agent count for better utilization');
     } else if (avgUtilization > 4) {
       recommendations.push('Consider increasing agent count to distribute load');
     }
-    
+
     // Analyze coordination efficiency
     if (this.metrics.coordinationEfficiency < 0.7) {
       recommendations.push('Improve coordination efficiency through better task decomposition');
     }
-    
+
     // Analyze quality gates
-    const qualityGateSuccess = this.metrics.qualityGates.filter(g => g.passed).length / this.metrics.qualityGates.length;
+    const qualityGateSuccess =
+      this.metrics.qualityGates.filter((g) => g.passed).length / this.metrics.qualityGates.length;
     if (qualityGateSuccess < 0.8) {
       recommendations.push('Review quality gate criteria and provide additional agent training');
     }
-    
+
     return recommendations;
   }
 
@@ -884,21 +929,23 @@ export class SparcCoordinator {
    */
   extractNeuralInsights() {
     const insights = [];
-    
+
     // Pattern analysis
-    const successfulPatterns = this.metrics.learningData.filter(d => d.success);
+    const successfulPatterns = this.metrics.learningData.filter((d) => d.success);
     if (successfulPatterns.length > 0) {
       insights.push(`${successfulPatterns.length} successful execution patterns identified`);
     }
-    
+
     // Quality analysis
-    const avgQuality = this.metrics.learningData.reduce((sum, d) => sum + d.quality, 0) / this.metrics.learningData.length;
+    const avgQuality =
+      this.metrics.learningData.reduce((sum, d) => sum + d.quality, 0) /
+      this.metrics.learningData.length;
     if (avgQuality > 85) {
       insights.push('High quality outcomes consistently achieved');
     } else if (avgQuality < 70) {
       insights.push('Quality improvements needed in execution');
     }
-    
+
     return insights;
   }
 
@@ -912,30 +959,30 @@ export class SparcCoordinator {
 
     try {
       const { spawn } = await import('child_process');
-      
+
       return new Promise((resolve, reject) => {
         const args = ['ruv-swarm', 'hook', hookName];
-        
+
         // Add data as JSON argument
         if (Object.keys(data).length > 0) {
           args.push('--data', JSON.stringify(data));
         }
 
         const process = spawn('npx', args, {
-          stdio: 'pipe'
+          stdio: 'pipe',
         });
-        
+
         let output = '';
         let error = '';
-        
+
         process.stdout.on('data', (data) => {
           output += data.toString();
         });
-        
+
         process.stderr.on('data', (data) => {
           error += data.toString();
         });
-        
+
         process.on('close', (code) => {
           if (code === 0) {
             try {
@@ -968,7 +1015,7 @@ export class SparcCoordinator {
       await this.executeSwarmHook('neural_record_learning', {
         methodology: 'sparc',
         data: learningData,
-        timestamp: Date.now()
+        timestamp: Date.now(),
       });
     } catch (error) {
       console.warn(`⚠️ Failed to record learning: ${error.message}`);
@@ -985,13 +1032,14 @@ export class SparcCoordinator {
       agentCount: this.agents.length,
       phaseAgents: Object.fromEntries(
         Array.from(this.phaseAgents.entries()).map(([phase, agents]) => [
-          phase, agents.map(a => ({ id: a.id, type: a.type, status: a.status }))
-        ])
+          phase,
+          agents.map((a) => ({ id: a.id, type: a.type, status: a.status })),
+        ]),
       ),
       metrics: this.metrics,
-      coordination: this.coordination
+      coordination: this.coordination,
     };
   }
 }
 
-export default SparcCoordinator;
+export default SparcCoordinator;