claude-flow-novice 2.0.4 → 2.0.5

package/dist/src/cli/simple-commands/automation.js

@@ -1,513 +1,501 @@
-import { printSuccess, printError, printWarning } from "../utils.js";
-import { WorkflowExecutor, loadWorkflowFromFile, getMLEStarWorkflowPath } from "./automation-executor.js";
-import { existsSync } from "fs";
+import { printSuccess, printError, printWarning } from '../utils.js';
+import {
+  WorkflowExecutor,
+  loadWorkflowFromFile,
+  getMLEStarWorkflowPath,
+} from './automation-executor.js';
+import { existsSync } from 'fs';
+import { join } from 'path';
+
 // Simple ID generator
 function generateId(prefix = 'id') {
-    return `${prefix}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  return `${prefix}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
 }
+
 export async function automationAction(subArgs, flags) {
-    const subcommand = subArgs[0];
-    const options = flags;
-    if (options.help || options.h || !subcommand) {
+  const subcommand = subArgs[0];
+  const options = flags;
+
+  if (options.help || options.h || !subcommand) {
+    showAutomationHelp();
+    return;
+  }
+
+  try {
+    switch (subcommand) {
+      case 'auto-agent':
+        await autoAgentCommand(subArgs, flags);
+        break;
+      case 'smart-spawn':
+        await smartSpawnCommand(subArgs, flags);
+        break;
+      case 'workflow-select':
+        await workflowSelectCommand(subArgs, flags);
+        break;
+      case 'run-workflow':
+        await runWorkflowCommand(subArgs, flags);
+        break;
+      case 'mle-star':
+        await mleStarCommand(subArgs, flags);
+        break;
+      default:
+        printError(`Unknown automation command: ${subcommand}`);
         showAutomationHelp();
-        return;
-    }
-    try {
-        switch(subcommand){
-            case 'auto-agent':
-                await autoAgentCommand(subArgs, flags);
-                break;
-            case 'smart-spawn':
-                await smartSpawnCommand(subArgs, flags);
-                break;
-            case 'workflow-select':
-                await workflowSelectCommand(subArgs, flags);
-                break;
-            case 'run-workflow':
-                await runWorkflowCommand(subArgs, flags);
-                break;
-            case 'mle-star':
-                await mleStarCommand(subArgs, flags);
-                break;
-            default:
-                printError(`Unknown automation command: ${subcommand}`);
-                showAutomationHelp();
-        }
-    } catch (err) {
-        printError(`Automation command failed: ${err.message}`);
     }
+  } catch (err) {
+    printError(`Automation command failed: ${err.message}`);
+  }
 }
+
 async function autoAgentCommand(subArgs, flags) {
-    const options = flags;
-    const complexity = options['task-complexity'] || options.complexity || 'medium';
-    const swarmId = options['swarm-id'] || options.swarmId || generateId('swarm');
-    console.log(`🤖 Auto-spawning agents based on task complexity...`);
-    console.log(`📊 Task complexity: ${complexity}`);
-    console.log(`🐝 Swarm ID: ${swarmId}`);
-    // Determine optimal agent configuration based on complexity
-    let agentConfig;
-    switch(complexity.toLowerCase()){
-        case 'low':
-        case 'simple':
-            agentConfig = {
-                coordinator: 1,
-                developer: 1,
-                total: 2
-            };
-            break;
-        case 'medium':
-        case 'moderate':
-            agentConfig = {
-                coordinator: 1,
-                developer: 2,
-                researcher: 1,
-                total: 4
-            };
-            break;
-        case 'high':
-        case 'complex':
-            agentConfig = {
-                coordinator: 2,
-                developer: 3,
-                researcher: 2,
-                analyzer: 1,
-                total: 8
-            };
-            break;
-        case 'enterprise':
-        case 'massive':
-            agentConfig = {
-                coordinator: 3,
-                developer: 5,
-                researcher: 3,
-                analyzer: 2,
-                tester: 2,
-                total: 15
-            };
-            break;
-        default:
-            agentConfig = {
-                coordinator: 1,
-                developer: 2,
-                researcher: 1,
-                total: 4
-            };
+  const options = flags;
+  const complexity = options['task-complexity'] || options.complexity || 'medium';
+  const swarmId = options['swarm-id'] || options.swarmId || generateId('swarm');
+
+  console.log(`🤖 Auto-spawning agents based on task complexity...`);
+  console.log(`📊 Task complexity: ${complexity}`);
+  console.log(`🐝 Swarm ID: ${swarmId}`);
+
+  // Determine optimal agent configuration based on complexity
+  let agentConfig;
+  switch (complexity.toLowerCase()) {
+    case 'low':
+    case 'simple':
+      agentConfig = { coordinator: 1, developer: 1, total: 2 };
+      break;
+    case 'medium':
+    case 'moderate':
+      agentConfig = { coordinator: 1, developer: 2, researcher: 1, total: 4 };
+      break;
+    case 'high':
+    case 'complex':
+      agentConfig = { coordinator: 2, developer: 3, researcher: 2, analyzer: 1, total: 8 };
+      break;
+    case 'enterprise':
+    case 'massive':
+      agentConfig = {
+        coordinator: 3,
+        developer: 5,
+        researcher: 3,
+        analyzer: 2,
+        tester: 2,
+        total: 15,
+      };
+      break;
+    default:
+      agentConfig = { coordinator: 1, developer: 2, researcher: 1, total: 4 };
+  }
+
+  console.log(`\n🎯 OPTIMAL AGENT CONFIGURATION:`);
+  Object.entries(agentConfig).forEach(([type, count]) => {
+    if (type !== 'total') {
+      console.log(`  🤖 ${type}: ${count} agents`);
     }
-    console.log(`\n🎯 OPTIMAL AGENT CONFIGURATION:`);
-    Object.entries(agentConfig).forEach(([type, count])=>{
-        if (type !== 'total') {
-            console.log(`  🤖 ${type}: ${count} agents`);
-        }
-    });
-    console.log(`  📊 Total agents: ${agentConfig.total}`);
-    // Simulate auto-spawning
-    await new Promise((resolve)=>setTimeout(resolve, 1500));
-    printSuccess(`✅ Auto-agent spawning completed`);
-    console.log(`🚀 ${agentConfig.total} agents spawned and configured for ${complexity} complexity tasks`);
-    console.log(`💾 Agent configuration saved to swarm memory: ${swarmId}`);
-    console.log(`📋 Agents ready for task assignment`);
+  });
+  console.log(`  📊 Total agents: ${agentConfig.total}`);
+
+  // Simulate auto-spawning
+  await new Promise((resolve) => setTimeout(resolve, 1500));
+
+  printSuccess(`✅ Auto-agent spawning completed`);
+  console.log(
+    `🚀 ${agentConfig.total} agents spawned and configured for ${complexity} complexity tasks`,
+  );
+  console.log(`💾 Agent configuration saved to swarm memory: ${swarmId}`);
+  console.log(`📋 Agents ready for task assignment`);
 }
+
 async function smartSpawnCommand(subArgs, flags) {
-    const options = flags;
-    const requirement = options.requirement || 'general-development';
-    const maxAgents = parseInt(options['max-agents'] || options.maxAgents || '10');
-    console.log(`🧠 Smart spawning agents based on requirements...`);
-    console.log(`📋 Requirement: ${requirement}`);
-    console.log(`🔢 Max agents: ${maxAgents}`);
-    // Analyze requirements and suggest optimal agent mix
-    let recommendedAgents = [];
-    if (requirement.includes('development') || requirement.includes('coding')) {
-        recommendedAgents.push({
-            type: 'coordinator',
-            count: 1,
-            reason: 'Task orchestration'
-        }, {
-            type: 'coder',
-            count: 3,
-            reason: 'Core development work'
-        }, {
-            type: 'tester',
-            count: 1,
-            reason: 'Quality assurance'
-        });
-    }
-    if (requirement.includes('research') || requirement.includes('analysis')) {
-        recommendedAgents.push({
-            type: 'researcher',
-            count: 2,
-            reason: 'Information gathering'
-        }, {
-            type: 'analyst',
-            count: 1,
-            reason: 'Data analysis'
-        });
-    }
-    if (requirement.includes('enterprise') || requirement.includes('production')) {
-        recommendedAgents.push({
-            type: 'coordinator',
-            count: 2,
-            reason: 'Multi-tier coordination'
-        }, {
-            type: 'coder',
-            count: 4,
-            reason: 'Parallel development'
-        }, {
-            type: 'researcher',
-            count: 2,
-            reason: 'Requirements analysis'
-        }, {
-            type: 'analyst',
-            count: 1,
-            reason: 'Performance monitoring'
-        }, {
-            type: 'tester',
-            count: 2,
-            reason: 'Comprehensive testing'
-        });
-    }
-    // Default fallback
-    if (recommendedAgents.length === 0) {
-        recommendedAgents = [
-            {
-                type: 'coordinator',
-                count: 1,
-                reason: 'General coordination'
-            },
-            {
-                type: 'coder',
-                count: 2,
-                reason: 'General development'
-            },
-            {
-                type: 'researcher',
-                count: 1,
-                reason: 'Support research'
-            }
-        ];
-    }
-    await new Promise((resolve)=>setTimeout(resolve, 1000));
-    printSuccess(`✅ Smart spawn analysis completed`);
-    console.log(`\n🎯 RECOMMENDED AGENT CONFIGURATION:`);
-    let totalRecommended = 0;
-    recommendedAgents.forEach((agent)=>{
-        console.log(`  🤖 ${agent.type}: ${agent.count} agents - ${agent.reason}`);
-        totalRecommended += agent.count;
-    });
-    console.log(`\n📊 SUMMARY:`);
-    console.log(`  📝 Total recommended: ${totalRecommended} agents`);
-    console.log(`  🔢 Max allowed: ${maxAgents} agents`);
-    console.log(`  ✅ Configuration: ${totalRecommended <= maxAgents ? 'Within limits' : 'Exceeds limits - scaling down required'}`);
-    if (totalRecommended > maxAgents) {
-        printWarning(`⚠️  Recommended configuration exceeds max agents. Consider increasing limit or simplifying requirements.`);
-    }
+  const options = flags;
+  const requirement = options.requirement || 'general-development';
+  const maxAgents = parseInt(options['max-agents'] || options.maxAgents || '10');
+
+  console.log(`🧠 Smart spawning agents based on requirements...`);
+  console.log(`📋 Requirement: ${requirement}`);
+  console.log(`🔢 Max agents: ${maxAgents}`);
+
+  // Analyze requirements and suggest optimal agent mix
+  let recommendedAgents = [];
+
+  if (requirement.includes('development') || requirement.includes('coding')) {
+    recommendedAgents.push(
+      { type: 'coordinator', count: 1, reason: 'Task orchestration' },
+      { type: 'coder', count: 3, reason: 'Core development work' },
+      { type: 'tester', count: 1, reason: 'Quality assurance' },
+    );
+  }
+
+  if (requirement.includes('research') || requirement.includes('analysis')) {
+    recommendedAgents.push(
+      { type: 'researcher', count: 2, reason: 'Information gathering' },
+      { type: 'analyst', count: 1, reason: 'Data analysis' },
+    );
+  }
+
+  if (requirement.includes('enterprise') || requirement.includes('production')) {
+    recommendedAgents.push(
+      { type: 'coordinator', count: 2, reason: 'Multi-tier coordination' },
+      { type: 'coder', count: 4, reason: 'Parallel development' },
+      { type: 'researcher', count: 2, reason: 'Requirements analysis' },
+      { type: 'analyst', count: 1, reason: 'Performance monitoring' },
+      { type: 'tester', count: 2, reason: 'Comprehensive testing' },
+    );
+  }
+
+  // Default fallback
+  if (recommendedAgents.length === 0) {
+    recommendedAgents = [
+      { type: 'coordinator', count: 1, reason: 'General coordination' },
+      { type: 'coder', count: 2, reason: 'General development' },
+      { type: 'researcher', count: 1, reason: 'Support research' },
+    ];
+  }
+
+  await new Promise((resolve) => setTimeout(resolve, 1000));
+
+  printSuccess(`✅ Smart spawn analysis completed`);
+  console.log(`\n🎯 RECOMMENDED AGENT CONFIGURATION:`);
+
+  let totalRecommended = 0;
+  recommendedAgents.forEach((agent) => {
+    console.log(`  🤖 ${agent.type}: ${agent.count} agents - ${agent.reason}`);
+    totalRecommended += agent.count;
+  });
+
+  console.log(`\n📊 SUMMARY:`);
+  console.log(`  📝 Total recommended: ${totalRecommended} agents`);
+  console.log(`  🔢 Max allowed: ${maxAgents} agents`);
+  console.log(
+    `  ✅ Configuration: ${totalRecommended <= maxAgents ? 'Within limits' : 'Exceeds limits - scaling down required'}`,
+  );
+
+  if (totalRecommended > maxAgents) {
+    printWarning(
+      `⚠️  Recommended configuration exceeds max agents. Consider increasing limit or simplifying requirements.`,
+    );
+  }
 }
+
 async function workflowSelectCommand(subArgs, flags) {
-    const options = flags;
-    const projectType = options['project-type'] || options.project || 'general';
-    const priority = options.priority || 'balanced';
-    console.log(`🔄 Selecting optimal workflow configuration...`);
-    console.log(`📁 Project type: ${projectType}`);
-    console.log(`⚡ Priority: ${priority}`);
-    // Define workflow templates
-    const workflows = {
-        'web-app': {
-            phases: [
-                'planning',
-                'design',
-                'frontend',
-                'backend',
-                'testing',
-                'deployment'
-            ],
-            agents: {
-                coordinator: 1,
-                developer: 3,
-                tester: 1,
-                researcher: 1
-            },
-            duration: '2-4 weeks'
-        },
-        api: {
-            phases: [
-                'specification',
-                'design',
-                'implementation',
-                'testing',
-                'documentation'
-            ],
-            agents: {
-                coordinator: 1,
-                developer: 2,
-                tester: 1,
-                researcher: 1
-            },
-            duration: '1-2 weeks'
-        },
-        'data-analysis': {
-            phases: [
-                'collection',
-                'cleaning',
-                'analysis',
-                'visualization',
-                'reporting'
-            ],
-            agents: {
-                coordinator: 1,
-                researcher: 2,
-                analyzer: 2,
-                developer: 1
-            },
-            duration: '1-3 weeks'
-        },
-        enterprise: {
-            phases: [
-                'requirements',
-                'architecture',
-                'development',
-                'integration',
-                'testing',
-                'deployment',
-                'monitoring'
-            ],
-            agents: {
-                coordinator: 2,
-                developer: 5,
-                researcher: 2,
-                analyzer: 1,
-                tester: 2
-            },
-            duration: '2-6 months'
-        },
-        general: {
-            phases: [
-                'planning',
-                'implementation',
-                'testing',
-                'delivery'
-            ],
-            agents: {
-                coordinator: 1,
-                developer: 2,
-                researcher: 1
-            },
-            duration: '1-2 weeks'
-        }
-    };
-    const selectedWorkflow = workflows[projectType] || workflows['general'];
-    await new Promise((resolve)=>setTimeout(resolve, 800));
-    printSuccess(`✅ Workflow selection completed`);
-    console.log(`\n🔄 SELECTED WORKFLOW: ${projectType.toUpperCase()}`);
-    console.log(`⏱️  Estimated duration: ${selectedWorkflow.duration}`);
-    console.log(`\n📋 WORKFLOW PHASES:`);
-    selectedWorkflow.phases.forEach((phase, index)=>{
-        console.log(`  ${index + 1}. ${phase.charAt(0).toUpperCase() + phase.slice(1)}`);
-    });
-    console.log(`\n🤖 RECOMMENDED AGENTS:`);
-    Object.entries(selectedWorkflow.agents).forEach(([type, count])=>{
-        console.log(`  • ${type}: ${count} agent${count > 1 ? 's' : ''}`);
-    });
-    console.log(`\n⚡ PRIORITY OPTIMIZATIONS:`);
-    switch(priority){
-        case 'speed':
-            console.log(`  🚀 Speed-optimized: +50% agents, parallel execution`);
-            break;
-        case 'quality':
-            console.log(`  🎯 Quality-focused: +100% testing, code review stages`);
-            break;
-        case 'cost':
-            console.log(`  💰 Cost-efficient: Minimal agents, sequential execution`);
-            break;
-        default:
-            console.log(`  ⚖️  Balanced approach: Optimal speed/quality/cost ratio`);
-    }
-    console.log(`\n📄 Workflow template saved for project: ${projectType}`);
+  const options = flags;
+  const projectType = options['project-type'] || options.project || 'general';
+  const priority = options.priority || 'balanced';
+
+  console.log(`🔄 Selecting optimal workflow configuration...`);
+  console.log(`📁 Project type: ${projectType}`);
+  console.log(`⚡ Priority: ${priority}`);
+
+  // Define workflow templates
+  const workflows = {
+    'web-app': {
+      phases: ['planning', 'design', 'frontend', 'backend', 'testing', 'deployment'],
+      agents: { coordinator: 1, developer: 3, tester: 1, researcher: 1 },
+      duration: '2-4 weeks',
+    },
+    api: {
+      phases: ['specification', 'design', 'implementation', 'testing', 'documentation'],
+      agents: { coordinator: 1, developer: 2, tester: 1, researcher: 1 },
+      duration: '1-2 weeks',
+    },
+    'data-analysis': {
+      phases: ['collection', 'cleaning', 'analysis', 'visualization', 'reporting'],
+      agents: { coordinator: 1, researcher: 2, analyzer: 2, developer: 1 },
+      duration: '1-3 weeks',
+    },
+    enterprise: {
+      phases: [
+        'requirements',
+        'architecture',
+        'development',
+        'integration',
+        'testing',
+        'deployment',
+        'monitoring',
+      ],
+      agents: { coordinator: 2, developer: 5, researcher: 2, analyzer: 1, tester: 2 },
+      duration: '2-6 months',
+    },
+    general: {
+      phases: ['planning', 'implementation', 'testing', 'delivery'],
+      agents: { coordinator: 1, developer: 2, researcher: 1 },
+      duration: '1-2 weeks',
+    },
+  };
+
+  const selectedWorkflow = workflows[projectType] || workflows['general'];
+
+  await new Promise((resolve) => setTimeout(resolve, 800));
+
+  printSuccess(`✅ Workflow selection completed`);
+  console.log(`\n🔄 SELECTED WORKFLOW: ${projectType.toUpperCase()}`);
+  console.log(`⏱️  Estimated duration: ${selectedWorkflow.duration}`);
+
+  console.log(`\n📋 WORKFLOW PHASES:`);
+  selectedWorkflow.phases.forEach((phase, index) => {
+    console.log(`  ${index + 1}. ${phase.charAt(0).toUpperCase() + phase.slice(1)}`);
+  });
+
+  console.log(`\n🤖 RECOMMENDED AGENTS:`);
+  Object.entries(selectedWorkflow.agents).forEach(([type, count]) => {
+    console.log(`  • ${type}: ${count} agent${count > 1 ? 's' : ''}`);
+  });
+
+  console.log(`\n⚡ PRIORITY OPTIMIZATIONS:`);
+  switch (priority) {
+    case 'speed':
+      console.log(`  🚀 Speed-optimized: +50% agents, parallel execution`);
+      break;
+    case 'quality':
+      console.log(`  🎯 Quality-focused: +100% testing, code review stages`);
+      break;
+    case 'cost':
+      console.log(`  💰 Cost-efficient: Minimal agents, sequential execution`);
+      break;
+    default:
+      console.log(`  ⚖️  Balanced approach: Optimal speed/quality/cost ratio`);
+  }
+
+  console.log(`\n📄 Workflow template saved for project: ${projectType}`);
 }
+
 /**
  * Execute a workflow from file - NEW IMPLEMENTATION
- */ async function runWorkflowCommand(subArgs, flags) {
-    const workflowFile = subArgs[1];
-    const options = flags;
-    if (!workflowFile) {
-        printError('Usage: automation run-workflow <workflow-file> [options]');
-        console.log('\nExample:');
-        console.log('  claude-flow-novice automation run-workflow workflow.json --claude --non-interactive');
-        return;
+ */
+async function runWorkflowCommand(subArgs, flags) {
+  const workflowFile = subArgs[1];
+  const options = flags;
+
+  if (!workflowFile) {
+    printError('Usage: automation run-workflow <workflow-file> [options]');
+    console.log('\nExample:');
+    console.log('  claude-flow-novice automation run-workflow workflow.json --claude --non-interactive');
+    return;
+  }
+
+  if (!existsSync(workflowFile)) {
+    printError(`Workflow file not found: ${workflowFile}`);
+    return;
+  }
+
+  try {
+    console.log(`🔄 Loading workflow: ${workflowFile}`);
+
+    // Load workflow definition
+    const workflowData = await loadWorkflowFromFile(workflowFile);
+
+    // Create executor with options
+    const executor = new WorkflowExecutor({
+      enableClaude: options.claude || false,
+      nonInteractive: options['non-interactive'] || options.nonInteractive || false,
+      outputFormat:
+        options['output-format'] ||
+        (options['non-interactive'] || options.nonInteractive ? 'stream-json' : 'text'),
+      maxConcurrency: parseInt(options['max-concurrency']) || 3,
+      timeout: parseInt(options.timeout) || 3600000,
+      logLevel: options.verbose ? 'debug' : 'info',
+      workflowName: workflowData.name,
+      workflowType:
+        workflowData.type || (workflowData.name?.toLowerCase().includes('ml') ? 'ml' : 'general'),
+      enableChaining: options.chaining !== false, // Default to true for stream-json chaining
+    });
+
+    // Apply variable overrides if provided
+    const variables = {};
+    if (options.variables) {
+      try {
+        Object.assign(variables, JSON.parse(options.variables));
+      } catch (error) {
+        printWarning(`Invalid variables JSON: ${error.message}`);
+      }
     }
-    if (!existsSync(workflowFile)) {
-        printError(`Workflow file not found: ${workflowFile}`);
-        return;
+
+    // Execute workflow
+    const result = await executor.executeWorkflow(workflowData, variables);
+
+    if (options['output-format'] === 'json') {
+      console.log(JSON.stringify(result, null, 2));
     }
-    try {
-        console.log(`🔄 Loading workflow: ${workflowFile}`);
-        // Load workflow definition
-        const workflowData = await loadWorkflowFromFile(workflowFile);
-        // Create executor with options
-        const executor = new WorkflowExecutor({
-            enableClaude: options.claude || false,
-            nonInteractive: options['non-interactive'] || options.nonInteractive || false,
-            outputFormat: options['output-format'] || (options['non-interactive'] || options.nonInteractive ? 'stream-json' : 'text'),
-            maxConcurrency: parseInt(options['max-concurrency']) || 3,
-            timeout: parseInt(options.timeout) || 3600000,
-            logLevel: options.verbose ? 'debug' : 'info',
-            workflowName: workflowData.name,
-            workflowType: workflowData.type || (workflowData.name?.toLowerCase().includes('ml') ? 'ml' : 'general'),
-            enableChaining: options.chaining !== false
-        });
-        // Apply variable overrides if provided
-        const variables = {};
-        if (options.variables) {
-            try {
-                Object.assign(variables, JSON.parse(options.variables));
-            } catch (error) {
-                printWarning(`Invalid variables JSON: ${error.message}`);
-            }
-        }
-        // Execute workflow
-        const result = await executor.executeWorkflow(workflowData, variables);
-        if (options['output-format'] === 'json') {
-            console.log(JSON.stringify(result, null, 2));
-        }
-        printSuccess(`Workflow execution ${result.success ? 'completed' : 'failed'}`);
-        if (!result.success && result.errors.length > 0) {
-            console.log('\n❌ Errors encountered:');
-            result.errors.forEach((error)=>{
-                console.log(`  • ${error.type}: ${error.error}`);
-            });
-        }
-        // Ensure process exits properly in non-interactive mode
-        if (options['non-interactive'] || options.nonInteractive) {
-            process.exit(result.success ? 0 : 1);
-        }
-    } catch (error) {
-        printError(`Failed to execute workflow: ${error.message}`);
-        if (options['non-interactive'] || options.nonInteractive) {
-            process.exit(1);
-        }
+
+    printSuccess(`Workflow execution ${result.success ? 'completed' : 'failed'}`);
+
+    if (!result.success && result.errors.length > 0) {
+      console.log('\n❌ Errors encountered:');
+      result.errors.forEach((error) => {
+        console.log(`  • ${error.type}: ${error.error}`);
+      });
     }
+
+    // Ensure process exits properly in non-interactive mode
+    if (options['non-interactive'] || options.nonInteractive) {
+      process.exit(result.success ? 0 : 1);
+    }
+  } catch (error) {
+    printError(`Failed to execute workflow: ${error.message}`);
+    if (options['non-interactive'] || options.nonInteractive) {
+      process.exit(1);
+    }
+  }
 }
+
 /**
  * Run MLE-STAR workflow - NEW FLAGSHIP COMMAND
- */ async function mleStarCommand(subArgs, flags) {
-    const options = flags;
-    console.log(`🧠 MLE-STAR: Machine Learning Engineering via Search and Targeted Refinement`);
-    console.log(`🎯 This is the flagship automation workflow for ML engineering tasks`);
+ */
+async function mleStarCommand(subArgs, flags) {
+  const options = flags;
+
+  console.log(`🧠 MLE-STAR: Machine Learning Engineering via Search and Targeted Refinement`);
+  console.log(`🎯 This is the flagship automation workflow for ML engineering tasks`);
+  console.log();
+
+  try {
+    // Get the built-in MLE-STAR workflow
+    const workflowPath = getMLEStarWorkflowPath();
+
+    if (!existsSync(workflowPath)) {
+      printError('MLE-STAR workflow template not found');
+      console.log('Please ensure the template is installed at:');
+      console.log(workflowPath);
+      return;
+    }
+
+    // Load MLE-STAR workflow
+    const workflowData = await loadWorkflowFromFile(workflowPath);
+
+    console.log(`📋 Workflow: ${workflowData.name}`);
+    console.log(`📄 Description: ${workflowData.description}`);
+    console.log(`🎓 Methodology: Search → Foundation → Refinement → Ensemble → Validation`);
+    console.log(`⏱️  Expected Runtime: ${workflowData.metadata.expected_runtime}`);
     console.log();
-    try {
-        // Get the built-in MLE-STAR workflow
-        const workflowPath = getMLEStarWorkflowPath();
-        if (!existsSync(workflowPath)) {
-            printError('MLE-STAR workflow template not found');
-            console.log('Please ensure the template is installed at:');
-            console.log(workflowPath);
-            return;
+
+    // Detect dataset if provided
+    const datasetPath = options.dataset || options.data || './data/dataset.csv';
+    const targetColumn = options.target || 'target';
+
+    // Create executor with MLE-STAR optimized settings
+    // IMPORTANT: Default to non-interactive mode to prevent multiple Claude spawns
+    const isNonInteractive = options.interactive
+      ? false // If --interactive is explicitly set, use interactive mode
+      : options['non-interactive'] !== undefined
+        ? options['non-interactive'] || options.nonInteractive
+        : true; // Default to true for MLE-STAR to avoid multiple interactive sessions
+
+    const executor = new WorkflowExecutor({
+      enableClaude: options.claude !== false, // Default to true for MLE-STAR
+      nonInteractive: isNonInteractive,
+      outputFormat: options['output-format'] || (isNonInteractive ? 'stream-json' : 'text'),
+      maxConcurrency: parseInt(options['max-agents']) || 6,
+      timeout: parseInt(options.timeout) || 14400000, // 4 hours for ML workflows
+      logLevel: options.quiet ? 'quiet' : options.verbose ? 'debug' : 'info',
+      workflowName: 'MLE-STAR Machine Learning Engineering Workflow',
+      workflowType: 'ml',
+      enableChaining: options.chaining !== false, // Default to true for stream-json chaining
+    });
+
+    // Prepare MLE-STAR specific variables
+    const variables = {
+      dataset_path: datasetPath,
+      target_column: targetColumn,
+      experiment_name: options.name || `mle-star-${Date.now()}`,
+      model_output_dir: options.output || './models/',
+      search_iterations: parseInt(options['search-iterations']) || 3,
+      refinement_iterations: parseInt(options['refinement-iterations']) || 5,
+      ...((options.variables && JSON.parse(options.variables)) || {}),
+    };
+
+    if (options.quiet) {
+      console.log(
+        `📊 Running MLE-STAR: ${variables.dataset_path} → ${variables.target_column} (${executor.options.enableClaude ? 'Claude enabled' : 'Simulation'})`,
+      );
+      console.log();
+    } else {
+      console.log(`📊 Configuration:`);
+      console.log(`  Dataset: ${variables.dataset_path}`);
+      console.log(`  Target: ${variables.target_column}`);
+      console.log(`  Output: ${variables.model_output_dir}`);
+      console.log(
+        `  Claude Integration: ${executor.options.enableClaude ? 'Enabled' : 'Disabled'}`,
+      );
+      console.log(
+        `  Execution Mode: ${isNonInteractive ? 'Non-interactive (default)' : 'Interactive'}`,
+      );
+      console.log(
+        `  Stream Chaining: ${executor.options.enableChaining && executor.options.outputFormat === 'stream-json' ? 'Enabled' : 'Disabled'}`,
+      );
+      console.log();
+
+      if (isNonInteractive && options.claude !== false) {
+        console.log(`💡 Running in non-interactive mode: Each agent will execute independently`);
+        if (executor.options.enableChaining && executor.options.outputFormat === 'stream-json') {
+          console.log(
+            `🔗 Stream chaining enabled: Agent outputs will be piped to dependent agents`,
+          );
         }
-        // Load MLE-STAR workflow
-        const workflowData = await loadWorkflowFromFile(workflowPath);
-        console.log(`📋 Workflow: ${workflowData.name}`);
-        console.log(`📄 Description: ${workflowData.description}`);
-        console.log(`🎓 Methodology: Search → Foundation → Refinement → Ensemble → Validation`);
-        console.log(`⏱️  Expected Runtime: ${workflowData.metadata.expected_runtime}`);
+        console.log(`   To use interactive mode instead, add --interactive flag`);
         console.log();
-        // Detect dataset if provided
-        const datasetPath = options.dataset || options.data || './data/dataset.csv';
-        const targetColumn = options.target || 'target';
-        // Create executor with MLE-STAR optimized settings
-        // IMPORTANT: Default to non-interactive mode to prevent multiple Claude spawns
-        const isNonInteractive = options.interactive ? false // If --interactive is explicitly set, use interactive mode
-         : options['non-interactive'] !== undefined ? options['non-interactive'] || options.nonInteractive : true; // Default to true for MLE-STAR to avoid multiple interactive sessions
-        const executor = new WorkflowExecutor({
-            enableClaude: options.claude !== false,
-            nonInteractive: isNonInteractive,
-            outputFormat: options['output-format'] || (isNonInteractive ? 'stream-json' : 'text'),
-            maxConcurrency: parseInt(options['max-agents']) || 6,
-            timeout: parseInt(options.timeout) || 14400000,
-            logLevel: options.quiet ? 'quiet' : options.verbose ? 'debug' : 'info',
-            workflowName: 'MLE-STAR Machine Learning Engineering Workflow',
-            workflowType: 'ml',
-            enableChaining: options.chaining !== false
+      }
+    }
+
+    if (!options.claude && !options['no-claude-warning']) {
+      printWarning(
+        'MLE-STAR works best with Claude integration. Add --claude flag for full automation.',
+      );
+      console.log('Without Claude, this will simulate the workflow execution.');
+      console.log();
+    }
+
+    // Execute MLE-STAR workflow
+    const result = await executor.executeWorkflow(workflowData, variables);
+
+    if (result.success) {
+      console.log();
+      printSuccess('🎉 MLE-STAR workflow completed successfully!');
+      console.log(`📊 Results: ${result.completedTasks}/${result.totalTasks} tasks completed`);
+      console.log(`⏱️  Duration: ${executor.formatDuration(result.duration)}`);
+      console.log(`🆔 Execution ID: ${result.executionId}`);
+
+      if (result.results && Object.keys(result.results).length > 0) {
+        console.log(`\n📈 Key Results:`);
+        Object.entries(result.results).forEach(([taskId, taskResult]) => {
+          if (taskResult.output?.status === 'completed') {
+            console.log(`  ✅ ${taskId}: Completed successfully`);
+          }
         });
-        // Prepare MLE-STAR specific variables
-        const variables = {
-            dataset_path: datasetPath,
-            target_column: targetColumn,
-            experiment_name: options.name || `mle-star-${Date.now()}`,
-            model_output_dir: options.output || './models/',
-            search_iterations: parseInt(options['search-iterations']) || 3,
-            refinement_iterations: parseInt(options['refinement-iterations']) || 5,
-            ...options.variables && JSON.parse(options.variables) || {}
-        };
-        if (options.quiet) {
-            console.log(`📊 Running MLE-STAR: ${variables.dataset_path} → ${variables.target_column} (${executor.options.enableClaude ? 'Claude enabled' : 'Simulation'})`);
-            console.log();
-        } else {
-            console.log(`📊 Configuration:`);
-            console.log(`  Dataset: ${variables.dataset_path}`);
-            console.log(`  Target: ${variables.target_column}`);
-            console.log(`  Output: ${variables.model_output_dir}`);
-            console.log(`  Claude Integration: ${executor.options.enableClaude ? 'Enabled' : 'Disabled'}`);
-            console.log(`  Execution Mode: ${isNonInteractive ? 'Non-interactive (default)' : 'Interactive'}`);
-            console.log(`  Stream Chaining: ${executor.options.enableChaining && executor.options.outputFormat === 'stream-json' ? 'Enabled' : 'Disabled'}`);
-            console.log();
-            if (isNonInteractive && options.claude !== false) {
-                console.log(`💡 Running in non-interactive mode: Each agent will execute independently`);
-                if (executor.options.enableChaining && executor.options.outputFormat === 'stream-json') {
-                    console.log(`🔗 Stream chaining enabled: Agent outputs will be piped to dependent agents`);
-                }
-                console.log(`   To use interactive mode instead, add --interactive flag`);
-                console.log();
-            }
-        }
-        if (!options.claude && !options['no-claude-warning']) {
-            printWarning('MLE-STAR works best with Claude integration. Add --claude flag for full automation.');
-            console.log('Without Claude, this will simulate the workflow execution.');
-            console.log();
-        }
-        // Execute MLE-STAR workflow
-        const result = await executor.executeWorkflow(workflowData, variables);
-        if (result.success) {
-            console.log();
-            printSuccess('🎉 MLE-STAR workflow completed successfully!');
-            console.log(`📊 Results: ${result.completedTasks}/${result.totalTasks} tasks completed`);
-            console.log(`⏱️  Duration: ${executor.formatDuration(result.duration)}`);
-            console.log(`🆔 Execution ID: ${result.executionId}`);
-            if (result.results && Object.keys(result.results).length > 0) {
-                console.log(`\n📈 Key Results:`);
-                Object.entries(result.results).forEach(([taskId, taskResult])=>{
-                    if (taskResult.output?.status === 'completed') {
-                        console.log(`  ✅ ${taskId}: Completed successfully`);
-                    }
-                });
-            }
-            console.log(`\n💡 Next Steps:`);
-            console.log(`  • Check models in: ${variables.model_output_dir}`);
-            console.log(`  • Review experiment: ${variables.experiment_name}`);
-            console.log(`  • Validate results with your test data`);
-        } else {
-            printError('❌ MLE-STAR workflow failed');
-            console.log(`📊 Progress: ${result.completedTasks}/${result.totalTasks} tasks completed`);
-            if (result.errors.length > 0) {
-                console.log('\n🔍 Errors:');
-                result.errors.forEach((error)=>{
-                    console.log(`  • ${error.type}: ${error.error}`);
-                });
-            }
-        }
-        if (options['output-format'] === 'json') {
-            console.log('\n' + JSON.stringify(result, null, 2));
-        }
-        // Ensure process exits properly in non-interactive mode
-        if (options['non-interactive'] || options.nonInteractive) {
-            process.exit(result.success ? 0 : 1);
-        }
-    } catch (error) {
-        printError(`MLE-STAR execution failed: ${error.message}`);
-        if (options['non-interactive'] || options.nonInteractive) {
-            process.exit(1);
-        }
+      }
+
+      console.log(`\n💡 Next Steps:`);
+      console.log(`  • Check models in: ${variables.model_output_dir}`);
+      console.log(`  • Review experiment: ${variables.experiment_name}`);
+      console.log(`  • Validate results with your test data`);
+    } else {
+      printError('❌ MLE-STAR workflow failed');
+      console.log(`📊 Progress: ${result.completedTasks}/${result.totalTasks} tasks completed`);
+
+      if (result.errors.length > 0) {
+        console.log('\n🔍 Errors:');
+        result.errors.forEach((error) => {
+          console.log(`  • ${error.type}: ${error.error}`);
+        });
+      }
     }
+
+    if (options['output-format'] === 'json') {
+      console.log('\n' + JSON.stringify(result, null, 2));
+    }
+
+    // Ensure process exits properly in non-interactive mode
+    if (options['non-interactive'] || options.nonInteractive) {
+      process.exit(result.success ? 0 : 1);
+    }
+  } catch (error) {
+    printError(`MLE-STAR execution failed: ${error.message}`);
+    if (options['non-interactive'] || options.nonInteractive) {
+      process.exit(1);
+    }
+  }
 }
+
 function showAutomationHelp() {
-    console.log(`
+  console.log(`
 🤖 Automation Commands - Intelligent Agent & Workflow Management
 
 USAGE: