claude-flow-novice 2.0.4 → 2.0.5

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

@@ -2,60 +2,77 @@
 /**
  * Training Pipeline with Real Task Execution
  * Executes actual code and learns from real test results
- */ import fs from "node:fs/promises";
-import path from "path";
-import { execSync } from "child_process";
-import { promisify } from "util";
-import { exec } from "child_process";
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { execSync, spawn } 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 {
-    /**
+ */
+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;
+  }
+
+  /**
    * 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
-            });
-        }
-        // Load or create pipeline configuration
-        await this.loadPipelineConfig();
-        console.log('🚀 Training Pipeline initialized');
-        this.initialized = 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;
+  }
+
+  /**
    * 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', () => {
@@ -67,15 +84,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();
 
@@ -99,7 +116,7 @@ app.post('/users', (req, res) => {
 
 module.exports = app;
 `,
-                    test: `
+          test: `
 const request = require('supertest');
 const app = require('./index');
 
@@ -118,15 +135,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;
   
@@ -161,7 +178,7 @@ function mergeSort(arr) {
 
 module.exports = { quickSort, mergeSort };
 `,
-                    test: `
+          test: `
 const { quickSort, mergeSort } = require('./index');
 
 describe('Sorting Algorithms', () => {
@@ -181,588 +198,677 @@ 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
-            });
-        }
-        console.log(`📝 Generated ${realTasks.length} ${complexity} training tasks`);
-        return realTasks;
+`,
+        },
+      ],
+    };
+
+    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;
+  }
+
+  /**
    * 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()
-                });
-            }
-        }
-        // Save real results
-        const resultsFile = `.claude-flow/training/real-results-${Date.now()}.json`;
-        await fs.writeFile(resultsFile, JSON.stringify(results, null, 2));
-        return results;
+   */
+  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;
+  }
+
+  /**
    * 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
-        }
-        const score = successRate * 60 + Math.max(0, 1 - executionTime / 5000) * 20 + strategyBonus * 20;
-        return {
-            executionTime,
-            successRate,
-            checks,
-            strategy,
-            score,
-            real: true
-        };
+   */
+  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, // 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
-                };
-            }
-            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
+   */
+  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++;
     }
-    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);
-        }
+
+    // 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);
     }
-    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;
+
+    // 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`,
+      );
     }
-    /**
-   * 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}`);
-                }
-            }
-            // 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)
-        };
+
+    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,
+      };
     }
-    // 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
-            };
-        }
+
+    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;
     }
-    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
-                });
-            }
-        }
-        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;
+
+    // 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);
     }
-    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
-        };
+
+    // 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',
+        });
+      }
     }
-    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);
+
+    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}`);
         }
-        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';
+      }
+
+      // 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');
         }
-        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;
+
+    // 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,
+      };
+    }
+  }
+
+  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 });
+      }
+    }
+
+    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);
     }
-    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;
+
+    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;
+  }
+
+  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;
+    }
+  }
 }
+
 /**
  * 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;