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

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

@@ -16,17 +16,17 @@ export class SparcMethodology {
       swarmEnabled: options.swarmEnabled || false,
       neuralLearning: options.neuralLearning || false,
       verbose: options.verbose || false,
-      ...options
+      ...options,
     };
-    
+
     this.phases = {
       specification: new SparcSpecification(this.taskDescription, this.options),
       pseudocode: new SparcPseudocode(this.taskDescription, this.options),
       architecture: new SparcArchitecture(this.taskDescription, this.options),
       refinement: new SparcRefinement(this.taskDescription, this.options),
-      completion: new SparcCompletion(this.taskDescription, this.options)
+      completion: new SparcCompletion(this.taskDescription, this.options),
     };
-    
+
     this.coordinator = new SparcCoordinator(this.phases, this.options);
     this.currentPhase = 'specification';
     this.phaseOrder = ['specification', 'pseudocode', 'architecture', 'refinement', 'completion'];
@@ -52,26 +52,26 @@ export class SparcMethodology {
     // Execute each phase in order
     for (const phaseName of this.phaseOrder) {
       console.log(`\n📍 Phase: ${phaseName.toUpperCase()}`);
-      
+
       try {
         // Pre-phase coordination
         await this.coordinator.prePhase(phaseName);
-        
+
         // Execute phase
         const phase = this.phases[phaseName];
         const result = await phase.execute();
-        
+
         // Store artifacts
         this.artifacts[phaseName] = result;
-        
+
         // Quality gate validation
         const qualityGate = await this.validateQualityGate(phaseName, result);
         this.qualityGates[phaseName] = qualityGate;
-        
+
         if (!qualityGate.passed) {
           console.log(`❌ Quality Gate Failed for ${phaseName}`);
           console.log(`Reasons: ${qualityGate.reasons.join(', ')}`);
-          
+
           // Attempt auto-remediation
           if (this.options.autoRemediation) {
             await this.autoRemediate(phaseName, qualityGate);
@@ -79,27 +79,26 @@ export class SparcMethodology {
             throw new Error(`Quality gate failed for phase: ${phaseName}`);
           }
         }
-        
+
         // Post-phase coordination
         await this.coordinator.postPhase(phaseName, result);
-        
+
         console.log(`✅ ${phaseName} completed successfully`);
-        
       } catch (error) {
         console.error(`❌ Error in ${phaseName}: ${error.message}`);
-        
+
         // Neural learning from failures
         if (this.options.neuralLearning) {
           await this.learnFromFailure(phaseName, error);
         }
-        
+
         throw error;
       }
     }
 
     // Final coordination and cleanup
     await this.coordinator.finalize();
-    
+
     console.log('\n🎉 SPARC Methodology Execution Complete');
     return this.generateSummary();
   }
@@ -113,10 +112,10 @@ export class SparcMethodology {
     }
 
     console.log(`📍 Executing Phase: ${phaseName.toUpperCase()}`);
-    
+
     const phase = this.phases[phaseName];
     const result = await phase.execute();
-    
+
     this.artifacts[phaseName] = result;
     return result;
   }
@@ -127,7 +126,7 @@ export class SparcMethodology {
   async validateQualityGate(phaseName, result) {
     const qualityGate = {
       passed: true,
-      reasons: []
+      reasons: [],
     };
 
     switch (phaseName) {
@@ -195,27 +194,32 @@ export class SparcMethodology {
    */
   async autoRemediate(phaseName, qualityGate) {
     console.log(`🔄 Attempting auto-remediation for ${phaseName}`);
-    
+
     // Neural learning can inform remediation strategies
     if (this.options.neuralLearning) {
-      await this.learnFromFailure(phaseName, new Error(`Quality gate failed: ${qualityGate.reasons.join(', ')}`));
+      await this.learnFromFailure(
+        phaseName,
+        new Error(`Quality gate failed: ${qualityGate.reasons.join(', ')}`),
+      );
     }
 
     // Re-execute the phase with enhanced context
     const phase = this.phases[phaseName];
     phase.setRemediationContext(qualityGate);
-    
+
     const result = await phase.execute();
     this.artifacts[phaseName] = result;
-    
+
     // Re-validate
     const newQualityGate = await this.validateQualityGate(phaseName, result);
     this.qualityGates[phaseName] = newQualityGate;
-    
+
     if (!newQualityGate.passed) {
-      throw new Error(`Auto-remediation failed for ${phaseName}: ${newQualityGate.reasons.join(', ')}`);
+      throw new Error(
+        `Auto-remediation failed for ${phaseName}: ${newQualityGate.reasons.join(', ')}`,
+      );
     }
-    
+
     console.log(`✅ Auto-remediation successful for ${phaseName}`);
   }
 
@@ -228,7 +232,7 @@ export class SparcMethodology {
       task: this.taskDescription,
       error: error.message,
       timestamp: new Date().toISOString(),
-      context: this.artifacts
+      context: this.artifacts,
     };
 
     // Store learning data for neural network training
@@ -244,14 +248,14 @@ export class SparcMethodology {
     const summary = {
       taskDescription: this.taskDescription,
       executionTime: Date.now() - this.startTime,
-      phases: this.phaseOrder.map(phase => ({
+      phases: this.phaseOrder.map((phase) => ({
         name: phase,
         status: this.qualityGates[phase]?.passed ? 'passed' : 'failed',
-        artifacts: this.artifacts[phase]
+        artifacts: this.artifacts[phase],
       })),
       qualityGates: this.qualityGates,
       artifacts: this.artifacts,
-      recommendations: this.generateRecommendations()
+      recommendations: this.generateRecommendations(),
     };
 
     return summary;
@@ -269,7 +273,7 @@ export class SparcMethodology {
         recommendations.push({
           type: 'quality_improvement',
           phase: phase,
-          message: `Improve ${phase} quality: ${gate.reasons.join(', ')}`
+          message: `Improve ${phase} quality: ${gate.reasons.join(', ')}`,
         });
       }
     }
@@ -278,7 +282,7 @@ export class SparcMethodology {
     if (this.artifacts.architecture && this.artifacts.architecture.components.length > 10) {
       recommendations.push({
         type: 'architecture_optimization',
-        message: 'Consider breaking down architecture into smaller, more manageable components'
+        message: 'Consider breaking down architecture into smaller, more manageable components',
       });
     }
 
@@ -293,7 +297,7 @@ export class SparcMethodology {
       name: phaseName,
       completed: !!this.artifacts[phaseName],
       qualityGate: this.qualityGates[phaseName],
-      artifacts: this.artifacts[phaseName]
+      artifacts: this.artifacts[phaseName],
     };
   }
 
@@ -303,15 +307,15 @@ export class SparcMethodology {
   getProgress() {
     const completedPhases = Object.keys(this.artifacts).length;
     const totalPhases = this.phaseOrder.length;
-    
+
     return {
       completed: completedPhases,
       total: totalPhases,
       percentage: (completedPhases / totalPhases) * 100,
       currentPhase: this.currentPhase,
-      phases: this.phaseOrder.map(phase => this.getPhaseStatus(phase))
+      phases: this.phaseOrder.map((phase) => this.getPhaseStatus(phase)),
     };
   }
 }
 
-export default SparcMethodology;
+export default SparcMethodology;

package/src/cli/simple-commands/sparc/phase-base.js

@@ -20,16 +20,16 @@ export class SparcPhase {
   async initializePhase() {
     this.startTime = Date.now();
     console.log(`🚀 Initializing ${this.phaseName} phase`);
-    
+
     // Load previous context from memory
     if (this.options.swarmEnabled) {
       await this.loadSwarmContext();
     }
-    
+
     // Store phase start in memory
     await this.storeInMemory(`${this.phaseName}_started`, {
       timestamp: this.startTime,
-      taskDescription: this.taskDescription
+      taskDescription: this.taskDescription,
     });
   }
 
@@ -39,16 +39,16 @@ export class SparcPhase {
   async finalizePhase() {
     this.endTime = Date.now();
     const duration = this.endTime - this.startTime;
-    
+
     console.log(`✅ ${this.phaseName} phase completed in ${duration}ms`);
-    
+
     // Store phase completion in memory
     await this.storeInMemory(`${this.phaseName}_completed`, {
       timestamp: this.endTime,
       duration: duration,
-      artifacts: this.artifacts
+      artifacts: this.artifacts,
     });
-    
+
     // Update swarm context if enabled
     if (this.options.swarmEnabled) {
       await this.updateSwarmContext();
@@ -62,15 +62,15 @@ export class SparcPhase {
     try {
       const memoryKey = `${this.options.namespace}_${key}`;
       const memoryData = JSON.stringify(data);
-      
+
       // Store in local memory
       this.memory[key] = data;
-      
+
       // Store in swarm memory if enabled
       if (this.options.swarmEnabled) {
         await this.storeInSwarmMemory(memoryKey, memoryData);
       }
-      
+
       console.log(`💾 Stored in memory: ${memoryKey}`);
     } catch (error) {
       console.warn(`⚠️ Failed to store in memory: ${error.message}`);
@@ -83,17 +83,17 @@ export class SparcPhase {
   async retrieveFromMemory(key) {
     try {
       const memoryKey = `${this.options.namespace}_${key}`;
-      
+
       // Try local memory first
       if (this.memory[key]) {
         return this.memory[key];
       }
-      
+
       // Try swarm memory if enabled
       if (this.options.swarmEnabled) {
         return await this.retrieveFromSwarmMemory(memoryKey);
       }
-      
+
       return null;
     } catch (error) {
       console.warn(`⚠️ Failed to retrieve from memory: ${error.message}`);
@@ -106,21 +106,25 @@ export class SparcPhase {
    */
   async storeInSwarmMemory(key, data) {
     if (!this.options.swarmEnabled) return;
-    
+
     try {
       // Use ruv-swarm memory hooks
       const { spawn } = await import('child_process');
-      
+
       return new Promise((resolve, reject) => {
-        const process = spawn('npx', ['ruv-swarm', 'hook', 'memory-store', '--key', key, '--data', data], {
-          stdio: 'pipe'
-        });
-        
+        const process = spawn(
+          'npx',
+          ['ruv-swarm', 'hook', 'memory-store', '--key', key, '--data', data],
+          {
+            stdio: 'pipe',
+          },
+        );
+
         let output = '';
         process.stdout.on('data', (data) => {
           output += data.toString();
         });
-        
+
         process.on('close', (code) => {
           if (code === 0) {
             resolve(output);
@@ -139,20 +143,20 @@ export class SparcPhase {
    */
   async retrieveFromSwarmMemory(key) {
     if (!this.options.swarmEnabled) return null;
-    
+
     try {
       const { spawn } = await import('child_process');
-      
+
       return new Promise((resolve, reject) => {
         const process = spawn('npx', ['ruv-swarm', 'hook', 'memory-retrieve', '--key', key], {
-          stdio: 'pipe'
+          stdio: 'pipe',
         });
-        
+
         let output = '';
         process.stdout.on('data', (data) => {
           output += data.toString();
         });
-        
+
         process.on('close', (code) => {
           if (code === 0) {
             try {
@@ -177,7 +181,9 @@ export class SparcPhase {
    */
   async loadSwarmContext() {
     try {
-      this.swarmContext = await this.retrieveFromSwarmMemory(`${this.options.namespace}_swarm_context`);
+      this.swarmContext = await this.retrieveFromSwarmMemory(
+        `${this.options.namespace}_swarm_context`,
+      );
       if (this.swarmContext) {
         console.log(`🐝 Loaded swarm context for ${this.phaseName}`);
       }
@@ -196,10 +202,13 @@ export class SparcPhase {
         timestamp: Date.now(),
         artifacts: this.artifacts,
         memory: this.memory,
-        status: 'completed'
+        status: 'completed',
       };
-      
-      await this.storeInSwarmMemory(`${this.options.namespace}_swarm_context`, JSON.stringify(contextUpdate));
+
+      await this.storeInSwarmMemory(
+        `${this.options.namespace}_swarm_context`,
+        JSON.stringify(contextUpdate),
+      );
       console.log(`🐝 Updated swarm context for ${this.phaseName}`);
     } catch (error) {
       console.warn(`⚠️ Failed to update swarm context: ${error.message}`);
@@ -213,19 +222,19 @@ export class SparcPhase {
     try {
       const fs = await import('fs/promises');
       const path = await import('path');
-      
+
       const artifactDir = path.join(process.cwd(), 'sparc-artifacts', this.options.namespace);
       await fs.mkdir(artifactDir, { recursive: true });
-      
+
       const filePath = path.join(artifactDir, filename);
       await fs.writeFile(filePath, content, 'utf8');
-      
+
       this.artifacts.push({
         filename,
         path: filePath,
-        timestamp: Date.now()
+        timestamp: Date.now(),
       });
-      
+
       console.log(`📄 Saved artifact: ${filename}`);
       return filePath;
     } catch (error) {
@@ -241,10 +250,10 @@ export class SparcPhase {
     try {
       const fs = await import('fs/promises');
       const path = await import('path');
-      
+
       const artifactDir = path.join(process.cwd(), 'sparc-artifacts', this.options.namespace);
       const filePath = path.join(artifactDir, filename);
-      
+
       const content = await fs.readFile(filePath, 'utf8');
       return content;
     } catch (error) {
@@ -258,7 +267,9 @@ export class SparcPhase {
    */
   setRemediationContext(qualityGate) {
     this.remediationContext = qualityGate;
-    console.log(`🔧 Set remediation context for ${this.phaseName}: ${qualityGate.reasons.join(', ')}`);
+    console.log(
+      `🔧 Set remediation context for ${this.phaseName}: ${qualityGate.reasons.join(', ')}`,
+    );
   }
 
   /**
@@ -271,7 +282,7 @@ export class SparcPhase {
       artifactsCount: this.artifacts.length,
       memoryKeys: Object.keys(this.memory).length,
       hasSwarmContext: !!this.swarmContext,
-      hasRemediationContext: !!this.remediationContext
+      hasRemediationContext: !!this.remediationContext,
     };
   }
 
@@ -301,7 +312,7 @@ export class SparcPhase {
       duration: this.endTime ? this.endTime - this.startTime : null,
       artifacts: this.artifacts.length,
       hasContext: !!this.swarmContext,
-      hasRemediation: !!this.remediationContext
+      hasRemediation: !!this.remediationContext,
     };
   }
 
@@ -310,7 +321,7 @@ export class SparcPhase {
    */
   async recordLearning(learningData) {
     if (!this.options.neuralLearning) return;
-    
+
     try {
       const learningRecord = {
         phase: this.phaseName,
@@ -319,17 +330,20 @@ export class SparcPhase {
         context: {
           task: this.taskDescription,
           options: this.options,
-          metrics: this.getMetrics()
-        }
+          metrics: this.getMetrics(),
+        },
       };
-      
+
       await this.storeInMemory(`learning_${Date.now()}`, learningRecord);
-      
+
       // Store in neural learning system if available
       if (this.options.swarmEnabled) {
-        await this.storeInSwarmMemory(`neural_learning_${this.phaseName}`, JSON.stringify(learningRecord));
+        await this.storeInSwarmMemory(
+          `neural_learning_${this.phaseName}`,
+          JSON.stringify(learningRecord),
+        );
       }
-      
+
       console.log(`🧠 Recorded learning for ${this.phaseName}`);
     } catch (error) {
       console.warn(`⚠️ Failed to record learning: ${error.message}`);
@@ -341,24 +355,24 @@ export class SparcPhase {
    */
   async getLearningInsights() {
     if (!this.options.neuralLearning) return [];
-    
+
     try {
       const insights = [];
-      
+
       // Analyze previous executions
-      const learningKeys = Object.keys(this.memory).filter(key => key.startsWith('learning_'));
-      
+      const learningKeys = Object.keys(this.memory).filter((key) => key.startsWith('learning_'));
+
       for (const key of learningKeys) {
         const record = this.memory[key];
         if (record && record.phase === this.phaseName) {
           insights.push({
             timestamp: record.timestamp,
             insight: this.generateInsight(record),
-            confidence: this.calculateConfidence(record)
+            confidence: this.calculateConfidence(record),
           });
         }
       }
-      
+
       return insights;
     } catch (error) {
       console.warn(`⚠️ Failed to get learning insights: ${error.message}`);
@@ -383,7 +397,7 @@ export class SparcPhase {
     const age = Date.now() - record.timestamp;
     const recencyScore = Math.max(0, 1 - age / (24 * 60 * 60 * 1000)); // Decay over 24 hours
     const successScore = record.data.success ? 1 : 0.5;
-    
+
     return (recencyScore + successScore) / 2;
   }
 
@@ -392,7 +406,7 @@ export class SparcPhase {
    */
   identifyPatterns(record) {
     const patterns = [];
-    
+
     if (record.data.duration) {
       if (record.data.duration > 60000) {
         patterns.push('Long execution time');
@@ -400,17 +414,17 @@ export class SparcPhase {
         patterns.push('Fast execution');
       }
     }
-    
+
     if (record.data.errors && record.data.errors.length > 0) {
       patterns.push('Error prone');
     }
-    
+
     if (record.data.qualityGate && !record.data.qualityGate.passed) {
       patterns.push('Quality gate failures');
     }
-    
+
     return patterns;
   }
 }
 
-export default SparcPhase;
+export default SparcPhase;