claude-flow 2.5.0-alpha.139 → 2.7.0-alpha

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

@@ -1,14 +1,48 @@
-import { printSuccess, printError } from '../utils.js';
+import { printSuccess, printError, printWarning } from '../utils.js';
 import { onAgentSpawn } from './performance-hooks.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
 export async function agentCommand(subArgs, flags) {
     const agentCmd = subArgs[0];
+    if (flags.help || flags.h || agentCmd === '--help' || agentCmd === '-h') {
+        showAgentHelp();
+        return;
+    }
     switch(agentCmd){
+        case 'run':
+        case 'execute':
+            await executeAgentTask(subArgs, flags);
+            break;
         case 'spawn':
             await spawnAgent(subArgs, flags);
             break;
         case 'list':
             await listAgents(subArgs, flags);
             break;
+        case 'agents':
+            await listAgenticFlowAgents(subArgs, flags);
+            break;
+        case 'create':
+            await createAgent(subArgs, flags);
+            break;
+        case 'info':
+            await getAgentInfo(subArgs, flags);
+            break;
+        case 'conflicts':
+            await checkAgentConflicts(subArgs, flags);
+            break;
+        case 'memory':
+            await memoryCommand(subArgs, flags);
+            break;
+        case 'config':
+        case 'configure':
+            await configAgenticFlow(subArgs, flags);
+            break;
+        case 'mcp':
+        case 'mcp-server':
+            await mcpAgenticFlow(subArgs, flags);
+            break;
         case 'hierarchy':
             await manageHierarchy(subArgs, flags);
             break;
@@ -24,13 +58,733 @@ export async function agentCommand(subArgs, flags) {
         case 'terminate':
             await terminateAgent(subArgs, flags);
             break;
-        case 'info':
-            await showAgentInfo(subArgs, flags);
+        case 'booster':
+            const { agentBoosterCommand } = await import('./agent-booster.js');
+            await agentBoosterCommand(subArgs, flags);
             break;
         default:
             showAgentHelp();
     }
 }
+async function executeAgentTask(subArgs, flags) {
+    const agentType = subArgs[1];
+    const task = subArgs[2];
+    if (!agentType || !task) {
+        printError('Usage: agent run <agent-type> "<task>" [--provider <provider>] [--model <model>]');
+        console.log('\nExamples:');
+        console.log('  claude-flow agent run coder "Create a REST API"');
+        console.log('  claude-flow agent run researcher "Research AI trends" --provider openrouter');
+        console.log('  claude-flow agent run reviewer "Review code for security" --provider onnx');
+        return;
+    }
+    if (flags.enableMemory || flags.memory) {
+        const { checkEnvConfig, showEnvSetupInstructions } = await import('./env-template.js');
+        const envCheck = await checkEnvConfig(process.cwd());
+        if (!envCheck.exists) {
+            printWarning('⚠️  ReasoningBank memory requires .env configuration');
+            showEnvSetupInstructions();
+            console.log('❌ Cannot use --enable-memory without .env file\n');
+            process.exit(1);
+        }
+        if (!envCheck.hasApiKeys) {
+            printWarning('⚠️  No API keys found in .env file');
+            console.log('\n⚠️  ReasoningBank will fall back to heuristic mode (regex matching)');
+            console.log('   Without API keys, memory will NOT learn from experience!\n');
+            showEnvSetupInstructions();
+            console.log('❌ Add API keys to .env to enable actual learning\n');
+            process.exit(1);
+        }
+        console.log('✅ API keys configured:');
+        if (envCheck.keys.anthropic) console.log('   • Anthropic (Claude)');
+        if (envCheck.keys.openrouter) console.log('   • OpenRouter (cost optimization available)');
+        if (envCheck.keys.gemini) console.log('   • Gemini (free tier available)');
+        console.log('');
+    }
+    printSuccess(`🚀 Executing ${agentType} agent with agentic-flow...`);
+    console.log(`Task: ${task}`);
+    const provider = flags.provider || 'anthropic';
+    if (flags.provider) {
+        console.log(`Provider: ${provider}`);
+    }
+    try {
+        const cmd = buildAgenticFlowCommand(agentType, task, flags);
+        console.log('\n⏳ Running agent... (this may take a moment)\n');
+        const { stdout, stderr } = await execAsync(cmd, {
+            timeout: flags.timeout || 300000,
+            maxBuffer: 10 * 1024 * 1024
+        });
+        if (stdout) {
+            console.log(stdout);
+        }
+        if (stderr && flags.verbose) {
+            console.warn('\nWarnings:', stderr);
+        }
+        printSuccess('✅ Agent task completed successfully!');
+    } catch (error) {
+        printError('❌ Agent execution failed');
+        console.error(error.message);
+        if (error.stderr) {
+            console.error('Error details:', error.stderr);
+        }
+        process.exit(1);
+    }
+}
+function buildAgenticFlowCommand(agent, task, flags) {
+    const parts = [
+        'npx',
+        'agentic-flow'
+    ];
+    parts.push('--agent', agent);
+    parts.push('--task', `"${task.replace(/"/g, '\\"')}"`);
+    if (flags.provider) {
+        parts.push('--provider', flags.provider);
+    }
+    if (flags.model) {
+        parts.push('--model', flags.model);
+    }
+    if (flags.temperature) {
+        parts.push('--temperature', flags.temperature);
+    }
+    if (flags.maxTokens) {
+        parts.push('--max-tokens', flags.maxTokens);
+    }
+    if (flags.format) {
+        parts.push('--output-format', flags.format);
+    }
+    if (flags.stream) {
+        parts.push('--stream');
+    }
+    if (flags.verbose) {
+        parts.push('--verbose');
+    }
+    if (flags.enableMemory || flags.memory) {
+        parts.push('--enable-memory');
+    }
+    if (flags.memoryDb || flags.memoryDatabase) {
+        parts.push('--memory-db', flags.memoryDb || flags.memoryDatabase);
+    }
+    if (flags.memoryK) {
+        parts.push('--memory-k', flags.memoryK);
+    }
+    if (flags.memoryDomain) {
+        parts.push('--memory-domain', flags.memoryDomain);
+    }
+    if (flags.memoryLearning === false) {
+        parts.push('--no-memory-learning');
+    }
+    if (flags.memoryMinConfidence) {
+        parts.push('--memory-min-confidence', flags.memoryMinConfidence);
+    }
+    if (flags.memoryTaskId) {
+        parts.push('--memory-task-id', flags.memoryTaskId);
+    }
+    if (flags.optimize) {
+        parts.push('--optimize');
+    }
+    if (flags.priority) {
+        parts.push('--priority', flags.priority);
+    }
+    if (flags.maxCost) {
+        parts.push('--max-cost', flags.maxCost);
+    }
+    if (flags.retry) {
+        parts.push('--retry');
+    }
+    if (flags.agentsDir) {
+        parts.push('--agents-dir', flags.agentsDir);
+    }
+    if (flags.timeout) {
+        parts.push('--timeout', flags.timeout);
+    }
+    if (flags.anthropicKey) {
+        parts.push('--anthropic-key', flags.anthropicKey);
+    }
+    if (flags.openrouterKey) {
+        parts.push('--openrouter-key', flags.openrouterKey);
+    }
+    if (flags.geminiKey) {
+        parts.push('--gemini-key', flags.geminiKey);
+    }
+    return parts.join(' ');
+}
+async function listAgenticFlowAgents(subArgs, flags) {
+    printSuccess('📋 Loading available agentic-flow agents...');
+    try {
+        const { stdout } = await execAsync('npx agentic-flow agent list', {
+            timeout: 30000
+        });
+        console.log('\n66+ Available Agents:\n');
+        console.log(stdout);
+        console.log('\nUsage:');
+        console.log('  claude-flow agent run <agent-type> "<task>"');
+        console.log('\nExamples:');
+        console.log('  claude-flow agent run coder "Build a REST API with authentication"');
+        console.log('  claude-flow agent run security-auditor "Review this code for vulnerabilities"');
+        console.log('  claude-flow agent run full-stack-developer "Create a Next.js app"');
+    } catch (error) {
+        printError('Failed to load agentic-flow agents');
+        console.error('Make sure agentic-flow is installed: npm install -g agentic-flow');
+        console.error(error.message);
+    }
+}
+async function createAgent(subArgs, flags) {
+    printSuccess('🛠️  Creating custom agent with agentic-flow...');
+    try {
+        let cmd = 'npx agentic-flow agent create';
+        if (flags.name) {
+            cmd += ` --name "${flags.name}"`;
+        }
+        if (flags.description) {
+            cmd += ` --description "${flags.description}"`;
+        }
+        if (flags.category) {
+            cmd += ` --category "${flags.category}"`;
+        }
+        if (flags.prompt) {
+            cmd += ` --prompt "${flags.prompt}"`;
+        }
+        if (flags.tools) {
+            cmd += ` --tools "${flags.tools}"`;
+        }
+        const { stdout, stderr } = await execAsync(cmd, {
+            timeout: 60000,
+            maxBuffer: 10 * 1024 * 1024
+        });
+        if (stdout) {
+            console.log(stdout);
+        }
+        printSuccess('✅ Agent created successfully!');
+        console.log('\nNext steps:');
+        console.log('  1. Run your agent: claude-flow agent run <agent-name> "<task>"');
+        console.log('  2. View agent info: claude-flow agent info <agent-name>');
+        console.log('  3. Check for conflicts: claude-flow agent conflicts');
+    } catch (error) {
+        printError('❌ Failed to create agent');
+        console.error(error.message);
+        if (error.stderr) {
+            console.error('Details:', error.stderr);
+        }
+        process.exit(1);
+    }
+}
+async function getAgentInfo(subArgs, flags) {
+    const agentName = subArgs[1];
+    if (!agentName) {
+        printError('Usage: agent info <agent-name>');
+        console.log('\nExample:');
+        console.log('  claude-flow agent info coder');
+        console.log('  claude-flow agent info security-auditor');
+        return;
+    }
+    printSuccess(`📊 Getting information for agent: ${agentName}`);
+    try {
+        const { stdout } = await execAsync(`npx agentic-flow agent info ${agentName}`, {
+            timeout: 30000
+        });
+        console.log(stdout);
+    } catch (error) {
+        printError(`❌ Failed to get agent info for: ${agentName}`);
+        console.error(error.message);
+        console.log('\nTip: List all agents with: claude-flow agent agents');
+        process.exit(1);
+    }
+}
+async function checkAgentConflicts(subArgs, flags) {
+    printSuccess('🔍 Checking for agent conflicts between package and local agents...');
+    try {
+        const { stdout } = await execAsync('npx agentic-flow agent conflicts', {
+            timeout: 30000
+        });
+        console.log(stdout);
+        if (stdout.includes('No conflicts found')) {
+            printSuccess('✅ No conflicts detected!');
+        } else {
+            printWarning('⚠️  Conflicts found! Local agents will override package agents with the same path.');
+        }
+    } catch (error) {
+        printError('❌ Failed to check agent conflicts');
+        console.error(error.message);
+        process.exit(1);
+    }
+}
+async function memoryCommand(subArgs, flags) {
+    const memoryCmd = subArgs[1];
+    switch(memoryCmd){
+        case 'init':
+        case 'initialize':
+            await initializeMemory(subArgs, flags);
+            break;
+        case 'status':
+        case 'info':
+            await getMemoryStatus(subArgs, flags);
+            break;
+        case 'consolidate':
+        case 'prune':
+            await consolidateMemory(subArgs, flags);
+            break;
+        case 'list':
+        case 'ls':
+            await listMemories(subArgs, flags);
+            break;
+        case 'demo':
+            await runMemoryDemo(subArgs, flags);
+            break;
+        case 'test':
+            await runMemoryTest(subArgs, flags);
+            break;
+        case 'benchmark':
+            await runMemoryBenchmark(subArgs, flags);
+            break;
+        default:
+            showMemoryHelp();
+    }
+}
+async function initializeMemory(subArgs, flags) {
+    const dbPath = flags.db || flags.database || '.swarm/memory.db';
+    printSuccess('🧠 Initializing ReasoningBank memory system...');
+    console.log(`Database: ${dbPath}`);
+    try {
+        const { stdout, stderr } = await execAsync('npx agentic-flow reasoningbank init', {
+            timeout: 30000
+        });
+        if (stdout) {
+            console.log(stdout);
+        }
+        printSuccess('✅ ReasoningBank initialized successfully!');
+        console.log('\nNext steps:');
+        console.log('  1. Run agents with --enable-memory flag');
+        console.log('  2. Check status: claude-flow agent memory status');
+        console.log('  3. View demo: claude-flow agent memory demo');
+    } catch (error) {
+        printError('❌ Failed to initialize ReasoningBank');
+        console.error(error.message);
+        if (error.stderr) {
+            console.error('Details:', error.stderr);
+        }
+        process.exit(1);
+    }
+}
+async function getMemoryStatus(subArgs, flags) {
+    printSuccess('🧠 ReasoningBank Status:');
+    try {
+        const { stdout } = await execAsync('npx agentic-flow reasoningbank status', {
+            timeout: 30000
+        });
+        console.log(stdout);
+    } catch (error) {
+        printError('❌ Failed to get memory status');
+        console.error(error.message);
+        console.log('\nTip: Initialize first with: claude-flow agent memory init');
+        process.exit(1);
+    }
+}
+async function consolidateMemory(subArgs, flags) {
+    printSuccess('🧠 Consolidating ReasoningBank memories...');
+    console.log('This will deduplicate and prune old/low-quality memories');
+    try {
+        const { stdout } = await execAsync('npx agentic-flow reasoningbank consolidate', {
+            timeout: 60000
+        });
+        console.log(stdout);
+        printSuccess('✅ Memory consolidation complete!');
+    } catch (error) {
+        printError('❌ Consolidation failed');
+        console.error(error.message);
+        process.exit(1);
+    }
+}
+async function listMemories(subArgs, flags) {
+    const domain = flags.domain;
+    const limit = flags.limit || 10;
+    printSuccess(`🧠 Listing ReasoningBank memories (limit: ${limit})`);
+    if (domain) {
+        console.log(`Domain filter: ${domain}`);
+    }
+    try {
+        let cmd = 'npx agentic-flow reasoningbank list';
+        if (domain) {
+            cmd += ` --domain ${domain}`;
+        }
+        cmd += ` --limit ${limit}`;
+        const { stdout } = await execAsync(cmd, {
+            timeout: 30000
+        });
+        console.log(stdout);
+    } catch (error) {
+        printError('❌ Failed to list memories');
+        console.error(error.message);
+        process.exit(1);
+    }
+}
+async function runMemoryDemo(subArgs, flags) {
+    printSuccess('🎯 Running ReasoningBank demo...');
+    console.log('This will show how memory improves task success over time\n');
+    try {
+        const { stdout } = await execAsync('npx agentic-flow reasoningbank demo', {
+            timeout: 120000
+        });
+        console.log(stdout);
+        printSuccess('✅ Demo complete!');
+    } catch (error) {
+        printError('❌ Demo failed');
+        console.error(error.message);
+        process.exit(1);
+    }
+}
+async function runMemoryTest(subArgs, flags) {
+    printSuccess('🧪 Running ReasoningBank integration tests...');
+    try {
+        const { stdout } = await execAsync('npx agentic-flow reasoningbank test', {
+            timeout: 120000
+        });
+        console.log(stdout);
+        printSuccess('✅ Tests complete!');
+    } catch (error) {
+        printError('❌ Tests failed');
+        console.error(error.message);
+        process.exit(1);
+    }
+}
+async function runMemoryBenchmark(subArgs, flags) {
+    printSuccess('⚡ Running ReasoningBank performance benchmarks...');
+    try {
+        const { stdout } = await execAsync('npx agentic-flow reasoningbank benchmark', {
+            timeout: 120000
+        });
+        console.log(stdout);
+        printSuccess('✅ Benchmarks complete!');
+    } catch (error) {
+        printError('❌ Benchmark failed');
+        console.error(error.message);
+        process.exit(1);
+    }
+}
+function showMemoryHelp() {
+    console.log('Memory (ReasoningBank) commands:');
+    console.log('  init                             Initialize ReasoningBank database');
+    console.log('  status                           Show memory system status');
+    console.log('  consolidate                      Deduplicate and prune memories');
+    console.log('  list [--domain <domain>]         List stored memories');
+    console.log('  demo                             Run interactive demo');
+    console.log('  test                             Run integration tests');
+    console.log('  benchmark                        Run performance benchmarks');
+    console.log();
+    console.log('Options:');
+    console.log('  --db, --database <path>          Database path [default: .swarm/memory.db]');
+    console.log('  --domain <domain>                Filter by domain');
+    console.log('  --limit <n>                      Limit results [default: 10]');
+    console.log();
+    console.log('Examples:');
+    console.log('  claude-flow agent memory init');
+    console.log('  claude-flow agent memory status');
+    console.log('  claude-flow agent memory list --domain web --limit 5');
+    console.log('  claude-flow agent memory consolidate');
+    console.log('  claude-flow agent memory demo');
+}
+async function configAgenticFlow(subArgs, flags) {
+    const configCmd = subArgs[1];
+    switch(configCmd){
+        case 'set':
+            await agenticConfigSet(subArgs, flags);
+            break;
+        case 'get':
+            await agenticConfigGet(subArgs, flags);
+            break;
+        case 'list':
+            await agenticConfigList(subArgs, flags);
+            break;
+        case 'delete':
+        case 'remove':
+        case 'rm':
+            await agenticConfigDelete(subArgs, flags);
+            break;
+        case 'reset':
+            await agenticConfigReset(subArgs, flags);
+            break;
+        case undefined:
+        case 'wizard':
+        case 'interactive':
+            await agenticConfigWizard(subArgs, flags);
+            break;
+        default:
+            showAgenticConfigHelp();
+    }
+}
+async function agenticConfigSet(subArgs, flags) {
+    const key = subArgs[2];
+    const value = subArgs[3];
+    if (!key || !value) {
+        printError('Usage: agent config set <key> <value>');
+        console.log('\nExample:');
+        console.log('  claude-flow agent config set ANTHROPIC_API_KEY sk-ant-xxx');
+        console.log('  claude-flow agent config set DEFAULT_MODEL claude-3-5-sonnet-20241022');
+        return;
+    }
+    printSuccess(`🔧 Setting agentic-flow configuration: ${key}`);
+    try {
+        const { stdout } = await execAsync(`npx agentic-flow config set ${key} "${value}"`, {
+            timeout: 30000
+        });
+        console.log(stdout);
+        printSuccess('✅ Configuration set successfully!');
+    } catch (error) {
+        printError(`❌ Failed to set configuration: ${key}`);
+        console.error(error.message);
+        process.exit(1);
+    }
+}
+async function agenticConfigGet(subArgs, flags) {
+    const key = subArgs[2];
+    if (!key) {
+        printError('Usage: agent config get <key>');
+        console.log('\nExample:');
+        console.log('  claude-flow agent config get ANTHROPIC_API_KEY');
+        return;
+    }
+    try {
+        const { stdout } = await execAsync(`npx agentic-flow config get ${key}`, {
+            timeout: 30000
+        });
+        console.log(stdout);
+    } catch (error) {
+        printError(`❌ Failed to get configuration: ${key}`);
+        console.error(error.message);
+        process.exit(1);
+    }
+}
+async function agenticConfigList(subArgs, flags) {
+    printSuccess('📋 Listing agentic-flow configurations...');
+    try {
+        let cmd = 'npx agentic-flow config list';
+        if (flags.showSecrets) {
+            cmd += ' --show-secrets';
+        }
+        const { stdout } = await execAsync(cmd, {
+            timeout: 30000
+        });
+        console.log(stdout);
+        if (!flags.showSecrets) {
+            console.log('\n💡 Tip: Use --show-secrets to reveal sensitive values');
+        }
+    } catch (error) {
+        printError('❌ Failed to list configurations');
+        console.error(error.message);
+        process.exit(1);
+    }
+}
+async function agenticConfigDelete(subArgs, flags) {
+    const key = subArgs[2];
+    if (!key) {
+        printError('Usage: agent config delete <key>');
+        return;
+    }
+    printWarning(`⚠️  Deleting configuration: ${key}`);
+    try {
+        const { stdout } = await execAsync(`npx agentic-flow config delete ${key}`, {
+            timeout: 30000
+        });
+        console.log(stdout);
+        printSuccess('✅ Configuration deleted!');
+    } catch (error) {
+        printError(`❌ Failed to delete configuration: ${key}`);
+        console.error(error.message);
+        process.exit(1);
+    }
+}
+async function agenticConfigReset(subArgs, flags) {
+    if (!flags.force) {
+        printWarning('⚠️  WARNING: This will reset ALL agentic-flow configurations!');
+        console.log('\nUse --force to confirm: claude-flow agent config reset --force');
+        return;
+    }
+    printWarning('🔄 Resetting agentic-flow configurations...');
+    try {
+        const { stdout } = await execAsync('npx agentic-flow config reset --force', {
+            timeout: 30000
+        });
+        console.log(stdout);
+        printSuccess('✅ Configurations reset!');
+    } catch (error) {
+        printError('❌ Failed to reset configurations');
+        console.error(error.message);
+        process.exit(1);
+    }
+}
+async function agenticConfigWizard(subArgs, flags) {
+    printSuccess('🧙 Starting agentic-flow configuration wizard...');
+    try {
+        const { stdout } = await execAsync('npx agentic-flow config wizard', {
+            timeout: 300000
+        });
+        console.log(stdout);
+        printSuccess('✅ Configuration wizard completed!');
+    } catch (error) {
+        printError('❌ Configuration wizard failed');
+        console.error(error.message);
+        process.exit(1);
+    }
+}
+function showAgenticConfigHelp() {
+    console.log('Agentic-flow configuration commands:');
+    console.log('  set <key> <value>               Set configuration value');
+    console.log('  get <key>                       Get configuration value');
+    console.log('  list                            List all configurations');
+    console.log('  delete <key>                    Delete configuration value');
+    console.log('  reset --force                   Reset to defaults');
+    console.log('  wizard                          Run interactive setup wizard');
+    console.log();
+    console.log('Examples:');
+    console.log('  claude-flow agent config wizard');
+    console.log('  claude-flow agent config set ANTHROPIC_API_KEY sk-ant-xxx');
+    console.log('  claude-flow agent config list --show-secrets');
+}
+async function mcpAgenticFlow(subArgs, flags) {
+    const mcpCmd = subArgs[1];
+    switch(mcpCmd){
+        case 'start':
+            await agenticMcpStart(subArgs, flags);
+            break;
+        case 'stop':
+            await agenticMcpStop(subArgs, flags);
+            break;
+        case 'status':
+            await agenticMcpStatus(subArgs, flags);
+            break;
+        case 'list':
+        case 'ls':
+            await agenticMcpList(subArgs, flags);
+            break;
+        case 'logs':
+            await agenticMcpLogs(subArgs, flags);
+            break;
+        case 'restart':
+            await agenticMcpRestart(subArgs, flags);
+            break;
+        default:
+            showAgenticMcpHelp();
+    }
+}
+async function agenticMcpStart(subArgs, flags) {
+    printSuccess('🚀 Starting agentic-flow MCP server...');
+    try {
+        let cmd = 'npx agentic-flow mcp start';
+        if (flags.port) cmd += ` --port ${flags.port}`;
+        if (flags.host) cmd += ` --host ${flags.host}`;
+        if (flags.daemon || flags.background) cmd += ' --daemon';
+        const { stdout } = await execAsync(cmd, {
+            timeout: 60000
+        });
+        console.log(stdout);
+        printSuccess('✅ MCP server started!');
+    } catch (error) {
+        printError('❌ Failed to start MCP server');
+        console.error(error.message);
+        process.exit(1);
+    }
+}
+async function agenticMcpStop(subArgs, flags) {
+    printWarning('🛑 Stopping agentic-flow MCP server...');
+    try {
+        const { stdout } = await execAsync('npx agentic-flow mcp stop', {
+            timeout: 30000
+        });
+        console.log(stdout);
+        printSuccess('✅ MCP server stopped!');
+    } catch (error) {
+        printError('❌ Failed to stop MCP server');
+        console.error(error.message);
+        process.exit(1);
+    }
+}
+async function agenticMcpStatus(subArgs, flags) {
+    printSuccess('📊 Getting agentic-flow MCP server status...');
+    try {
+        let cmd = 'npx agentic-flow mcp status';
+        if (flags.detailed || flags.verbose) cmd += ' --detailed';
+        const { stdout } = await execAsync(cmd, {
+            timeout: 30000
+        });
+        console.log(stdout);
+    } catch (error) {
+        printError('❌ Failed to get MCP status');
+        console.error(error.message);
+        process.exit(1);
+    }
+}
+async function agenticMcpList(subArgs, flags) {
+    printSuccess('📋 Listing agentic-flow MCP tools...');
+    try {
+        let cmd = 'npx agentic-flow mcp list';
+        if (flags.server) cmd += ` --server ${flags.server}`;
+        if (flags.category) cmd += ` --category ${flags.category}`;
+        if (flags.detailed || flags.verbose) cmd += ' --detailed';
+        const { stdout } = await execAsync(cmd, {
+            timeout: 30000
+        });
+        console.log(stdout);
+    } catch (error) {
+        printError('❌ Failed to list MCP tools');
+        console.error(error.message);
+        process.exit(1);
+    }
+}
+async function agenticMcpLogs(subArgs, flags) {
+    printSuccess('📄 Getting agentic-flow MCP logs...');
+    try {
+        let cmd = 'npx agentic-flow mcp logs';
+        if (flags.lines) cmd += ` --lines ${flags.lines}`;
+        if (flags.follow || flags.f) cmd += ' --follow';
+        if (flags.error) cmd += ' --error';
+        const { stdout } = await execAsync(cmd, {
+            timeout: flags.follow ? 0 : 30000,
+            maxBuffer: 10 * 1024 * 1024
+        });
+        console.log(stdout);
+    } catch (error) {
+        printError('❌ Failed to get MCP logs');
+        console.error(error.message);
+        process.exit(1);
+    }
+}
+async function agenticMcpRestart(subArgs, flags) {
+    printWarning('🔄 Restarting agentic-flow MCP server...');
+    try {
+        await agenticMcpStop(subArgs, {
+            ...flags,
+            quiet: true
+        });
+        await new Promise((resolve)=>setTimeout(resolve, 2000));
+        await agenticMcpStart(subArgs, flags);
+        printSuccess('✅ MCP server restarted!');
+    } catch (error) {
+        printError('❌ Failed to restart MCP server');
+        console.error(error.message);
+        process.exit(1);
+    }
+}
+function showAgenticMcpHelp() {
+    console.log('Agentic-flow MCP server commands:');
+    console.log('  start [--port <port>]           Start MCP server');
+    console.log('  stop                            Stop MCP server');
+    console.log('  restart                         Restart MCP server');
+    console.log('  status [--detailed]             Get server status');
+    console.log('  list [--server <name>]          List MCP tools');
+    console.log('  logs [--lines <n>] [--follow]   View server logs');
+    console.log();
+    console.log('Options:');
+    console.log('  --port <number>                 Server port (default: 3000)');
+    console.log('  --host <string>                 Server host (default: localhost)');
+    console.log('  --daemon, --background          Run in background');
+    console.log('  --server <name>                 Filter by server name');
+    console.log('  --category <type>               Filter by tool category');
+    console.log('  --detailed, --verbose           Detailed output');
+    console.log();
+    console.log('Examples:');
+    console.log('  claude-flow agent mcp start --daemon');
+    console.log('  claude-flow agent mcp status --detailed');
+    console.log('  claude-flow agent mcp list --server agent-booster');
+    console.log('  claude-flow agent mcp logs --lines 50 --follow');
+}
 async function spawnAgent(subArgs, flags) {
     const agentType = subArgs[1] || 'general';
     const agentName = getFlag(subArgs, '--name') || flags.name || `agent-${Date.now()}`;
@@ -257,27 +1011,116 @@ function getFlag(args, flagName) {
 }
 function showAgentHelp() {
     console.log('Agent commands:');
-    console.log('  spawn <type> [--name <name>]     Create new agent');
-    console.log('  list [--verbose]                 List active agents');
+    console.log('\n🚀 Agentic-Flow Integration (NEW in v2.6.0):');
+    console.log('  run <agent> "<task>" [options]   Execute agent with multi-provider support');
+    console.log('  agents                           List all 66+ agentic-flow agents');
+    console.log('  create --name <name> [options]   Create custom agent');
+    console.log('  info <agent-name>                Show detailed agent information');
+    console.log('  conflicts                        Check for agent conflicts');
+    console.log('\n🧠 ReasoningBank Memory (NEW in v2.6.0):');
+    console.log('  memory init                      Initialize memory system');
+    console.log('  memory status                    Show memory statistics');
+    console.log('  memory consolidate               Prune and deduplicate memories');
+    console.log('  memory list [--domain <d>]       List stored memories');
+    console.log('  memory demo                      Run interactive demo');
+    console.log('  memory test                      Run integration tests');
+    console.log('  memory benchmark                 Run performance benchmarks');
+    console.log('\n🔧 Configuration Management (NEW in v2.6.0):');
+    console.log('  config wizard                    Run interactive setup wizard');
+    console.log('  config set <key> <value>         Set configuration value');
+    console.log('  config get <key>                 Get configuration value');
+    console.log('  config list [--show-secrets]     List all configurations');
+    console.log('  config delete <key>              Delete configuration value');
+    console.log('  config reset --force             Reset to defaults');
+    console.log('\n🌐 MCP Server Management (NEW in v2.6.0):');
+    console.log('  mcp start [--port <port>]        Start MCP server');
+    console.log('  mcp stop                         Stop MCP server');
+    console.log('  mcp restart                      Restart MCP server');
+    console.log('  mcp status [--detailed]          Get server status');
+    console.log('  mcp list [--server <name>]       List MCP tools');
+    console.log('  mcp logs [--lines <n>] [-f]      View server logs');
+    console.log('\n🚀 Agent Booster - Ultra-Fast Code Editing (NEW in v2.6.0):');
+    console.log('  booster edit <file> "<instr>"    Edit file (352x faster, $0)');
+    console.log('  booster batch <pattern> "<i>"    Batch edit files');
+    console.log('  booster parse-markdown <file>    Parse markdown edits');
+    console.log('  booster benchmark [options]      Run performance tests');
+    console.log('  booster help                     Show Agent Booster help');
+    console.log('\n🤖 Internal Agent Management:');
+    console.log('  spawn <type> [--name <name>]     Create internal agent');
+    console.log('  list [--verbose]                 List active internal agents');
     console.log('  terminate <id>                   Stop specific agent');
-    console.log('  info <id>                        Show agent details');
     console.log('  hierarchy <create|show>          Manage agent hierarchies');
     console.log('  network <topology|metrics>       Agent network operations');
     console.log('  ecosystem <status|optimize>      Ecosystem management');
     console.log('  provision <count>                Auto-provision agents');
     console.log();
-    console.log('Agent Types:');
-    console.log('  researcher    Research and information gathering');
-    console.log('  coder         Code development and analysis');
-    console.log('  analyst       Data analysis and insights');
-    console.log('  coordinator   Task coordination and management');
-    console.log('  general       Multi-purpose agent');
+    console.log('Execution Options (for run command):');
+    console.log('  --provider <provider>            Provider: anthropic, openrouter, onnx, gemini');
+    console.log('  --model <model>                  Specific model to use');
+    console.log('  --temperature <temp>             Temperature (0.0-1.0)');
+    console.log('  --max-tokens <tokens>            Maximum tokens');
+    console.log('  --format <format>                Output format: text, json, markdown');
+    console.log('  --stream                         Enable streaming');
+    console.log('  --verbose                        Verbose output');
+    console.log();
+    console.log('Model Optimization Options (NEW in v2.6.0):');
+    console.log('  --optimize                       Auto-select optimal model (85-98% savings)');
+    console.log('  --priority <priority>            Priority: quality, cost, speed, privacy, balanced');
+    console.log('  --max-cost <dollars>             Maximum cost per task in dollars');
+    console.log();
+    console.log('Advanced Execution Options (NEW in v2.6.0):');
+    console.log('  --retry                          Auto-retry on transient errors');
+    console.log('  --agents-dir <path>              Custom agents directory');
+    console.log('  --timeout <ms>                   Execution timeout in milliseconds');
+    console.log('  --anthropic-key <key>            Override Anthropic API key');
+    console.log('  --openrouter-key <key>           Override OpenRouter API key');
+    console.log('  --gemini-key <key>               Override Gemini API key');
+    console.log();
+    console.log('Memory Options (NEW - for run command):');
+    console.log('  --enable-memory                  Enable ReasoningBank learning');
+    console.log('                                   ⚠️  REQUIRES .env with API keys');
+    console.log('                                   Run: claude-flow init --env');
+    console.log('  --memory-db <path>               Memory database path [default: .swarm/memory.db]');
+    console.log('  --memory-k <n>                   Top-k memories to retrieve [default: 3]');
+    console.log('  --memory-domain <domain>         Domain filter for memories');
+    console.log('  --no-memory-learning             Disable post-task learning');
+    console.log('  --memory-min-confidence <n>      Min confidence threshold [default: 0.5]');
+    console.log('  --memory-task-id <id>            Custom task ID for tracking');
     console.log();
     console.log('Examples:');
+    console.log('\n  # Execute with agentic-flow (multi-provider)');
+    console.log('  claude-flow agent run coder "Build REST API with authentication"');
+    console.log('  claude-flow agent run researcher "Research React 19 features" --provider openrouter');
+    console.log('  claude-flow agent run security-auditor "Audit code" --provider onnx');
+    console.log('  claude-flow agent agents  # List all available agents');
+    console.log('\n  # Model optimization (85-98% cost savings)');
+    console.log('  claude-flow agent run coder "Build API" --optimize');
+    console.log('  claude-flow agent run coder "Fix bug" --optimize --priority cost');
+    console.log('  claude-flow agent run coder "Critical fix" --optimize --priority quality --max-cost 0.50');
+    console.log('\n  # Execute with ReasoningBank memory (learns from experience)');
+    console.log('  claude-flow agent run coder "Build API" --enable-memory');
+    console.log('  claude-flow agent run coder "Add auth" --enable-memory --memory-domain api');
+    console.log('  claude-flow agent run coder "Fix bug" --enable-memory --memory-k 5');
+    console.log('\n  # Memory management');
+    console.log('  claude-flow agent memory init');
+    console.log('  claude-flow agent memory status');
+    console.log('  claude-flow agent memory list --domain api --limit 10');
+    console.log('  claude-flow agent memory consolidate');
+    console.log('  claude-flow agent memory demo  # See 70% → 88% success improvement');
+    console.log('\n  # Configuration management');
+    console.log('  claude-flow agent config wizard  # Interactive setup');
+    console.log('  claude-flow agent config set ANTHROPIC_API_KEY sk-ant-xxx');
+    console.log('  claude-flow agent config list --show-secrets');
+    console.log('  claude-flow agent config get DEFAULT_MODEL');
+    console.log('\n  # MCP server management');
+    console.log('  claude-flow agent mcp start --daemon');
+    console.log('  claude-flow agent mcp status --detailed');
+    console.log('  claude-flow agent mcp list --server agent-booster');
+    console.log('  claude-flow agent mcp logs --follow');
+    console.log('\n  # Internal agent management');
     console.log('  claude-flow agent spawn researcher --name "DataBot"');
     console.log('  claude-flow agent list --verbose');
     console.log('  claude-flow agent hierarchy create enterprise');
-    console.log('  claude-flow agent ecosystem status');
 }
 
 //# sourceMappingURL=agent.js.map