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

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

@@ -1,221 +1,246 @@
-import { printSuccess, printError, printWarning, trainNeuralModel, updateNeuralPattern, callRuvSwarmMCP, checkRuvSwarmAvailable } from "../utils.js";
+import {
+  printSuccess,
+  printError,
+  printWarning,
+  trainNeuralModel,
+  updateNeuralPattern,
+  callRuvSwarmMCP,
+  checkRuvSwarmAvailable,
+} from '../utils.js';
 
 export async function trainingAction(subArgs, flags) {
-    const subcommand = subArgs[0];
-    const options = flags;
+  const subcommand = subArgs[0];
+  const options = flags;
 
-    if (options.help || options.h || !subcommand) {
-        showTrainingHelp();
-        return;
-    }
+  if (options.help || options.h || !subcommand) {
+    showTrainingHelp();
+    return;
+  }
 
-    try {
-        switch (subcommand) {
-            case 'neural-train':
-                await neuralTrainCommand(subArgs, flags);
-                break;
-            case 'pattern-learn':
-                await patternLearnCommand(subArgs, flags);
-                break;
-            case 'model-update':
-                await modelUpdateCommand(subArgs, flags);
-                break;
-            default:
-                printError(`Unknown training command: ${subcommand}`);
-                showTrainingHelp();
-        }
-    } catch (err) {
-        printError(`Training command failed: ${err.message}`);
+  try {
+    switch (subcommand) {
+      case 'neural-train':
+        await neuralTrainCommand(subArgs, flags);
+        break;
+      case 'pattern-learn':
+        await patternLearnCommand(subArgs, flags);
+        break;
+      case 'model-update':
+        await modelUpdateCommand(subArgs, flags);
+        break;
+      default:
+        printError(`Unknown training command: ${subcommand}`);
+        showTrainingHelp();
     }
+  } catch (err) {
+    printError(`Training command failed: ${err.message}`);
+  }
 }
 
 async function neuralTrainCommand(subArgs, flags) {
-    const options = flags;
-    const data = options.data || 'recent';
-    const model = options.model || 'general-predictor';
-    const epochs = parseInt(options.epochs || '50');
-
-    console.log(`🧠 Starting neural training...`);
-    console.log(`📊 Data source: ${data}`);
-    console.log(`🤖 Target model: ${model}`);
-    console.log(`🔄 Training epochs: ${epochs}`);
-
-    // Check if ruv-swarm is available
-    const isAvailable = await checkRuvSwarmAvailable();
-    if (!isAvailable) {
-        printError('ruv-swarm is not available. Please install it with: npm install -g ruv-swarm');
-        return;
-    }
+  const options = flags;
+  const data = options.data || 'recent';
+  const model = options.model || 'general-predictor';
+  const epochs = parseInt(options.epochs || '50');
 
-    try {
-        console.log(`\n🔄 Executing REAL ruv-swarm neural training with WASM acceleration...`);
-        console.log(`🎯 Model: ${model} | Data: ${data} | Epochs: ${epochs}`);
-        console.log(`🚀 This will use actual neural networks, not simulation!\n`);
-        
-        // Use REAL ruv-swarm neural training - no artificial delays
-        const trainingResult = await trainNeuralModel(model, data, epochs);
-        
-        if (trainingResult.success) {
-            if (trainingResult.real_training) {
-                printSuccess(`✅ REAL neural training completed successfully with ruv-swarm WASM!`);
-                console.log(`🧠 WASM-accelerated training: ${trainingResult.wasm_accelerated ? 'ENABLED' : 'DISABLED'}`);
-            } else {
-                printSuccess(`✅ Neural training completed successfully`);
-            }
-            
-            console.log(`📈 Model '${model}' updated with ${data} data`);
-            console.log(`🧠 Training metrics:`);
-            console.log(`  • Epochs completed: ${trainingResult.epochs || epochs}`);
-            
-            // Use real accuracy from ruv-swarm
-            const accuracy = trainingResult.accuracy || (0.65 + (Math.min(epochs/100, 1) * 0.3) + Math.random() * 0.05);
-            console.log(`  • Final accuracy: ${(accuracy * 100).toFixed(1)}%`);
-            
-            // Use real training time from ruv-swarm
-            const trainingTime = trainingResult.training_time || Math.max(epochs * 0.1, 2);
-            console.log(`  • Training time: ${trainingTime.toFixed(1)}s`);
-            
-            console.log(`  • Model ID: ${trainingResult.modelId || `${model}_${Date.now()}`}`);
-            console.log(`  • Improvement rate: ${trainingResult.improvement_rate || (epochs > 100 ? 'converged' : 'improving')}`);
-            
-            if (trainingResult.real_training) {
-                console.log(`  • WASM acceleration: ✅ ENABLED`);
-                console.log(`  • Real neural training: ✅ CONFIRMED`);
-                if (trainingResult.ruv_swarm_output) {
-                    console.log(`  • ruv-swarm status: Training completed successfully`);
-                }
-            }
-            
-            console.log(`💾 Training results saved: ${trainingResult.outputPath || 'Neural memory updated'}`);
-        } else {
-            printError(`Neural training failed: ${trainingResult.error || 'Unknown error'}`);
-        }
-    } catch (err) {
-        printError(`Neural training failed: ${err.message}`);
-        console.log('Falling back to local simulation mode...');
-        
-        // Fallback to basic simulation if ruv-swarm fails
-        for (let i = 1; i <= Math.min(epochs, 3); i++) {
-            console.log(`  Epoch ${i}/${epochs}: Training... (fallback mode)`);
-            await new Promise(resolve => setTimeout(resolve, 200));
+  console.log(`🧠 Starting neural training...`);
+  console.log(`📊 Data source: ${data}`);
+  console.log(`🤖 Target model: ${model}`);
+  console.log(`🔄 Training epochs: ${epochs}`);
+
+  // Check if ruv-swarm is available
+  const isAvailable = await checkRuvSwarmAvailable();
+  if (!isAvailable) {
+    printError('ruv-swarm is not available. Please install it with: npm install -g ruv-swarm');
+    return;
+  }
+
+  try {
+    console.log(`\n🔄 Executing REAL ruv-swarm neural training with WASM acceleration...`);
+    console.log(`🎯 Model: ${model} | Data: ${data} | Epochs: ${epochs}`);
+    console.log(`🚀 This will use actual neural networks, not simulation!\n`);
+
+    // Use REAL ruv-swarm neural training - no artificial delays
+    const trainingResult = await trainNeuralModel(model, data, epochs);
+
+    if (trainingResult.success) {
+      if (trainingResult.real_training) {
+        printSuccess(`✅ REAL neural training completed successfully with ruv-swarm WASM!`);
+        console.log(
+          `🧠 WASM-accelerated training: ${trainingResult.wasm_accelerated ? 'ENABLED' : 'DISABLED'}`,
+        );
+      } else {
+        printSuccess(`✅ Neural training completed successfully`);
+      }
+
+      console.log(`📈 Model '${model}' updated with ${data} data`);
+      console.log(`🧠 Training metrics:`);
+      console.log(`  • Epochs completed: ${trainingResult.epochs || epochs}`);
+
+      // Use real accuracy from ruv-swarm
+      const accuracy =
+        trainingResult.accuracy || 0.65 + Math.min(epochs / 100, 1) * 0.3 + Math.random() * 0.05;
+      console.log(`  • Final accuracy: ${(accuracy * 100).toFixed(1)}%`);
+
+      // Use real training time from ruv-swarm
+      const trainingTime = trainingResult.training_time || Math.max(epochs * 0.1, 2);
+      console.log(`  • Training time: ${trainingTime.toFixed(1)}s`);
+
+      console.log(`  • Model ID: ${trainingResult.modelId || `${model}_${Date.now()}`}`);
+      console.log(
+        `  • Improvement rate: ${trainingResult.improvement_rate || (epochs > 100 ? 'converged' : 'improving')}`,
+      );
+
+      if (trainingResult.real_training) {
+        console.log(`  • WASM acceleration: ✅ ENABLED`);
+        console.log(`  • Real neural training: ✅ CONFIRMED`);
+        if (trainingResult.ruv_swarm_output) {
+          console.log(`  • ruv-swarm status: Training completed successfully`);
         }
-        printSuccess(`✅ Neural training completed (fallback mode)`);
+      }
+
+      console.log(
+        `💾 Training results saved: ${trainingResult.outputPath || 'Neural memory updated'}`,
+      );
+    } else {
+      printError(`Neural training failed: ${trainingResult.error || 'Unknown error'}`);
+    }
+  } catch (err) {
+    printError(`Neural training failed: ${err.message}`);
+    console.log('Falling back to local simulation mode...');
+
+    // Fallback to basic simulation if ruv-swarm fails
+    for (let i = 1; i <= Math.min(epochs, 3); i++) {
+      console.log(`  Epoch ${i}/${epochs}: Training... (fallback mode)`);
+      await new Promise((resolve) => setTimeout(resolve, 200));
     }
+    printSuccess(`✅ Neural training completed (fallback mode)`);
+  }
 }
 
 async function patternLearnCommand(subArgs, flags) {
-    const options = flags;
-    const operation = options.operation || 'unknown';
-    const outcome = options.outcome || 'success';
-
-    console.log(`🔍 Learning from operation pattern...`);
-    console.log(`⚙️  Operation: ${operation}`);
-    console.log(`📊 Outcome: ${outcome}`);
-
-    // Check if ruv-swarm is available
-    const isAvailable = await checkRuvSwarmAvailable();
-    if (!isAvailable) {
-        printError('ruv-swarm is not available. Please install it with: npm install -g ruv-swarm');
-        return;
-    }
+  const options = flags;
+  const operation = options.operation || 'unknown';
+  const outcome = options.outcome || 'success';
 
-    try {
-        console.log(`\n🧠 Updating neural patterns with ruv-swarm...`);
-        
-        // Use real ruv-swarm pattern learning
-        const metadata = {
-            timestamp: Date.now(),
-            environment: 'claude-flow',
-            version: '2.0.0'
-        };
-        
-        const patternResult = await updateNeuralPattern(operation, outcome, metadata);
-        
-        if (patternResult.success) {
-            printSuccess(`✅ Pattern learning completed`);
-            console.log(`🧠 Updated neural patterns for operation: ${operation}`);
-            console.log(`📈 Outcome '${outcome}' integrated into prediction model`);
-            console.log(`🔍 Pattern insights:`);
-            console.log(`  • Confidence: ${patternResult.confidence || patternResult.pattern_confidence || '87.3%'}`);
-            console.log(`  • Similar patterns: ${patternResult.similarPatterns || patternResult.patterns_detected?.coordination_patterns || '5'}`);
-            console.log(`  • Prediction improvement: ${patternResult.improvement || '+12.5%'}`);
-            console.log(`  • Processing time: ${patternResult.processing_time_ms || '85'}ms`);
-        } else {
-            printError(`Pattern learning failed: ${patternResult.error || 'Unknown error'}`);
-        }
-    } catch (err) {
-        printError(`Pattern learning failed: ${err.message}`);
-        console.log('Operation logged for future training.');
+  console.log(`🔍 Learning from operation pattern...`);
+  console.log(`⚙️  Operation: ${operation}`);
+  console.log(`📊 Outcome: ${outcome}`);
+
+  // Check if ruv-swarm is available
+  const isAvailable = await checkRuvSwarmAvailable();
+  if (!isAvailable) {
+    printError('ruv-swarm is not available. Please install it with: npm install -g ruv-swarm');
+    return;
+  }
+
+  try {
+    console.log(`\n🧠 Updating neural patterns with ruv-swarm...`);
+
+    // Use real ruv-swarm pattern learning
+    const metadata = {
+      timestamp: Date.now(),
+      environment: 'claude-flow',
+      version: '2.0.0',
+    };
+
+    const patternResult = await updateNeuralPattern(operation, outcome, metadata);
+
+    if (patternResult.success) {
+      printSuccess(`✅ Pattern learning completed`);
+      console.log(`🧠 Updated neural patterns for operation: ${operation}`);
+      console.log(`📈 Outcome '${outcome}' integrated into prediction model`);
+      console.log(`🔍 Pattern insights:`);
+      console.log(
+        `  • Confidence: ${patternResult.confidence || patternResult.pattern_confidence || '87.3%'}`,
+      );
+      console.log(
+        `  • Similar patterns: ${patternResult.similarPatterns || patternResult.patterns_detected?.coordination_patterns || '5'}`,
+      );
+      console.log(`  • Prediction improvement: ${patternResult.improvement || '+12.5%'}`);
+      console.log(`  • Processing time: ${patternResult.processing_time_ms || '85'}ms`);
+    } else {
+      printError(`Pattern learning failed: ${patternResult.error || 'Unknown error'}`);
     }
+  } catch (err) {
+    printError(`Pattern learning failed: ${err.message}`);
+    console.log('Operation logged for future training.');
+  }
 }
 
 async function modelUpdateCommand(subArgs, flags) {
-    const options = flags;
-    const agentType = options['agent-type'] || options.agentType || 'general';
-    const result = options['operation-result'] || options.result || 'success';
-
-    console.log(`🔄 Updating agent model...`);
-    console.log(`🤖 Agent type: ${agentType}`);
-    console.log(`📊 Operation result: ${result}`);
-
-    // Check if ruv-swarm is available
-    const isAvailable = await checkRuvSwarmAvailable();
-    if (!isAvailable) {
-        printError('ruv-swarm is not available. Please install it with: npm install -g ruv-swarm');
-        return;
-    }
+  const options = flags;
+  const agentType = options['agent-type'] || options.agentType || 'general';
+  const result = options['operation-result'] || options.result || 'success';
 
-    try {
-        console.log(`\n🤖 Updating agent model with ruv-swarm...`);
-        
-        // Use real ruv-swarm model update via learning adaptation
-        const updateResult = await callRuvSwarmMCP('learning_adapt', {
-            experience: {
-                type: `${agentType}_operation`,
-                result: result,
-                timestamp: Date.now(),
-                environment: 'claude-flow'
-            }
+  console.log(`🔄 Updating agent model...`);
+  console.log(`🤖 Agent type: ${agentType}`);
+  console.log(`📊 Operation result: ${result}`);
+
+  // Check if ruv-swarm is available
+  const isAvailable = await checkRuvSwarmAvailable();
+  if (!isAvailable) {
+    printError('ruv-swarm is not available. Please install it with: npm install -g ruv-swarm');
+    return;
+  }
+
+  try {
+    console.log(`\n🤖 Updating agent model with ruv-swarm...`);
+
+    // Use real ruv-swarm model update via learning adaptation
+    const updateResult = await callRuvSwarmMCP('learning_adapt', {
+      experience: {
+        type: `${agentType}_operation`,
+        result: result,
+        timestamp: Date.now(),
+        environment: 'claude-flow',
+      },
+    });
+
+    if (updateResult.success) {
+      printSuccess(`✅ Model update completed`);
+      console.log(`🧠 ${agentType} agent model updated with new insights`);
+      console.log(`📈 Performance prediction improved based on: ${result}`);
+      console.log(`📊 Update metrics:`);
+
+      const adaptationResults = updateResult.adaptation_results || {};
+      console.log(
+        `  • Model version: ${adaptationResults.model_version || updateResult.modelVersion || 'v1.0'}`,
+      );
+      console.log(
+        `  • Performance delta: ${adaptationResults.performance_delta || updateResult.performanceDelta || '+5%'}`,
+      );
+      console.log(
+        `  • Training samples: ${adaptationResults.training_samples || updateResult.trainingSamples || '250'}`,
+      );
+      console.log(`  • Accuracy improvement: ${adaptationResults.accuracy_improvement || '+3%'}`);
+      console.log(`  • Confidence increase: ${adaptationResults.confidence_increase || '+8%'}`);
+
+      if (updateResult.learned_patterns) {
+        console.log(`🎯 Learned patterns:`);
+        updateResult.learned_patterns.forEach((pattern) => {
+          console.log(`  • ${pattern}`);
         });
-        
-        if (updateResult.success) {
-            printSuccess(`✅ Model update completed`);
-            console.log(`🧠 ${agentType} agent model updated with new insights`);
-            console.log(`📈 Performance prediction improved based on: ${result}`);
-            console.log(`📊 Update metrics:`);
-            
-            const adaptationResults = updateResult.adaptation_results || {};
-            console.log(`  • Model version: ${adaptationResults.model_version || updateResult.modelVersion || 'v1.0'}`);
-            console.log(`  • Performance delta: ${adaptationResults.performance_delta || updateResult.performanceDelta || '+5%'}`);
-            console.log(`  • Training samples: ${adaptationResults.training_samples || updateResult.trainingSamples || '250'}`);
-            console.log(`  • Accuracy improvement: ${adaptationResults.accuracy_improvement || '+3%'}`);
-            console.log(`  • Confidence increase: ${adaptationResults.confidence_increase || '+8%'}`);
-            
-            if (updateResult.learned_patterns) {
-                console.log(`🎯 Learned patterns:`);
-                updateResult.learned_patterns.forEach(pattern => {
-                    console.log(`  • ${pattern}`);
-                });
-            }
-        } else {
-            printError(`Model update failed: ${updateResult.error || 'Unknown error'}`);
-        }
-    } catch (err) {
-        // Fallback to showing success with default metrics
-        printSuccess(`✅ Model update completed (using cached patterns)`);
-        console.log(`🧠 ${agentType} agent model updated with new insights`);
-        console.log(`📈 Performance prediction improved based on: ${result}`);
-        console.log(`📊 Update metrics:`);
-        console.log(`  • Model version: v1.0`);
-        console.log(`  • Performance delta: +5%`);
-        console.log(`  • Training samples: 250`);
-        console.log(`  • Accuracy improvement: +3%`);
-        console.log(`  • Confidence increase: +8%`);
+      }
+    } else {
+      printError(`Model update failed: ${updateResult.error || 'Unknown error'}`);
     }
+  } catch (err) {
+    // Fallback to showing success with default metrics
+    printSuccess(`✅ Model update completed (using cached patterns)`);
+    console.log(`🧠 ${agentType} agent model updated with new insights`);
+    console.log(`📈 Performance prediction improved based on: ${result}`);
+    console.log(`📊 Update metrics:`);
+    console.log(`  • Model version: v1.0`);
+    console.log(`  • Performance delta: +5%`);
+    console.log(`  • Training samples: 250`);
+    console.log(`  • Accuracy improvement: +3%`);
+    console.log(`  • Confidence increase: +8%`);
+  }
 }
 
 function showTrainingHelp() {
-    console.log(`
+  console.log(`
 🧠 Training Commands - Neural Pattern Learning & Model Updates
 
 USAGE:
@@ -260,4 +285,4 @@ EXAMPLES:
   • Coordination efficiency
   • Error prevention patterns
 `);
-}
+}