claude-flow-novice 2.0.4 → 2.0.5

package/dist/src/cli/simple-commands/verification-integration.js

@@ -1,436 +1,464 @@
 /**
  * Verification Integration Module
  * Connects verification system to actual agent operations and task execution
- */ import { exec } from "child_process";
-import { promisify } from "util";
-import fs from "node:fs/promises";
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs/promises';
+import path from 'path';
+import crypto from 'crypto';
+
 const execAsync = promisify(exec);
+
 /**
  * Verification middleware for task execution
  * Intercepts task results and verifies them
- */ export class VerificationMiddleware {
-    /**
+ */
+export class VerificationMiddleware {
+  constructor(verificationSystem) {
+    this.verificationSystem = verificationSystem;
+    this.enabled = true;
+    this.autoRollback = true;
+  }
+
+  /**
    * Wrap task execution with verification
-   */ async executeWithVerification(taskFn, taskId, agentType, context) {
-        // Pre-task verification
-        const preCheck = await this.preTaskVerification(taskId, context);
-        if (!preCheck.passed && this.enabled) {
-            console.log(`❌ Pre-task verification failed for ${taskId}`);
-            return {
-                success: false,
-                reason: 'Pre-task verification failed',
-                preCheck
-            };
-        }
-        // Execute the actual task
-        let result;
-        let error;
-        try {
-            result = await taskFn();
-        } catch (err) {
-            error = err;
-            result = {
-                success: false,
-                error: err.message
-            };
-        }
-        // Post-task verification
-        const postCheck = await this.postTaskVerification(taskId, agentType, result, context);
-        // If verification fails and auto-rollback is enabled
-        if (!postCheck.passed && this.autoRollback) {
-            await this.rollbackTask(taskId, context);
-            return {
-                success: false,
-                reason: 'Post-task verification failed',
-                result,
-                verification: postCheck,
-                rollback: true
-            };
-        }
-        return {
-            success: postCheck.passed,
-            result,
-            verification: postCheck
-        };
+   */
+  async executeWithVerification(taskFn, taskId, agentType, context) {
+    // Pre-task verification
+    const preCheck = await this.preTaskVerification(taskId, context);
+    if (!preCheck.passed && this.enabled) {
+      console.log(`❌ Pre-task verification failed for ${taskId}`);
+      return { success: false, reason: 'Pre-task verification failed', preCheck };
     }
-    /**
+
+    // Execute the actual task
+    let result;
+    let error;
+    try {
+      result = await taskFn();
+    } catch (err) {
+      error = err;
+      result = { success: false, error: err.message };
+    }
+
+    // Post-task verification
+    const postCheck = await this.postTaskVerification(taskId, agentType, result, context);
+
+    // If verification fails and auto-rollback is enabled
+    if (!postCheck.passed && this.autoRollback) {
+      await this.rollbackTask(taskId, context);
+      return {
+        success: false,
+        reason: 'Post-task verification failed',
+        result,
+        verification: postCheck,
+        rollback: true,
+      };
+    }
+
+    return {
+      success: postCheck.passed,
+      result,
+      verification: postCheck,
+    };
+  }
+
+  /**
    * Pre-task verification checks
-   */ async preTaskVerification(taskId, context) {
-        const checks = [];
-        // Check if environment is clean
-        if (context.requiresCleanState) {
-            const gitStatus = await this.checkGitStatus();
-            checks.push({
-                name: 'clean-state',
-                passed: gitStatus.clean,
-                score: gitStatus.clean ? 1.0 : 0.0
-            });
-        }
-        // Check dependencies
-        if (context.dependencies) {
-            for (const dep of context.dependencies){
-                const exists = await this.checkDependency(dep);
-                checks.push({
-                    name: `dependency-${dep}`,
-                    passed: exists,
-                    score: exists ? 1.0 : 0.0
-                });
-            }
-        }
-        const score = checks.length > 0 ? checks.reduce((sum, c)=>sum + c.score, 0) / checks.length : 1.0;
-        return {
-            passed: score >= 0.95,
-            score,
-            checks,
-            timestamp: new Date().toISOString()
-        };
+   */
+  async preTaskVerification(taskId, context) {
+    const checks = [];
+
+    // Check if environment is clean
+    if (context.requiresCleanState) {
+      const gitStatus = await this.checkGitStatus();
+      checks.push({
+        name: 'clean-state',
+        passed: gitStatus.clean,
+        score: gitStatus.clean ? 1.0 : 0.0,
+      });
     }
-    /**
+
+    // Check dependencies
+    if (context.dependencies) {
+      for (const dep of context.dependencies) {
+        const exists = await this.checkDependency(dep);
+        checks.push({
+          name: `dependency-${dep}`,
+          passed: exists,
+          score: exists ? 1.0 : 0.0,
+        });
+      }
+    }
+
+    const score =
+      checks.length > 0 ? checks.reduce((sum, c) => sum + c.score, 0) / checks.length : 1.0;
+
+    return {
+      passed: score >= 0.95,
+      score,
+      checks,
+      timestamp: new Date().toISOString(),
+    };
+  }
+
+  /**
    * Post-task verification checks
-   */ async postTaskVerification(taskId, agentType, result, context) {
-        const checks = [];
-        // Verify based on agent type
-        switch(agentType){
-            case 'coder':
-                // Check if code compiles
-                if (context.language === 'typescript' || context.language === 'javascript') {
-                    const typecheck = await this.runTypeCheck();
-                    checks.push({
-                        name: 'typecheck',
-                        passed: typecheck.passed,
-                        score: typecheck.score
-                    });
-                }
-                // Check if tests pass
-                if (context.hasTests) {
-                    const tests = await this.runTests();
-                    checks.push({
-                        name: 'tests',
-                        passed: tests.passed,
-                        score: tests.score
-                    });
-                }
-                // Check linting
-                const lint = await this.runLint();
-                checks.push({
-                    name: 'lint',
-                    passed: lint.passed,
-                    score: lint.score
-                });
-                break;
-            case 'researcher':
-                // Verify research output has required sections
-                if (result && result.output) {
-                    const hasFindings = result.output.includes('findings') || result.output.includes('results');
-                    checks.push({
-                        name: 'research-completeness',
-                        passed: hasFindings,
-                        score: hasFindings ? 1.0 : 0.5
-                    });
-                }
-                break;
-            case 'tester':
-                // Verify test coverage meets threshold
-                if (context.requiresCoverage) {
-                    const coverage = await this.checkTestCoverage();
-                    checks.push({
-                        name: 'coverage',
-                        passed: coverage.percentage >= 80,
-                        score: coverage.percentage / 100
-                    });
-                }
-                break;
-            case 'architect':
-                // Verify architecture decisions are documented
-                const hasDocs = await this.checkDocumentation();
-                checks.push({
-                    name: 'documentation',
-                    passed: hasDocs,
-                    score: hasDocs ? 1.0 : 0.3
-                });
-                break;
+   */
+  async postTaskVerification(taskId, agentType, result, context) {
+    const checks = [];
+
+    // Verify based on agent type
+    switch (agentType) {
+      case 'coder':
+        // Check if code compiles
+        if (context.language === 'typescript' || context.language === 'javascript') {
+          const typecheck = await this.runTypeCheck();
+          checks.push({
+            name: 'typecheck',
+            passed: typecheck.passed,
+            score: typecheck.score,
+          });
         }
-        // Check result success claim
-        if (result && result.success !== undefined) {
-            checks.push({
-                name: 'claimed-success',
-                passed: result.success,
-                score: result.success ? 1.0 : 0.0
-            });
+
+        // Check if tests pass
+        if (context.hasTests) {
+          const tests = await this.runTests();
+          checks.push({
+            name: 'tests',
+            passed: tests.passed,
+            score: tests.score,
+          });
         }
-        const score = checks.length > 0 ? checks.reduce((sum, c)=>sum + c.score, 0) / checks.length : 0.5;
-        // Store verification result
-        await this.verificationSystem.verifyTask(taskId, agentType, {
-            success: result?.success,
-            checks,
-            score
+
+        // Check linting
+        const lint = await this.runLint();
+        checks.push({
+          name: 'lint',
+          passed: lint.passed,
+          score: lint.score,
         });
-        return {
-            passed: score >= this.verificationSystem.getThreshold(),
-            score,
-            checks,
-            timestamp: new Date().toISOString()
-        };
+        break;
+
+      case 'researcher':
+        // Verify research output has required sections
+        if (result && result.output) {
+          const hasFindings =
+            result.output.includes('findings') || result.output.includes('results');
+          checks.push({
+            name: 'research-completeness',
+            passed: hasFindings,
+            score: hasFindings ? 1.0 : 0.5,
+          });
+        }
+        break;
+
+      case 'tester':
+        // Verify test coverage meets threshold
+        if (context.requiresCoverage) {
+          const coverage = await this.checkTestCoverage();
+          checks.push({
+            name: 'coverage',
+            passed: coverage.percentage >= 80,
+            score: coverage.percentage / 100,
+          });
+        }
+        break;
+
+      case 'architect':
+        // Verify architecture decisions are documented
+        const hasDocs = await this.checkDocumentation();
+        checks.push({
+          name: 'documentation',
+          passed: hasDocs,
+          score: hasDocs ? 1.0 : 0.3,
+        });
+        break;
+    }
+
+    // Check result success claim
+    if (result && result.success !== undefined) {
+      checks.push({
+        name: 'claimed-success',
+        passed: result.success,
+        score: result.success ? 1.0 : 0.0,
+      });
     }
-    /**
+
+    const score =
+      checks.length > 0 ? checks.reduce((sum, c) => sum + c.score, 0) / checks.length : 0.5;
+
+    // Store verification result
+    await this.verificationSystem.verifyTask(taskId, agentType, {
+      success: result?.success,
+      checks,
+      score,
+    });
+
+    return {
+      passed: score >= this.verificationSystem.getThreshold(),
+      score,
+      checks,
+      timestamp: new Date().toISOString(),
+    };
+  }
+
+  /**
    * Rollback task changes
-   */ async rollbackTask(taskId, context) {
-        console.log(`🔄 Rolling back task ${taskId}...`);
-        try {
-            // If we have a git checkpoint, rollback to it
-            if (context.gitCheckpoint) {
-                await execAsync(`git reset --hard ${context.gitCheckpoint}`);
-                console.log(`✅ Rolled back to checkpoint ${context.gitCheckpoint}`);
-            } else {
-                // Otherwise just reset to last commit
-                await execAsync('git reset --hard HEAD');
-                console.log(`✅ Rolled back to last commit`);
-            }
-            return true;
-        } catch (error) {
-            console.error(`❌ Rollback failed: ${error.message}`);
-            return false;
-        }
+   */
+  async rollbackTask(taskId, context) {
+    console.log(`🔄 Rolling back task ${taskId}...`);
+
+    try {
+      // If we have a git checkpoint, rollback to it
+      if (context.gitCheckpoint) {
+        await execAsync(`git reset --hard ${context.gitCheckpoint}`);
+        console.log(`✅ Rolled back to checkpoint ${context.gitCheckpoint}`);
+      } else {
+        // Otherwise just reset to last commit
+        await execAsync('git reset --hard HEAD');
+        console.log(`✅ Rolled back to last commit`);
+      }
+      return true;
+    } catch (error) {
+      console.error(`❌ Rollback failed: ${error.message}`);
+      return false;
     }
-    // Helper methods for actual checks
-    async checkGitStatus() {
-        try {
-            const { stdout } = await execAsync('git status --porcelain');
-            return {
-                clean: stdout.trim() === ''
-            };
-        } catch  {
-            return {
-                clean: false
-            };
-        }
+  }
+
+  // Helper methods for actual checks
+
+  async checkGitStatus() {
+    try {
+      const { stdout } = await execAsync('git status --porcelain');
+      return { clean: stdout.trim() === '' };
+    } catch {
+      return { clean: false };
     }
-    async checkDependency(dep) {
-        try {
-            await execAsync(`which ${dep}`);
-            return true;
-        } catch  {
-            return false;
-        }
+  }
+
+  async checkDependency(dep) {
+    try {
+      await execAsync(`which ${dep}`);
+      return true;
+    } catch {
+      return false;
     }
-    async runTypeCheck() {
-        try {
-            const { stdout } = await execAsync('npm run typecheck 2>&1 || true');
-            const hasErrors = stdout.toLowerCase().includes('error');
-            return {
-                passed: !hasErrors,
-                score: hasErrors ? 0.5 : 1.0
-            };
-        } catch  {
-            return {
-                passed: false,
-                score: 0.3
-            };
-        }
+  }
+
+  async runTypeCheck() {
+    try {
+      const { stdout } = await execAsync('npm run typecheck 2>&1 || true');
+      const hasErrors = stdout.toLowerCase().includes('error');
+      return {
+        passed: !hasErrors,
+        score: hasErrors ? 0.5 : 1.0,
+      };
+    } catch {
+      return { passed: false, score: 0.3 };
     }
-    async runTests() {
-        try {
-            const { stdout } = await execAsync('npm test 2>&1 || true');
-            const passed = stdout.includes('PASS') || stdout.includes('passing');
-            const failed = stdout.includes('FAIL') || stdout.includes('failing');
-            if (passed && !failed) {
-                return {
-                    passed: true,
-                    score: 1.0
-                };
-            } else if (passed && failed) {
-                return {
-                    passed: false,
-                    score: 0.7
-                };
-            } else {
-                return {
-                    passed: false,
-                    score: 0.3
-                };
-            }
-        } catch  {
-            return {
-                passed: false,
-                score: 0.0
-            };
-        }
+  }
+
+  async runTests() {
+    try {
+      const { stdout } = await execAsync('npm test 2>&1 || true');
+      const passed = stdout.includes('PASS') || stdout.includes('passing');
+      const failed = stdout.includes('FAIL') || stdout.includes('failing');
+
+      if (passed && !failed) {
+        return { passed: true, score: 1.0 };
+      } else if (passed && failed) {
+        return { passed: false, score: 0.7 };
+      } else {
+        return { passed: false, score: 0.3 };
+      }
+    } catch {
+      return { passed: false, score: 0.0 };
     }
-    async runLint() {
-        try {
-            const { stdout } = await execAsync('npm run lint 2>&1 || true');
-            const hasErrors = stdout.toLowerCase().includes('error');
-            const hasWarnings = stdout.toLowerCase().includes('warning');
-            if (!hasErrors && !hasWarnings) {
-                return {
-                    passed: true,
-                    score: 1.0
-                };
-            } else if (!hasErrors && hasWarnings) {
-                return {
-                    passed: true,
-                    score: 0.8
-                };
-            } else {
-                return {
-                    passed: false,
-                    score: 0.5
-                };
-            }
-        } catch  {
-            return {
-                passed: false,
-                score: 0.3
-            };
-        }
+  }
+
+  async runLint() {
+    try {
+      const { stdout } = await execAsync('npm run lint 2>&1 || true');
+      const hasErrors = stdout.toLowerCase().includes('error');
+      const hasWarnings = stdout.toLowerCase().includes('warning');
+
+      if (!hasErrors && !hasWarnings) {
+        return { passed: true, score: 1.0 };
+      } else if (!hasErrors && hasWarnings) {
+        return { passed: true, score: 0.8 };
+      } else {
+        return { passed: false, score: 0.5 };
+      }
+    } catch {
+      return { passed: false, score: 0.3 };
     }
-    async checkTestCoverage() {
-        try {
-            const { stdout } = await execAsync('npm run coverage 2>&1 || true');
-            const match = stdout.match(/(\d+(\.\d+)?)\s*%/);
-            const percentage = match ? parseFloat(match[1]) : 0;
-            return {
-                percentage
-            };
-        } catch  {
-            return {
-                percentage: 0
-            };
-        }
+  }
+
+  async checkTestCoverage() {
+    try {
+      const { stdout } = await execAsync('npm run coverage 2>&1 || true');
+      const match = stdout.match(/(\d+(\.\d+)?)\s*%/);
+      const percentage = match ? parseFloat(match[1]) : 0;
+      return { percentage };
+    } catch {
+      return { percentage: 0 };
     }
-    async checkDocumentation() {
+  }
+
+  async checkDocumentation() {
+    try {
+      // Check if common documentation files exist
+      const docFiles = ['README.md', 'ARCHITECTURE.md', 'docs/design.md'];
+      for (const file of docFiles) {
         try {
-            // Check if common documentation files exist
-            const docFiles = [
-                'README.md',
-                'ARCHITECTURE.md',
-                'docs/design.md'
-            ];
-            for (const file of docFiles){
-                try {
-                    await fs.access(file);
-                    return true;
-                } catch  {
-                // Continue checking other files
-                }
-            }
-            return false;
-        } catch  {
-            return false;
+          await fs.access(file);
+          return true;
+        } catch {
+          // Continue checking other files
         }
+      }
+      return false;
+    } catch {
+      return false;
     }
-    constructor(verificationSystem){
-        this.verificationSystem = verificationSystem;
-        this.enabled = true;
-        this.autoRollback = true;
-    }
+  }
 }
+
 /**
  * Integration with swarm command
- */ export function integrateWithSwarm(swarmCommand, verificationSystem) {
-    const originalExecute = swarmCommand.execute;
-    const middleware = new VerificationMiddleware(verificationSystem);
-    swarmCommand.execute = async function(objective, options) {
-        // Create checkpoint before swarm execution
-        const checkpoint = await createGitCheckpoint();
-        // Wrap the original execution with verification
-        const context = {
-            requiresCleanState: !options.allowDirty,
-            dependencies: options.dependencies || [],
-            language: options.language || 'javascript',
-            hasTests: options.runTests !== false,
-            requiresCoverage: options.coverage === true,
-            gitCheckpoint: checkpoint
-        };
-        // Execute with verification
-        return await middleware.executeWithVerification(()=>originalExecute.call(this, objective, options), `swarm-${Date.now()}`, 'swarm', context);
+ */
+export function integrateWithSwarm(swarmCommand, verificationSystem) {
+  const originalExecute = swarmCommand.execute;
+  const middleware = new VerificationMiddleware(verificationSystem);
+
+  swarmCommand.execute = async function (objective, options) {
+    // Create checkpoint before swarm execution
+    const checkpoint = await createGitCheckpoint();
+
+    // Wrap the original execution with verification
+    const context = {
+      requiresCleanState: !options.allowDirty,
+      dependencies: options.dependencies || [],
+      language: options.language || 'javascript',
+      hasTests: options.runTests !== false,
+      requiresCoverage: options.coverage === true,
+      gitCheckpoint: checkpoint,
     };
-    return swarmCommand;
+
+    // Execute with verification
+    return await middleware.executeWithVerification(
+      () => originalExecute.call(this, objective, options),
+      `swarm-${Date.now()}`,
+      'swarm',
+      context,
+    );
+  };
+
+  return swarmCommand;
 }
+
 /**
  * Integration with non-interactive mode
- */ export function integrateWithNonInteractive(flags, verificationSystem) {
-    // Add verification flags to non-interactive mode
-    const verificationFlags = {
-        ...flags,
-        verify: true,
-        verificationThreshold: flags.threshold || 0.95,
-        autoRollback: flags.rollback !== false
-    };
-    // Return a verification wrapper for non-interactive execution
-    return {
-        flags: verificationFlags,
-        preExecute: async (taskId)=>{
-            await verificationSystem.initialize('strict');
-            console.log('✅ Verification enabled for non-interactive mode');
-        },
-        postExecute: async (taskId, result)=>{
-            const verification = await verificationSystem.verifyTask(taskId, 'non-interactive', result);
-            if (!verification.passed) {
-                console.error('❌ Verification failed in non-interactive mode');
-                process.exit(1);
-            }
-        }
-    };
+ */
+export function integrateWithNonInteractive(flags, verificationSystem) {
+  // Add verification flags to non-interactive mode
+  const verificationFlags = {
+    ...flags,
+    verify: true,
+    verificationThreshold: flags.threshold || 0.95,
+    autoRollback: flags.rollback !== false,
+  };
+
+  // Return a verification wrapper for non-interactive execution
+  return {
+    flags: verificationFlags,
+    preExecute: async (taskId) => {
+      await verificationSystem.initialize('strict');
+      console.log('✅ Verification enabled for non-interactive mode');
+    },
+    postExecute: async (taskId, result) => {
+      const verification = await verificationSystem.verifyTask(taskId, 'non-interactive', result);
+
+      if (!verification.passed) {
+        console.error('❌ Verification failed in non-interactive mode');
+        process.exit(1);
+      }
+    },
+  };
 }
+
 /**
  * Integration with training system
- */ export function integrateWithTraining(trainingSystem, verificationSystem) {
-    // Feed verification results to training system
-    verificationSystem.onVerification = async (verification)=>{
-        // Convert verification to training data
-        const trainingData = {
-            input: {
-                taskId: verification.taskId,
-                agentType: verification.agentType,
-                context: verification.context
-            },
-            output: {
-                success: verification.passed,
-                score: verification.score,
-                checks: verification.results
-            }
-        };
-        // Feed to training system
-        await trainingSystem.learn(trainingData);
-        // Update agent model based on performance
-        if (verification.agentType) {
-            await trainingSystem.updateAgentModel(verification.agentType, verification.score);
-        }
+ */
+export function integrateWithTraining(trainingSystem, verificationSystem) {
+  // Feed verification results to training system
+  verificationSystem.onVerification = async (verification) => {
+    // Convert verification to training data
+    const trainingData = {
+      input: {
+        taskId: verification.taskId,
+        agentType: verification.agentType,
+        context: verification.context,
+      },
+      output: {
+        success: verification.passed,
+        score: verification.score,
+        checks: verification.results,
+      },
     };
-    return verificationSystem;
+
+    // Feed to training system
+    await trainingSystem.learn(trainingData);
+
+    // Update agent model based on performance
+    if (verification.agentType) {
+      await trainingSystem.updateAgentModel(verification.agentType, verification.score);
+    }
+  };
+
+  return verificationSystem;
 }
+
 /**
  * Create git checkpoint for rollback
- */ async function createGitCheckpoint() {
-    try {
-        // Create a temporary commit as checkpoint
-        const { stdout } = await execAsync('git rev-parse HEAD');
-        return stdout.trim();
-    } catch  {
-        return null;
-    }
+ */
+async function createGitCheckpoint() {
+  try {
+    // Create a temporary commit as checkpoint
+    const { stdout } = await execAsync('git rev-parse HEAD');
+    return stdout.trim();
+  } catch {
+    return null;
+  }
 }
+
 /**
  * Export verification hooks for command integration
- */ export const verificationHooks = {
-    beforeTask: async (taskId, context)=>{
-        // Hook called before task execution
-        console.log(`🔍 Pre-task verification for ${taskId}`);
-    },
-    afterTask: async (taskId, result, context)=>{
-        // Hook called after task execution
-        console.log(`✅ Post-task verification for ${taskId}`);
-    },
-    onFailure: async (taskId, verification)=>{
-        // Hook called when verification fails
-        console.log(`❌ Verification failed for ${taskId}: ${verification.score}`);
-    }
+ */
+export const verificationHooks = {
+  beforeTask: async (taskId, context) => {
+    // Hook called before task execution
+    console.log(`🔍 Pre-task verification for ${taskId}`);
+  },
+
+  afterTask: async (taskId, result, context) => {
+    // Hook called after task execution
+    console.log(`✅ Post-task verification for ${taskId}`);
+  },
+
+  onFailure: async (taskId, verification) => {
+    // Hook called when verification fails
+    console.log(`❌ Verification failed for ${taskId}: ${verification.score}`);
+  },
 };
+
 export default {
-    VerificationMiddleware,
-    integrateWithSwarm,
-    integrateWithNonInteractive,
-    integrateWithTraining,
-    verificationHooks
+  VerificationMiddleware,
+  integrateWithSwarm,
+  integrateWithNonInteractive,
+  integrateWithTraining,
+  verificationHooks,
 };