claude-flow-novice 2.0.3 → 2.0.4

package/dist/src/cli/simple-commands/training-pipeline.js

@@ -2,77 +2,60 @@
 /**
  * Training Pipeline with Real Task Execution
  * Executes actual code and learns from real test results
- */
-
-import fs from 'fs/promises';
-import path from 'path';
-import { execSync, spawn } from 'child_process';
-import { promisify } from 'util';
-import { exec } from 'child_process';
-
+ */ import fs from "node:fs/promises";
+import path from "path";
+import { execSync } from "child_process";
+import { promisify } from "util";
+import { exec } from "child_process";
 const execAsync = promisify(exec);
-
 /**
  * Training Pipeline that executes real tasks and learns from actual results
- */
-export class TrainingPipeline {
-  constructor() {
-    this.pipelineConfig = '.claude-flow/pipeline-config.json';
-    this.trainingLog = '.claude-flow/training/pipeline-log.jsonl';
-    this.improvementMetrics = '.claude-flow/metrics/improvements.json';
-    this.agentProfiles = '.claude-flow/agents/profiles.json';
-    this.realTasksDir = '.claude-flow/training/real-tasks';
-    this.initialized = false;
-  }
-
-  /**
+ */ export class TrainingPipeline {
+    /**
    * Initialize the training pipeline
-   */
-  async initialize() {
-    // Create necessary directories
-    const dirs = [
-      '.claude-flow/pipeline',
-      '.claude-flow/training',
-      '.claude-flow/training/real-tasks',
-      '.claude-flow/metrics',
-      '.claude-flow/agents',
-      '.claude-flow/validation',
-      '.claude-flow/benchmarks',
-    ];
-
-    for (const dir of dirs) {
-      await fs.mkdir(dir, { recursive: true });
+   */ async initialize() {
+        // Create necessary directories
+        const dirs = [
+            '.claude-flow/pipeline',
+            '.claude-flow/training',
+            '.claude-flow/training/real-tasks',
+            '.claude-flow/metrics',
+            '.claude-flow/agents',
+            '.claude-flow/validation',
+            '.claude-flow/benchmarks'
+        ];
+        for (const dir of dirs){
+            await fs.mkdir(dir, {
+                recursive: true
+            });
+        }
+        // Load or create pipeline configuration
+        await this.loadPipelineConfig();
+        console.log('🚀 Training Pipeline initialized');
+        this.initialized = true;
     }
-
-    // Load or create pipeline configuration
-    await this.loadPipelineConfig();
-
-    console.log('🚀 Training Pipeline initialized');
-    this.initialized = true;
-  }
-
-  /**
+    /**
    * STAGE 1: Generate Training Tasks
    * Creates actual code files that can be tested
-   */
-  async generateTrainingTasks(complexity = 'medium') {
-    const taskId = Date.now();
-    const taskDir = path.join(this.realTasksDir, `task-${taskId}`);
-    await fs.mkdir(taskDir, { recursive: true });
-
-    const tasks = {
-      easy: [
-        {
-          type: 'function',
-          name: 'validateEmail',
-          task: 'Create email validation function',
-          code: `function validateEmail(email) {
+   */ async generateTrainingTasks(complexity = 'medium') {
+        const taskId = Date.now();
+        const taskDir = path.join(this.realTasksDir, `task-${taskId}`);
+        await fs.mkdir(taskDir, {
+            recursive: true
+        });
+        const tasks = {
+            easy: [
+                {
+                    type: 'function',
+                    name: 'validateEmail',
+                    task: 'Create email validation function',
+                    code: `function validateEmail(email) {
   const regex = /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/;
   return regex.test(email);
 }
 
 module.exports = { validateEmail };`,
-          test: `
+                    test: `
 const { validateEmail } = require('./index');
 
 describe('validateEmail', () => {
@@ -84,15 +67,15 @@ describe('validateEmail', () => {
     expect(validateEmail('invalid')).toBe(false);
   });
 });
-`,
-        },
-      ],
-      medium: [
-        {
-          type: 'api',
-          name: 'userApi',
-          task: 'Build user API endpoint',
-          code: `
+`
+                }
+            ],
+            medium: [
+                {
+                    type: 'api',
+                    name: 'userApi',
+                    task: 'Build user API endpoint',
+                    code: `
 const express = require('express');
 const app = express();
 
@@ -116,7 +99,7 @@ app.post('/users', (req, res) => {
 
 module.exports = app;
 `,
-          test: `
+                    test: `
 const request = require('supertest');
 const app = require('./index');
 
@@ -135,15 +118,15 @@ describe('User API', () => {
     expect(res.body.name).toBe('Test');
   });
 });
-`,
-        },
-      ],
-      hard: [
-        {
-          type: 'algorithm',
-          name: 'sortAlgorithm',
-          task: 'Implement efficient sorting',
-          code: `
+`
+                }
+            ],
+            hard: [
+                {
+                    type: 'algorithm',
+                    name: 'sortAlgorithm',
+                    task: 'Implement efficient sorting',
+                    code: `
 function quickSort(arr) {
   if (arr.length <= 1) return arr;
   
@@ -178,7 +161,7 @@ function mergeSort(arr) {
 
 module.exports = { quickSort, mergeSort };
 `,
-          test: `
+                    test: `
 const { quickSort, mergeSort } = require('./index');
 
 describe('Sorting Algorithms', () => {
@@ -198,677 +181,588 @@ describe('Sorting Algorithms', () => {
     expect(mergeSort([])).toEqual([]);
   });
 });
-`,
-        },
-      ],
-    };
-
-    const selectedTasks = tasks[complexity] || tasks.medium;
-    const realTasks = [];
-
-    // Create real task files
-    for (const task of selectedTasks) {
-      const projectDir = path.join(taskDir, task.name);
-      await fs.mkdir(projectDir, { recursive: true });
-
-      // Write actual code file
-      await fs.writeFile(path.join(projectDir, 'index.js'), task.code);
-
-      // Write test file
-      await fs.writeFile(path.join(projectDir, 'index.test.js'), task.test);
-
-      // Create package.json with real dependencies
-      const packageJson = {
-        name: task.name,
-        version: '1.0.0',
-        scripts: {
-          test: 'jest --silent',
-          lint: 'eslint index.js || true',
-          typecheck: "echo 'No TypeScript' || true",
-        },
-        devDependencies: {
-          jest: '^29.0.0',
-          eslint: '^8.0.0',
-          supertest: '^6.0.0',
-        },
-        dependencies: {
-          express: task.type === 'api' ? '^4.18.0' : undefined,
-        },
-      };
-
-      await fs.writeFile(
-        path.join(projectDir, 'package.json'),
-        JSON.stringify(packageJson, null, 2),
-      );
-
-      realTasks.push({
-        ...task,
-        projectDir,
-        taskId,
-      });
+`
+                }
+            ]
+        };
+        const selectedTasks = tasks[complexity] || tasks.medium;
+        const realTasks = [];
+        // Create real task files
+        for (const task of selectedTasks){
+            const projectDir = path.join(taskDir, task.name);
+            await fs.mkdir(projectDir, {
+                recursive: true
+            });
+            // Write actual code file
+            await fs.writeFile(path.join(projectDir, 'index.js'), task.code);
+            // Write test file
+            await fs.writeFile(path.join(projectDir, 'index.test.js'), task.test);
+            // Create package.json with real dependencies
+            const packageJson = {
+                name: task.name,
+                version: '1.0.0',
+                scripts: {
+                    test: 'jest --silent',
+                    lint: 'eslint index.js || true',
+                    typecheck: "echo 'No TypeScript' || true"
+                },
+                devDependencies: {
+                    jest: '^29.0.0',
+                    eslint: '^8.0.0',
+                    supertest: '^6.0.0'
+                },
+                dependencies: {
+                    express: task.type === 'api' ? '^4.18.0' : undefined
+                }
+            };
+            await fs.writeFile(path.join(projectDir, 'package.json'), JSON.stringify(packageJson, null, 2));
+            realTasks.push({
+                ...task,
+                projectDir,
+                taskId
+            });
+        }
+        console.log(`📝 Generated ${realTasks.length} ${complexity} training tasks`);
+        return realTasks;
     }
-
-    console.log(`📝 Generated ${realTasks.length} ${complexity} training tasks`);
-    return realTasks;
-  }
-
-  /**
+    /**
    * STAGE 2: Execute Tasks with Different Strategies
    * Actually runs npm install, tests, and measures real performance
-   */
-  async executeTrainingRun(tasks, agentConfig = {}) {
-    const results = [];
-
-    for (const task of tasks) {
-      console.log(`\n🔄 Executing task: ${task.task}`);
-
-      // Install dependencies (only once per task)
-      try {
-        console.log(`   📦 Installing dependencies...`);
-        execSync('npm install --silent', {
-          cwd: task.projectDir,
-          stdio: 'pipe',
-        });
-      } catch (e) {
-        console.log(`   ⚠️ Install warning: ${e.message.slice(0, 50)}`);
-      }
-
-      // Test different strategies with REAL variations
-      const strategies = agentConfig.strategies || ['conservative', 'balanced', 'aggressive'];
-
-      for (const strategy of strategies) {
-        const result = await this.executeTaskWithStrategy(task, strategy);
-        results.push({
-          task: task.task,
-          type: task.type,
-          strategy,
-          ...result,
-          timestamp: new Date().toISOString(),
-        });
-      }
+   */ async executeTrainingRun(tasks, agentConfig = {}) {
+        const results = [];
+        for (const task of tasks){
+            console.log(`\n🔄 Executing task: ${task.task}`);
+            // Install dependencies (only once per task)
+            try {
+                console.log(`   📦 Installing dependencies...`);
+                execSync('npm install --silent', {
+                    cwd: task.projectDir,
+                    stdio: 'pipe'
+                });
+            } catch (e) {
+                console.log(`   ⚠️ Install warning: ${e.message.slice(0, 50)}`);
+            }
+            // Test different strategies with REAL variations
+            const strategies = agentConfig.strategies || [
+                'conservative',
+                'balanced',
+                'aggressive'
+            ];
+            for (const strategy of strategies){
+                const result = await this.executeTaskWithStrategy(task, strategy);
+                results.push({
+                    task: task.task,
+                    type: task.type,
+                    strategy,
+                    ...result,
+                    timestamp: new Date().toISOString()
+                });
+            }
+        }
+        // Save real results
+        const resultsFile = `.claude-flow/training/real-results-${Date.now()}.json`;
+        await fs.writeFile(resultsFile, JSON.stringify(results, null, 2));
+        return results;
     }
-
-    // Save real results
-    const resultsFile = `.claude-flow/training/real-results-${Date.now()}.json`;
-    await fs.writeFile(resultsFile, JSON.stringify(results, null, 2));
-
-    return results;
-  }
-
-  /**
+    /**
    * Execute a task with a specific strategy
    * Strategies affect how we modify and test the code
-   */
-  async executeTaskWithStrategy(task, strategy) {
-    const startTime = Date.now();
-    const checks = {};
-
-    // Save original code
-    const originalCode = await fs.readFile(path.join(task.projectDir, 'index.js'), 'utf8');
-
-    // Modify code based on strategy (but more carefully!)
-    if (strategy === 'aggressive') {
-      // Aggressive: Skip some validation (but keep valid syntax)
-      const aggressiveCode = originalCode.replace(/if \(!(\w+)\)/g, 'if (false && !$1)');
-      await fs.writeFile(path.join(task.projectDir, 'index.js'), aggressiveCode);
-    } else if (strategy === 'conservative') {
-      // Conservative: Add validation at the top of functions
-      const conservativeCode = originalCode.replace(
-        /function (\w+)\((.*?)\) {/g,
-        'function $1($2) {\n  // Extra validation for conservative strategy\n  if (arguments.length === 0) throw new Error("No arguments provided");',
-      );
-      await fs.writeFile(path.join(task.projectDir, 'index.js'), conservativeCode);
-    }
-    // Balanced: Keep original code
-
-    // Run REAL tests
-    try {
-      const testResult = execSync('npm test', {
-        cwd: task.projectDir,
-        encoding: 'utf8',
-        stdio: 'pipe',
-      });
-      checks.test = {
-        passed: true,
-        score: 1.0,
-        output: testResult.slice(0, 100),
-      };
-    } catch (e) {
-      checks.test = {
-        passed: false,
-        score: 0.3,
-        error: e.message.slice(0, 100),
-      };
-    }
-
-    // Run REAL lint
-    try {
-      const lintResult = execSync('npm run lint', {
-        cwd: task.projectDir,
-        encoding: 'utf8',
-        stdio: 'pipe',
-      });
-      const hasErrors = lintResult.includes('error');
-      checks.lint = {
-        passed: !hasErrors,
-        score: hasErrors ? 0.5 : 1.0,
-      };
-    } catch (e) {
-      checks.lint = {
-        passed: false,
-        score: 0.3,
-      };
-    }
-
-    // Restore original code after testing
-    await fs.writeFile(path.join(task.projectDir, 'index.js'), originalCode);
-
-    // Calculate REAL performance metrics
-    const executionTime = Date.now() - startTime;
-    const successRate =
-      Object.values(checks).filter((c) => c.passed).length / Object.values(checks).length;
-
-    // Strategy-specific scoring based on REAL results
-    let strategyBonus = 0;
-    if (strategy === 'aggressive' && executionTime < 1000) {
-      strategyBonus = 0.2; // Bonus for fast execution
-    } else if (strategy === 'conservative' && successRate === 1.0) {
-      strategyBonus = 0.3; // Bonus for perfect reliability
-    } else if (strategy === 'balanced' && successRate > 0.5 && executionTime < 2000) {
-      strategyBonus = 0.25; // Bonus for good balance
+   */ async executeTaskWithStrategy(task, strategy) {
+        const startTime = Date.now();
+        const checks = {};
+        // Save original code
+        const originalCode = await fs.readFile(path.join(task.projectDir, 'index.js'), 'utf8');
+        // Modify code based on strategy (but more carefully!)
+        if (strategy === 'aggressive') {
+            // Aggressive: Skip some validation (but keep valid syntax)
+            const aggressiveCode = originalCode.replace(/if \(!(\w+)\)/g, 'if (false && !$1)');
+            await fs.writeFile(path.join(task.projectDir, 'index.js'), aggressiveCode);
+        } else if (strategy === 'conservative') {
+            // Conservative: Add validation at the top of functions
+            const conservativeCode = originalCode.replace(/function (\w+)\((.*?)\) {/g, 'function $1($2) {\n  // Extra validation for conservative strategy\n  if (arguments.length === 0) throw new Error("No arguments provided");');
+            await fs.writeFile(path.join(task.projectDir, 'index.js'), conservativeCode);
+        }
+        // Balanced: Keep original code
+        // Run REAL tests
+        try {
+            const testResult = execSync('npm test', {
+                cwd: task.projectDir,
+                encoding: 'utf8',
+                stdio: 'pipe'
+            });
+            checks.test = {
+                passed: true,
+                score: 1.0,
+                output: testResult.slice(0, 100)
+            };
+        } catch (e) {
+            checks.test = {
+                passed: false,
+                score: 0.3,
+                error: e.message.slice(0, 100)
+            };
+        }
+        // Run REAL lint
+        try {
+            const lintResult = execSync('npm run lint', {
+                cwd: task.projectDir,
+                encoding: 'utf8',
+                stdio: 'pipe'
+            });
+            const hasErrors = lintResult.includes('error');
+            checks.lint = {
+                passed: !hasErrors,
+                score: hasErrors ? 0.5 : 1.0
+            };
+        } catch (e) {
+            checks.lint = {
+                passed: false,
+                score: 0.3
+            };
+        }
+        // Restore original code after testing
+        await fs.writeFile(path.join(task.projectDir, 'index.js'), originalCode);
+        // Calculate REAL performance metrics
+        const executionTime = Date.now() - startTime;
+        const successRate = Object.values(checks).filter((c)=>c.passed).length / Object.values(checks).length;
+        // Strategy-specific scoring based on REAL results
+        let strategyBonus = 0;
+        if (strategy === 'aggressive' && executionTime < 1000) {
+            strategyBonus = 0.2; // Bonus for fast execution
+        } else if (strategy === 'conservative' && successRate === 1.0) {
+            strategyBonus = 0.3; // Bonus for perfect reliability
+        } else if (strategy === 'balanced' && successRate > 0.5 && executionTime < 2000) {
+            strategyBonus = 0.25; // Bonus for good balance
+        }
+        const score = successRate * 60 + Math.max(0, 1 - executionTime / 5000) * 20 + strategyBonus * 20;
+        return {
+            executionTime,
+            successRate,
+            checks,
+            strategy,
+            score,
+            real: true
+        };
     }
-
-    const score =
-      successRate * 60 + Math.max(0, 1 - executionTime / 5000) * 20 + strategyBonus * 20;
-
-    return {
-      executionTime,
-      successRate,
-      checks,
-      strategy,
-      score,
-      real: true, // Mark as real execution
-    };
-  }
-
-  /**
+    /**
    * STAGE 3: Learn from Results
    * Updates profiles based on actual performance
-   */
-  async learnFromResults(results) {
-    console.log('\n🧠 Learning from results...');
-
-    // Load current agent profiles
-    let profiles = {};
-    try {
-      const data = await fs.readFile(this.agentProfiles, 'utf8');
-      profiles = JSON.parse(data);
-    } catch {
-      profiles = this.getDefaultProfiles();
-    }
-
-    // Analyze REAL results by strategy
-    const strategyPerformance = {};
-    for (const result of results) {
-      if (!strategyPerformance[result.strategy]) {
-        strategyPerformance[result.strategy] = {
-          totalScore: 0,
-          count: 0,
-          avgExecutionTime: 0,
-          successRate: 0,
-          realExecutions: 0,
+   */ async learnFromResults(results) {
+        console.log('\n🧠 Learning from results...');
+        // Load current agent profiles
+        let profiles = {};
+        try {
+            const data = await fs.readFile(this.agentProfiles, 'utf8');
+            profiles = JSON.parse(data);
+        } catch  {
+            profiles = this.getDefaultProfiles();
+        }
+        // Analyze REAL results by strategy
+        const strategyPerformance = {};
+        for (const result of results){
+            if (!strategyPerformance[result.strategy]) {
+                strategyPerformance[result.strategy] = {
+                    totalScore: 0,
+                    count: 0,
+                    avgExecutionTime: 0,
+                    successRate: 0,
+                    realExecutions: 0
+                };
+            }
+            const perf = strategyPerformance[result.strategy];
+            perf.totalScore += result.score;
+            perf.count++;
+            perf.avgExecutionTime += result.executionTime;
+            perf.successRate += result.successRate;
+            if (result.real) perf.realExecutions++;
+        }
+        // Calculate averages and update profiles with REAL data
+        for (const [strategy, perf] of Object.entries(strategyPerformance)){
+            perf.avgScore = perf.totalScore / perf.count;
+            perf.avgExecutionTime = perf.avgExecutionTime / perf.count;
+            perf.successRate = perf.successRate / perf.count;
+            // Update with stronger learning for real executions
+            const learningRate = perf.realExecutions > 0 ? 0.4 : 0.1;
+            this.updateAgentProfile(profiles, strategy, perf, learningRate);
+        }
+        // Save updated profiles
+        await fs.writeFile(this.agentProfiles, JSON.stringify(profiles, null, 2));
+        // Generate recommendations based on performance
+        const recommendations = this.generateRecommendations(strategyPerformance);
+        console.log('\n📊 Learning Results:');
+        for (const [strategy, perf] of Object.entries(strategyPerformance)){
+            console.log(`   ${strategy}: Score ${perf.avgScore.toFixed(2)}, Success ${(perf.successRate * 100).toFixed(1)}%, Time ${perf.avgExecutionTime.toFixed(0)}ms`);
+        }
+        return {
+            profiles,
+            recommendations
         };
-      }
-
-      const perf = strategyPerformance[result.strategy];
-      perf.totalScore += result.score;
-      perf.count++;
-      perf.avgExecutionTime += result.executionTime;
-      perf.successRate += result.successRate;
-      if (result.real) perf.realExecutions++;
     }
-
-    // Calculate averages and update profiles with REAL data
-    for (const [strategy, perf] of Object.entries(strategyPerformance)) {
-      perf.avgScore = perf.totalScore / perf.count;
-      perf.avgExecutionTime = perf.avgExecutionTime / perf.count;
-      perf.successRate = perf.successRate / perf.count;
-
-      // Update with stronger learning for real executions
-      const learningRate = perf.realExecutions > 0 ? 0.4 : 0.1;
-      this.updateAgentProfile(profiles, strategy, perf, learningRate);
-    }
-
-    // Save updated profiles
-    await fs.writeFile(this.agentProfiles, JSON.stringify(profiles, null, 2));
-
-    // Generate recommendations based on performance
-    const recommendations = this.generateRecommendations(strategyPerformance);
-
-    console.log('\n📊 Learning Results:');
-    for (const [strategy, perf] of Object.entries(strategyPerformance)) {
-      console.log(
-        `   ${strategy}: Score ${perf.avgScore.toFixed(2)}, Success ${(perf.successRate * 100).toFixed(1)}%, Time ${perf.avgExecutionTime.toFixed(0)}ms`,
-      );
-    }
-
-    return { profiles, recommendations };
-  }
-
-  updateAgentProfile(profiles, strategy, performance, learningRate = 0.3) {
-    if (!profiles[strategy]) {
-      profiles[strategy] = {
-        successRate: 0.5,
-        avgScore: 50,
-        avgExecutionTime: 2000,
-        uses: 0,
-        realExecutions: 0,
-      };
-    }
-
-    const profile = profiles[strategy];
-
-    // Update with exponential moving average
-    profile.successRate =
-      profile.successRate * (1 - learningRate) + performance.successRate * learningRate;
-    profile.avgScore = profile.avgScore * (1 - learningRate) + performance.avgScore * learningRate;
-    profile.avgExecutionTime =
-      profile.avgExecutionTime * (1 - learningRate) + performance.avgExecutionTime * learningRate;
-    profile.uses++;
-    if (performance.realExecutions) {
-      profile.realExecutions = (profile.realExecutions || 0) + performance.realExecutions;
-    }
-
-    // Add performance trend
-    if (!profile.trend) profile.trend = [];
-    profile.trend.push({
-      score: performance.avgScore,
-      timestamp: new Date().toISOString(),
-      real: performance.realExecutions > 0,
-    });
-    if (profile.trend.length > 20) {
-      profile.trend = profile.trend.slice(-20);
-    }
-
-    // Mark improvement
-    if (profile.trend.length > 1) {
-      const recent =
-        profile.trend.slice(-5).reduce((sum, t) => sum + t.score, 0) /
-        Math.min(5, profile.trend.length);
-      const older =
-        profile.trend.slice(0, -5).reduce((sum, t) => sum + t.score, 0) /
-        Math.max(1, profile.trend.length - 5);
-      profile.improving = recent > older;
-      profile.improvementRate = (((recent - older) / older) * 100).toFixed(1);
-    }
-  }
-
-  generateRecommendations(strategyPerformance) {
-    const recommendations = [];
-
-    for (const [strategy, perf] of Object.entries(strategyPerformance)) {
-      if (perf.successRate < 0.7) {
-        recommendations.push({
-          type: 'improve_reliability',
-          strategy,
-          action: `${strategy} needs better error handling (${(perf.successRate * 100).toFixed(1)}% success)`,
-          priority: 'high',
-        });
-      }
-
-      if (perf.avgExecutionTime > 3000) {
-        recommendations.push({
-          type: 'optimize_speed',
-          strategy,
-          action: `${strategy} is too slow (${perf.avgExecutionTime.toFixed(0)}ms avg)`,
-          priority: 'medium',
-        });
-      }
-
-      if (perf.avgScore > 75) {
-        recommendations.push({
-          type: 'good_performance',
-          strategy,
-          action: `${strategy} performing well (${perf.avgScore.toFixed(1)} score)`,
-          priority: 'info',
+    updateAgentProfile(profiles, strategy, performance, learningRate = 0.3) {
+        if (!profiles[strategy]) {
+            profiles[strategy] = {
+                successRate: 0.5,
+                avgScore: 50,
+                avgExecutionTime: 2000,
+                uses: 0,
+                realExecutions: 0
+            };
+        }
+        const profile = profiles[strategy];
+        // Update with exponential moving average
+        profile.successRate = profile.successRate * (1 - learningRate) + performance.successRate * learningRate;
+        profile.avgScore = profile.avgScore * (1 - learningRate) + performance.avgScore * learningRate;
+        profile.avgExecutionTime = profile.avgExecutionTime * (1 - learningRate) + performance.avgExecutionTime * learningRate;
+        profile.uses++;
+        if (performance.realExecutions) {
+            profile.realExecutions = (profile.realExecutions || 0) + performance.realExecutions;
+        }
+        // Add performance trend
+        if (!profile.trend) profile.trend = [];
+        profile.trend.push({
+            score: performance.avgScore,
+            timestamp: new Date().toISOString(),
+            real: performance.realExecutions > 0
         });
-      }
+        if (profile.trend.length > 20) {
+            profile.trend = profile.trend.slice(-20);
+        }
+        // Mark improvement
+        if (profile.trend.length > 1) {
+            const recent = profile.trend.slice(-5).reduce((sum, t)=>sum + t.score, 0) / Math.min(5, profile.trend.length);
+            const older = profile.trend.slice(0, -5).reduce((sum, t)=>sum + t.score, 0) / Math.max(1, profile.trend.length - 5);
+            profile.improving = recent > older;
+            profile.improvementRate = ((recent - older) / older * 100).toFixed(1);
+        }
     }
-
-    return recommendations;
-  }
-
-  /**
+    generateRecommendations(strategyPerformance) {
+        const recommendations = [];
+        for (const [strategy, perf] of Object.entries(strategyPerformance)){
+            if (perf.successRate < 0.7) {
+                recommendations.push({
+                    type: 'improve_reliability',
+                    strategy,
+                    action: `${strategy} needs better error handling (${(perf.successRate * 100).toFixed(1)}% success)`,
+                    priority: 'high'
+                });
+            }
+            if (perf.avgExecutionTime > 3000) {
+                recommendations.push({
+                    type: 'optimize_speed',
+                    strategy,
+                    action: `${strategy} is too slow (${perf.avgExecutionTime.toFixed(0)}ms avg)`,
+                    priority: 'medium'
+                });
+            }
+            if (perf.avgScore > 75) {
+                recommendations.push({
+                    type: 'good_performance',
+                    strategy,
+                    action: `${strategy} performing well (${perf.avgScore.toFixed(1)} score)`,
+                    priority: 'info'
+                });
+            }
+        }
+        return recommendations;
+    }
+    /**
    * Full Training Pipeline Execution
-   */
-  async runFullPipeline(options = {}) {
-    const { complexity = 'medium', iterations = 3, validate = true } = options;
-
-    console.log('🎯 Starting Training Pipeline');
-    console.log('━'.repeat(50));
-
-    await this.initialize();
-
-    // Capture baseline metrics
-    const baselineMetrics = await this.captureMetrics();
-
-    let cumulativeResults = [];
-
-    for (let i = 1; i <= iterations; i++) {
-      console.log(`\n📍 Iteration ${i}/${iterations}`);
-      console.log('─'.repeat(40));
-
-      // Stage 1: Generate tasks
-      const tasks = await this.generateTrainingTasks(complexity);
-
-      // Stage 2: Execute with real code
-      const results = await this.executeTrainingRun(tasks);
-      cumulativeResults = [...cumulativeResults, ...results];
-
-      // Stage 3: Learn from results
-      const { profiles, recommendations } = await this.learnFromResults(results);
-
-      // Show recommendations
-      if (recommendations.length > 0) {
-        console.log('\n💡 Recommendations:');
-        for (const rec of recommendations.slice(0, 3)) {
-          console.log(`   • ${rec.action}`);
+   */ async runFullPipeline(options = {}) {
+        const { complexity = 'medium', iterations = 3, validate = true } = options;
+        console.log('🎯 Starting Training Pipeline');
+        console.log('━'.repeat(50));
+        await this.initialize();
+        // Capture baseline metrics
+        const baselineMetrics = await this.captureMetrics();
+        let cumulativeResults = [];
+        for(let i = 1; i <= iterations; i++){
+            console.log(`\n📍 Iteration ${i}/${iterations}`);
+            console.log('─'.repeat(40));
+            // Stage 1: Generate tasks
+            const tasks = await this.generateTrainingTasks(complexity);
+            // Stage 2: Execute with real code
+            const results = await this.executeTrainingRun(tasks);
+            cumulativeResults = [
+                ...cumulativeResults,
+                ...results
+            ];
+            // Stage 3: Learn from results
+            const { profiles, recommendations } = await this.learnFromResults(results);
+            // Show recommendations
+            if (recommendations.length > 0) {
+                console.log('\n💡 Recommendations:');
+                for (const rec of recommendations.slice(0, 3)){
+                    console.log(`   • ${rec.action}`);
+                }
+            }
+            // Stage 4: Validate if enabled
+            if (validate && i === iterations) {
+                const currentMetrics = await this.captureMetrics();
+                const validation = await this.validateImprovements(baselineMetrics, currentMetrics);
+                if (validation.summary.overallImprovement) {
+                    console.log('✅ Improvement detected!');
+                } else {
+                    console.log('⚠️  More training needed for significant improvement');
+                }
+            }
         }
-      }
-
-      // Stage 4: Validate if enabled
-      if (validate && i === iterations) {
-        const currentMetrics = await this.captureMetrics();
-        const validation = await this.validateImprovements(baselineMetrics, currentMetrics);
-
-        if (validation.summary.overallImprovement) {
-          console.log('✅ Improvement detected!');
-        } else {
-          console.log('⚠️  More training needed for significant improvement');
+        // Generate final report
+        const report = await this.generateFinalReport(cumulativeResults);
+        console.log('\n' + report);
+        return {
+            success: true,
+            totalTasks: cumulativeResults.length,
+            realExecutions: cumulativeResults.filter((r)=>r.real).length,
+            improvements: await this.calculateOverallImprovement(baselineMetrics)
+        };
+    }
+    // Reuse helper methods from original
+    async captureMetrics() {
+        try {
+            const data = await fs.readFile(this.agentProfiles, 'utf8');
+            const profiles = JSON.parse(data);
+            // Calculate weighted average from all strategies
+            let totalScore = 0;
+            let totalSuccess = 0;
+            let totalTime = 0;
+            let count = 0;
+            for (const profile of Object.values(profiles)){
+                if (profile.uses > 0) {
+                    totalScore += profile.avgScore;
+                    totalSuccess += profile.successRate;
+                    totalTime += profile.avgExecutionTime;
+                    count++;
+                }
+            }
+            return {
+                successRate: count > 0 ? totalSuccess / count : 0,
+                executionTime: count > 0 ? totalTime / count : 0,
+                score: count > 0 ? totalScore / count : 0
+            };
+        } catch  {
+            return {
+                successRate: 0,
+                executionTime: 0,
+                score: 0
+            };
         }
-      }
     }
-
-    // Generate final report
-    const report = await this.generateFinalReport(cumulativeResults);
-    console.log('\n' + report);
-
-    return {
-      success: true,
-      totalTasks: cumulativeResults.length,
-      realExecutions: cumulativeResults.filter((r) => r.real).length,
-      improvements: await this.calculateOverallImprovement(baselineMetrics),
-    };
-  }
-
-  // Reuse helper methods from original
-  async captureMetrics() {
-    try {
-      const data = await fs.readFile(this.agentProfiles, 'utf8');
-      const profiles = JSON.parse(data);
-
-      // Calculate weighted average from all strategies
-      let totalScore = 0;
-      let totalSuccess = 0;
-      let totalTime = 0;
-      let count = 0;
-
-      for (const profile of Object.values(profiles)) {
-        if (profile.uses > 0) {
-          totalScore += profile.avgScore;
-          totalSuccess += profile.successRate;
-          totalTime += profile.avgExecutionTime;
-          count++;
+    async validateImprovements(beforeMetrics, afterMetrics) {
+        const validation = {
+            improved: [],
+            declined: [],
+            unchanged: [],
+            summary: {}
+        };
+        const metrics = [
+            'successRate',
+            'executionTime',
+            'score'
+        ];
+        for (const metric of metrics){
+            const before = beforeMetrics[metric] || 0.01; // Avoid division by zero
+            const after = afterMetrics[metric] || 0;
+            const change = after - before;
+            const percentChange = change / before * 100;
+            if (percentChange > 5) {
+                validation.improved.push({
+                    metric,
+                    change: percentChange
+                });
+            } else if (percentChange < -5) {
+                validation.declined.push({
+                    metric,
+                    change: percentChange
+                });
+            } else {
+                validation.unchanged.push({
+                    metric,
+                    change: percentChange
+                });
+            }
         }
-      }
-
-      return {
-        successRate: count > 0 ? totalSuccess / count : 0,
-        executionTime: count > 0 ? totalTime / count : 0,
-        score: count > 0 ? totalScore / count : 0,
-      };
-    } catch {
-      return {
-        successRate: 0,
-        executionTime: 0,
-        score: 0,
-      };
+        validation.summary = {
+            overallImprovement: validation.improved.length > validation.declined.length,
+            improvementScore: validation.improved.length - validation.declined.length,
+            timestamp: new Date().toISOString()
+        };
+        console.log(`\n✅ Validating improvements...`);
+        console.log(`   Improved: ${validation.improved.length} metrics`);
+        console.log(`   Declined: ${validation.declined.length} metrics`);
+        console.log(`   Unchanged: ${validation.unchanged.length} metrics`);
+        return validation;
     }
-  }
-
-  async validateImprovements(beforeMetrics, afterMetrics) {
-    const validation = {
-      improved: [],
-      declined: [],
-      unchanged: [],
-      summary: {},
-    };
-
-    const metrics = ['successRate', 'executionTime', 'score'];
-
-    for (const metric of metrics) {
-      const before = beforeMetrics[metric] || 0.01; // Avoid division by zero
-      const after = afterMetrics[metric] || 0;
-      const change = after - before;
-      const percentChange = (change / before) * 100;
-
-      if (percentChange > 5) {
-        validation.improved.push({ metric, change: percentChange });
-      } else if (percentChange < -5) {
-        validation.declined.push({ metric, change: percentChange });
-      } else {
-        validation.unchanged.push({ metric, change: percentChange });
-      }
+    async calculateOverallImprovement(baselineMetrics) {
+        const currentMetrics = await this.captureMetrics();
+        const base = {
+            successRate: baselineMetrics.successRate || 0.01,
+            executionTime: baselineMetrics.executionTime || 1,
+            score: baselineMetrics.score || 0.01
+        };
+        return {
+            successRate: (currentMetrics.successRate - base.successRate) / base.successRate * 100,
+            executionTime: (base.executionTime - currentMetrics.executionTime) / base.executionTime * 100,
+            score: (currentMetrics.score - base.score) / base.score * 100
+        };
     }
-
-    validation.summary = {
-      overallImprovement: validation.improved.length > validation.declined.length,
-      improvementScore: validation.improved.length - validation.declined.length,
-      timestamp: new Date().toISOString(),
-    };
-
-    console.log(`\n✅ Validating improvements...`);
-    console.log(`   Improved: ${validation.improved.length} metrics`);
-    console.log(`   Declined: ${validation.declined.length} metrics`);
-    console.log(`   Unchanged: ${validation.unchanged.length} metrics`);
-
-    return validation;
-  }
-
-  async calculateOverallImprovement(baselineMetrics) {
-    const currentMetrics = await this.captureMetrics();
-
-    const base = {
-      successRate: baselineMetrics.successRate || 0.01,
-      executionTime: baselineMetrics.executionTime || 1,
-      score: baselineMetrics.score || 0.01,
-    };
-
-    return {
-      successRate: ((currentMetrics.successRate - base.successRate) / base.successRate) * 100,
-      executionTime:
-        ((base.executionTime - currentMetrics.executionTime) / base.executionTime) * 100,
-      score: ((currentMetrics.score - base.score) / base.score) * 100,
-    };
-  }
-
-  async generateFinalReport(results) {
-    const realResults = results.filter((r) => r.real);
-    const successRates = {};
-    const scores = {};
-    const times = {};
-
-    for (const result of realResults) {
-      if (!successRates[result.strategy]) {
-        successRates[result.strategy] = [];
-        scores[result.strategy] = [];
-        times[result.strategy] = [];
-      }
-      successRates[result.strategy].push(result.successRate);
-      scores[result.strategy].push(result.score);
-      times[result.strategy].push(result.executionTime);
+    async generateFinalReport(results) {
+        const realResults = results.filter((r)=>r.real);
+        const successRates = {};
+        const scores = {};
+        const times = {};
+        for (const result of realResults){
+            if (!successRates[result.strategy]) {
+                successRates[result.strategy] = [];
+                scores[result.strategy] = [];
+                times[result.strategy] = [];
+            }
+            successRates[result.strategy].push(result.successRate);
+            scores[result.strategy].push(result.score);
+            times[result.strategy].push(result.executionTime);
+        }
+        let report = '📊 Training Pipeline Report\n';
+        report += '━'.repeat(50) + '\n\n';
+        for (const strategy of Object.keys(successRates)){
+            const avgSuccess = successRates[strategy].reduce((a, b)=>a + b, 0) / successRates[strategy].length;
+            const avgScore = scores[strategy].reduce((a, b)=>a + b, 0) / scores[strategy].length;
+            const avgTime = times[strategy].reduce((a, b)=>a + b, 0) / times[strategy].length;
+            report += `Strategy: ${strategy}\n`;
+            report += `  Average Success Rate: ${(avgSuccess * 100).toFixed(1)}%\n`;
+            report += `  Average Score: ${avgScore.toFixed(2)}\n`;
+            report += `  Average Time: ${avgTime.toFixed(0)}ms\n`;
+            report += `  Real Executions: ${successRates[strategy].length}\n`;
+            report += '\n';
+        }
+        return report;
     }
-
-    let report = '📊 Training Pipeline Report\n';
-    report += '━'.repeat(50) + '\n\n';
-
-    for (const strategy of Object.keys(successRates)) {
-      const avgSuccess =
-        successRates[strategy].reduce((a, b) => a + b, 0) / successRates[strategy].length;
-      const avgScore = scores[strategy].reduce((a, b) => a + b, 0) / scores[strategy].length;
-      const avgTime = times[strategy].reduce((a, b) => a + b, 0) / times[strategy].length;
-
-      report += `Strategy: ${strategy}\n`;
-      report += `  Average Success Rate: ${(avgSuccess * 100).toFixed(1)}%\n`;
-      report += `  Average Score: ${avgScore.toFixed(2)}\n`;
-      report += `  Average Time: ${avgTime.toFixed(0)}ms\n`;
-      report += `  Real Executions: ${successRates[strategy].length}\n`;
-      report += '\n';
+    getDefaultProfiles() {
+        return {
+            conservative: {
+                successRate: 0.5,
+                avgScore: 50,
+                avgExecutionTime: 3000,
+                uses: 0,
+                realExecutions: 0
+            },
+            balanced: {
+                successRate: 0.5,
+                avgScore: 50,
+                avgExecutionTime: 2000,
+                uses: 0,
+                realExecutions: 0
+            },
+            aggressive: {
+                successRate: 0.5,
+                avgScore: 50,
+                avgExecutionTime: 1000,
+                uses: 0,
+                realExecutions: 0
+            }
+        };
     }
-
-    return report;
-  }
-
-  getDefaultProfiles() {
-    return {
-      conservative: {
-        successRate: 0.5,
-        avgScore: 50,
-        avgExecutionTime: 3000,
-        uses: 0,
-        realExecutions: 0,
-      },
-      balanced: {
-        successRate: 0.5,
-        avgScore: 50,
-        avgExecutionTime: 2000,
-        uses: 0,
-        realExecutions: 0,
-      },
-      aggressive: {
-        successRate: 0.5,
-        avgScore: 50,
-        avgExecutionTime: 1000,
-        uses: 0,
-        realExecutions: 0,
-      },
-    };
-  }
-
-  async loadPipelineConfig() {
-    try {
-      const data = await fs.readFile(this.pipelineConfig, 'utf8');
-      return JSON.parse(data);
-    } catch {
-      const defaultConfig = {
-        version: '2.0.0',
-        strategies: ['conservative', 'balanced', 'aggressive'],
-        learningRate: 0.4,
-        minSamplesForUpdate: 3,
-        useRealExecution: true,
-        created: new Date().toISOString(),
-      };
-
-      await fs.writeFile(this.pipelineConfig, JSON.stringify(defaultConfig, null, 2));
-      return defaultConfig;
+    async loadPipelineConfig() {
+        try {
+            const data = await fs.readFile(this.pipelineConfig, 'utf8');
+            return JSON.parse(data);
+        } catch  {
+            const defaultConfig = {
+                version: '2.0.0',
+                strategies: [
+                    'conservative',
+                    'balanced',
+                    'aggressive'
+                ],
+                learningRate: 0.4,
+                minSamplesForUpdate: 3,
+                useRealExecution: true,
+                created: new Date().toISOString()
+            };
+            await fs.writeFile(this.pipelineConfig, JSON.stringify(defaultConfig, null, 2));
+            return defaultConfig;
+        }
+    }
+    constructor(){
+        this.pipelineConfig = '.claude-flow/pipeline-config.json';
+        this.trainingLog = '.claude-flow/training/pipeline-log.jsonl';
+        this.improvementMetrics = '.claude-flow/metrics/improvements.json';
+        this.agentProfiles = '.claude-flow/agents/profiles.json';
+        this.realTasksDir = '.claude-flow/training/real-tasks';
+        this.initialized = false;
     }
-  }
 }
-
 /**
  * CLI Command Handler
- */
-export async function trainingPipelineCommand(args, flags) {
-  const pipeline = new TrainingPipeline();
-  const subcommand = args[0] || 'run';
-
-  switch (subcommand) {
-    case 'run':
-      // Run real pipeline
-      const options = {
-        complexity: flags.complexity || 'medium',
-        iterations: parseInt(flags.iterations) || 3,
-        validate: flags.validate !== false,
-      };
-
-      console.log('🚀 Starting Training Pipeline');
-      console.log(`   Complexity: ${options.complexity}`);
-      console.log(`   Iterations: ${options.iterations}`);
-      console.log(`   Validation: ${options.validate ? 'Enabled' : 'Disabled'}`);
-
-      const result = await pipeline.runFullPipeline(options);
-
-      if (result.success) {
-        console.log('\n✅ Training Pipeline completed');
-        console.log(`   Total tasks: ${result.totalTasks}`);
-        console.log(`   Real executions: ${result.realExecutions}`);
-
-        if (result.improvements) {
-          console.log('\n📈 Improvements:');
-          console.log(
-            `   Success Rate: ${result.improvements.successRate > 0 ? '+' : ''}${result.improvements.successRate.toFixed(1)}%`,
-          );
-          console.log(
-            `   Execution Time: ${result.improvements.executionTime > 0 ? '+' : ''}${result.improvements.executionTime.toFixed(1)}%`,
-          );
-          console.log(
-            `   Score: ${result.improvements.score > 0 ? '+' : ''}${result.improvements.score.toFixed(1)}%`,
-          );
-        }
-      }
-      break;
-
-    case 'status':
-      // Show real pipeline status
-      await pipeline.initialize();
-
-      let profiles = {};
-      try {
-        const data = await fs.readFile(pipeline.agentProfiles, 'utf8');
-        profiles = JSON.parse(data);
-      } catch {
-        profiles = pipeline.getDefaultProfiles();
-      }
-
-      console.log('\n📊 Training Pipeline Status');
-      console.log('━'.repeat(50));
-
-      console.log('\n🤖 Strategy Profiles:');
-      for (const [strategy, profile] of Object.entries(profiles)) {
-        console.log(`   ${strategy}:`);
-        console.log(`     Success Rate: ${(profile.successRate * 100).toFixed(1)}%`);
-        console.log(`     Average Score: ${profile.avgScore.toFixed(2)}`);
-        console.log(`     Execution Time: ${profile.avgExecutionTime.toFixed(0)}ms`);
-        console.log(`     Total Uses: ${profile.uses}`);
-        console.log(`     Real Executions: ${profile.realExecutions || 0}`);
-        if (profile.improving !== undefined) {
-          console.log(
-            `     Trend: ${profile.improving ? '📈 Improving' : '📉 Declining'} (${profile.improvementRate}%)`,
-          );
-        }
-      }
-      break;
-
-    case 'validate':
-      // Validate current performance
-      await pipeline.initialize();
-      const metrics = await pipeline.captureMetrics();
-      console.log('\n📊 Current Performance:');
-      console.log(`   Success Rate: ${(metrics.successRate * 100).toFixed(1)}%`);
-      console.log(`   Avg Execution Time: ${metrics.executionTime.toFixed(0)}ms`);
-      console.log(`   Average Score: ${metrics.score.toFixed(2)}`);
-      break;
-
-    default:
-      console.log('Usage: train-pipeline <command> [options]');
-      console.log('\nCommands:');
-      console.log('  run       - Run training pipeline with real code');
-      console.log('  status    - Show pipeline status');
-      console.log('  validate  - Check current performance');
-      console.log('\nOptions:');
-      console.log('  --complexity <level>  - easy/medium/hard');
-      console.log('  --iterations <n>      - Training cycles');
-  }
+ */ export async function trainingPipelineCommand(args, flags) {
+    const pipeline = new TrainingPipeline();
+    const subcommand = args[0] || 'run';
+    switch(subcommand){
+        case 'run':
+            // Run real pipeline
+            const options = {
+                complexity: flags.complexity || 'medium',
+                iterations: parseInt(flags.iterations) || 3,
+                validate: flags.validate !== false
+            };
+            console.log('🚀 Starting Training Pipeline');
+            console.log(`   Complexity: ${options.complexity}`);
+            console.log(`   Iterations: ${options.iterations}`);
+            console.log(`   Validation: ${options.validate ? 'Enabled' : 'Disabled'}`);
+            const result = await pipeline.runFullPipeline(options);
+            if (result.success) {
+                console.log('\n✅ Training Pipeline completed');
+                console.log(`   Total tasks: ${result.totalTasks}`);
+                console.log(`   Real executions: ${result.realExecutions}`);
+                if (result.improvements) {
+                    console.log('\n📈 Improvements:');
+                    console.log(`   Success Rate: ${result.improvements.successRate > 0 ? '+' : ''}${result.improvements.successRate.toFixed(1)}%`);
+                    console.log(`   Execution Time: ${result.improvements.executionTime > 0 ? '+' : ''}${result.improvements.executionTime.toFixed(1)}%`);
+                    console.log(`   Score: ${result.improvements.score > 0 ? '+' : ''}${result.improvements.score.toFixed(1)}%`);
+                }
+            }
+            break;
+        case 'status':
+            // Show real pipeline status
+            await pipeline.initialize();
+            let profiles = {};
+            try {
+                const data = await fs.readFile(pipeline.agentProfiles, 'utf8');
+                profiles = JSON.parse(data);
+            } catch  {
+                profiles = pipeline.getDefaultProfiles();
+            }
+            console.log('\n📊 Training Pipeline Status');
+            console.log('━'.repeat(50));
+            console.log('\n🤖 Strategy Profiles:');
+            for (const [strategy, profile] of Object.entries(profiles)){
+                console.log(`   ${strategy}:`);
+                console.log(`     Success Rate: ${(profile.successRate * 100).toFixed(1)}%`);
+                console.log(`     Average Score: ${profile.avgScore.toFixed(2)}`);
+                console.log(`     Execution Time: ${profile.avgExecutionTime.toFixed(0)}ms`);
+                console.log(`     Total Uses: ${profile.uses}`);
+                console.log(`     Real Executions: ${profile.realExecutions || 0}`);
+                if (profile.improving !== undefined) {
+                    console.log(`     Trend: ${profile.improving ? '📈 Improving' : '📉 Declining'} (${profile.improvementRate}%)`);
+                }
+            }
+            break;
+        case 'validate':
+            // Validate current performance
+            await pipeline.initialize();
+            const metrics = await pipeline.captureMetrics();
+            console.log('\n📊 Current Performance:');
+            console.log(`   Success Rate: ${(metrics.successRate * 100).toFixed(1)}%`);
+            console.log(`   Avg Execution Time: ${metrics.executionTime.toFixed(0)}ms`);
+            console.log(`   Average Score: ${metrics.score.toFixed(2)}`);
+            break;
+        default:
+            console.log('Usage: train-pipeline <command> [options]');
+            console.log('\nCommands:');
+            console.log('  run       - Run training pipeline with real code');
+            console.log('  status    - Show pipeline status');
+            console.log('  validate  - Check current performance');
+            console.log('\nOptions:');
+            console.log('  --complexity <level>  - easy/medium/hard');
+            console.log('  --iterations <n>      - Training cycles');
+    }
 }
-
 export default TrainingPipeline;