claude-flow-novice 2.0.3 → 2.0.4

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

@@ -1,430 +1,354 @@
 // Base class for SPARC phases
 // Provides common functionality for all phases
-
 export class SparcPhase {
-  constructor(phaseName, taskDescription, options = {}) {
-    this.phaseName = phaseName;
-    this.taskDescription = taskDescription;
-    this.options = options;
-    this.startTime = null;
-    this.endTime = null;
-    this.artifacts = [];
-    this.memory = {};
-    this.swarmContext = null;
-    this.remediationContext = null;
-  }
-
-  /**
+    /**
    * Initialize phase execution
-   */
-  async initializePhase() {
-    this.startTime = Date.now();
-    console.log(`🚀 Initializing ${this.phaseName} phase`);
-
-    // Load previous context from memory
-    if (this.options.swarmEnabled) {
-      await this.loadSwarmContext();
+   */ 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
+        });
     }
-
-    // Store phase start in memory
-    await this.storeInMemory(`${this.phaseName}_started`, {
-      timestamp: this.startTime,
-      taskDescription: this.taskDescription,
-    });
-  }
-
-  /**
+    /**
    * Finalize phase execution
-   */
-  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,
-    });
-
-    // Update swarm context if enabled
-    if (this.options.swarmEnabled) {
-      await this.updateSwarmContext();
+   */ 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
+        });
+        // Update swarm context if enabled
+        if (this.options.swarmEnabled) {
+            await this.updateSwarmContext();
+        }
     }
-  }
-
-  /**
+    /**
    * Store data in memory system
-   */
-  async storeInMemory(key, data) {
-    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}`);
+   */ async storeInMemory(key, data) {
+        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}`);
+        }
     }
-  }
-
-  /**
+    /**
    * Retrieve data from memory system
-   */
-  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}`);
-      return null;
+   */ 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}`);
+            return null;
+        }
     }
-  }
-
-  /**
+    /**
    * Store data in swarm memory
-   */
-  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',
-          },
-        );
-
-        let output = '';
-        process.stdout.on('data', (data) => {
-          output += data.toString();
-        });
-
-        process.on('close', (code) => {
-          if (code === 0) {
-            resolve(output);
-          } else {
-            reject(new Error(`Memory store failed with code ${code}`));
-          }
-        });
-      });
-    } catch (error) {
-      console.warn(`⚠️ Failed to store in swarm memory: ${error.message}`);
+   */ 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 process1 = spawn('npx', [
+                    'ruv-swarm',
+                    'hook',
+                    'memory-store',
+                    '--key',
+                    key,
+                    '--data',
+                    data
+                ], {
+                    stdio: 'pipe'
+                });
+                let output = '';
+                process1.stdout.on('data', (data)=>{
+                    output += data.toString();
+                });
+                process1.on('close', (code)=>{
+                    if (code === 0) {
+                        resolve(output);
+                    } else {
+                        reject(new Error(`Memory store failed with code ${code}`));
+                    }
+                });
+            });
+        } catch (error) {
+            console.warn(`⚠️ Failed to store in swarm memory: ${error.message}`);
+        }
     }
-  }
-
-  /**
+    /**
    * Retrieve data from swarm memory
-   */
-  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',
-        });
-
-        let output = '';
-        process.stdout.on('data', (data) => {
-          output += data.toString();
-        });
-
-        process.on('close', (code) => {
-          if (code === 0) {
-            try {
-              const data = JSON.parse(output);
-              resolve(data);
-            } catch (parseError) {
-              resolve(null);
-            }
-          } else {
-            resolve(null);
-          }
-        });
-      });
-    } catch (error) {
-      console.warn(`⚠️ Failed to retrieve from swarm memory: ${error.message}`);
-      return null;
+   */ async retrieveFromSwarmMemory(key) {
+        if (!this.options.swarmEnabled) return null;
+        try {
+            const { spawn } = await import("child_process");
+            return new Promise((resolve, reject)=>{
+                const process1 = spawn('npx', [
+                    'ruv-swarm',
+                    'hook',
+                    'memory-retrieve',
+                    '--key',
+                    key
+                ], {
+                    stdio: 'pipe'
+                });
+                let output = '';
+                process1.stdout.on('data', (data)=>{
+                    output += data.toString();
+                });
+                process1.on('close', (code)=>{
+                    if (code === 0) {
+                        try {
+                            const data = JSON.parse(output);
+                            resolve(data);
+                        } catch (parseError) {
+                            resolve(null);
+                        }
+                    } else {
+                        resolve(null);
+                    }
+                });
+            });
+        } catch (error) {
+            console.warn(`⚠️ Failed to retrieve from swarm memory: ${error.message}`);
+            return null;
+        }
     }
-  }
-
-  /**
+    /**
    * Load swarm context
-   */
-  async loadSwarmContext() {
-    try {
-      this.swarmContext = await this.retrieveFromSwarmMemory(
-        `${this.options.namespace}_swarm_context`,
-      );
-      if (this.swarmContext) {
-        console.log(`🐝 Loaded swarm context for ${this.phaseName}`);
-      }
-    } catch (error) {
-      console.warn(`⚠️ Failed to load swarm context: ${error.message}`);
+   */ async loadSwarmContext() {
+        try {
+            this.swarmContext = await this.retrieveFromSwarmMemory(`${this.options.namespace}_swarm_context`);
+            if (this.swarmContext) {
+                console.log(`🐝 Loaded swarm context for ${this.phaseName}`);
+            }
+        } catch (error) {
+            console.warn(`⚠️ Failed to load swarm context: ${error.message}`);
+        }
     }
-  }
-
-  /**
+    /**
    * Update swarm context
-   */
-  async updateSwarmContext() {
-    try {
-      const contextUpdate = {
-        phase: this.phaseName,
-        timestamp: Date.now(),
-        artifacts: this.artifacts,
-        memory: this.memory,
-        status: 'completed',
-      };
-
-      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}`);
+   */ async updateSwarmContext() {
+        try {
+            const contextUpdate = {
+                phase: this.phaseName,
+                timestamp: Date.now(),
+                artifacts: this.artifacts,
+                memory: this.memory,
+                status: 'completed'
+            };
+            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}`);
+        }
     }
-  }
-
-  /**
+    /**
    * Save artifact to file system
-   */
-  async saveArtifact(filename, content) {
-    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(),
-      });
-
-      console.log(`📄 Saved artifact: ${filename}`);
-      return filePath;
-    } catch (error) {
-      console.warn(`⚠️ Failed to save artifact: ${error.message}`);
-      return null;
+   */ async saveArtifact(filename, content) {
+        try {
+            const fs = await import("node: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()
+            });
+            console.log(`📄 Saved artifact: ${filename}`);
+            return filePath;
+        } catch (error) {
+            console.warn(`⚠️ Failed to save artifact: ${error.message}`);
+            return null;
+        }
     }
-  }
-
-  /**
+    /**
    * Load artifact from file system
-   */
-  async loadArtifact(filename) {
-    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) {
-      console.warn(`⚠️ Failed to load artifact: ${error.message}`);
-      return null;
+   */ async loadArtifact(filename) {
+        try {
+            const fs = await import("node: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) {
+            console.warn(`⚠️ Failed to load artifact: ${error.message}`);
+            return null;
+        }
     }
-  }
-
-  /**
+    /**
    * Set remediation context for quality gate failures
-   */
-  setRemediationContext(qualityGate) {
-    this.remediationContext = qualityGate;
-    console.log(
-      `🔧 Set remediation context for ${this.phaseName}: ${qualityGate.reasons.join(', ')}`,
-    );
-  }
-
-  /**
+   */ setRemediationContext(qualityGate) {
+        this.remediationContext = qualityGate;
+        console.log(`🔧 Set remediation context for ${this.phaseName}: ${qualityGate.reasons.join(', ')}`);
+    }
+    /**
    * Get phase metrics
-   */
-  getMetrics() {
-    return {
-      phaseName: this.phaseName,
-      duration: this.endTime ? this.endTime - this.startTime : null,
-      artifactsCount: this.artifacts.length,
-      memoryKeys: Object.keys(this.memory).length,
-      hasSwarmContext: !!this.swarmContext,
-      hasRemediationContext: !!this.remediationContext,
-    };
-  }
-
-  /**
+   */ getMetrics() {
+        return {
+            phaseName: this.phaseName,
+            duration: this.endTime ? this.endTime - this.startTime : null,
+            artifactsCount: this.artifacts.length,
+            memoryKeys: Object.keys(this.memory).length,
+            hasSwarmContext: !!this.swarmContext,
+            hasRemediationContext: !!this.remediationContext
+        };
+    }
+    /**
    * Validate phase prerequisites
-   */
-  async validatePrerequisites() {
-    // Base validation - override in subclasses
-    return { valid: true, reasons: [] };
-  }
-
-  /**
+   */ async validatePrerequisites() {
+        // Base validation - override in subclasses
+        return {
+            valid: true,
+            reasons: []
+        };
+    }
+    /**
    * Execute phase - must be implemented by subclasses
-   */
-  async execute() {
-    throw new Error(`Execute method must be implemented by ${this.phaseName} phase`);
-  }
-
-  /**
+   */ async execute() {
+        throw new Error(`Execute method must be implemented by ${this.phaseName} phase`);
+    }
+    /**
    * Get phase status
-   */
-  getStatus() {
-    return {
-      phase: this.phaseName,
-      started: !!this.startTime,
-      completed: !!this.endTime,
-      duration: this.endTime ? this.endTime - this.startTime : null,
-      artifacts: this.artifacts.length,
-      hasContext: !!this.swarmContext,
-      hasRemediation: !!this.remediationContext,
-    };
-  }
-
-  /**
+   */ getStatus() {
+        return {
+            phase: this.phaseName,
+            started: !!this.startTime,
+            completed: !!this.endTime,
+            duration: this.endTime ? this.endTime - this.startTime : null,
+            artifacts: this.artifacts.length,
+            hasContext: !!this.swarmContext,
+            hasRemediation: !!this.remediationContext
+        };
+    }
+    /**
    * Neural learning hook
-   */
-  async recordLearning(learningData) {
-    if (!this.options.neuralLearning) return;
-
-    try {
-      const learningRecord = {
-        phase: this.phaseName,
-        timestamp: Date.now(),
-        data: learningData,
-        context: {
-          task: this.taskDescription,
-          options: this.options,
-          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),
-        );
-      }
-
-      console.log(`🧠 Recorded learning for ${this.phaseName}`);
-    } catch (error) {
-      console.warn(`⚠️ Failed to record learning: ${error.message}`);
+   */ async recordLearning(learningData) {
+        if (!this.options.neuralLearning) return;
+        try {
+            const learningRecord = {
+                phase: this.phaseName,
+                timestamp: Date.now(),
+                data: learningData,
+                context: {
+                    task: this.taskDescription,
+                    options: this.options,
+                    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));
+            }
+            console.log(`🧠 Recorded learning for ${this.phaseName}`);
+        } catch (error) {
+            console.warn(`⚠️ Failed to record learning: ${error.message}`);
+        }
     }
-  }
-
-  /**
+    /**
    * Get learning insights
-   */
-  async getLearningInsights() {
-    if (!this.options.neuralLearning) return [];
-
-    try {
-      const insights = [];
-
-      // Analyze previous executions
-      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),
-          });
+   */ async getLearningInsights() {
+        if (!this.options.neuralLearning) return [];
+        try {
+            const insights = [];
+            // Analyze previous executions
+            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)
+                    });
+                }
+            }
+            return insights;
+        } catch (error) {
+            console.warn(`⚠️ Failed to get learning insights: ${error.message}`);
+            return [];
         }
-      }
-
-      return insights;
-    } catch (error) {
-      console.warn(`⚠️ Failed to get learning insights: ${error.message}`);
-      return [];
     }
-  }
-
-  /**
+    /**
    * Generate insight from learning record
-   */
-  generateInsight(record) {
-    // Basic insight generation - can be enhanced with ML
-    const patterns = this.identifyPatterns(record);
-    return `Pattern identified: ${patterns.join(', ')}`;
-  }
-
-  /**
+   */ generateInsight(record) {
+        // Basic insight generation - can be enhanced with ML
+        const patterns = this.identifyPatterns(record);
+        return `Pattern identified: ${patterns.join(', ')}`;
+    }
+    /**
    * Calculate confidence score
-   */
-  calculateConfidence(record) {
-    // Simple confidence calculation based on recency and success
-    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;
-  }
-
-  /**
-   * Identify patterns in learning data
-   */
-  identifyPatterns(record) {
-    const patterns = [];
-
-    if (record.data.duration) {
-      if (record.data.duration > 60000) {
-        patterns.push('Long execution time');
-      } else if (record.data.duration < 10000) {
-        patterns.push('Fast execution');
-      }
+   */ calculateConfidence(record) {
+        // Simple confidence calculation based on recency and success
+        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;
     }
-
-    if (record.data.errors && record.data.errors.length > 0) {
-      patterns.push('Error prone');
+    /**
+   * Identify patterns in learning data
+   */ identifyPatterns(record) {
+        const patterns = [];
+        if (record.data.duration) {
+            if (record.data.duration > 60000) {
+                patterns.push('Long execution time');
+            } else if (record.data.duration < 10000) {
+                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;
     }
-
-    if (record.data.qualityGate && !record.data.qualityGate.passed) {
-      patterns.push('Quality gate failures');
+    constructor(phaseName, taskDescription, options = {}){
+        this.phaseName = phaseName;
+        this.taskDescription = taskDescription;
+        this.options = options;
+        this.startTime = null;
+        this.endTime = null;
+        this.artifacts = [];
+        this.memory = {};
+        this.swarmContext = null;
+        this.remediationContext = null;
     }
-
-    return patterns;
-  }
 }
-
 export default SparcPhase;