claude-flow 2.7.19 → 2.7.21

package/bin/claude-flow

@@ -1,7 +1,7 @@
 #!/bin/sh
 # Claude-Flow Smart Dispatcher - Detects and uses the best available runtime
 
-VERSION="2.7.19"
+VERSION="2.7.21"
 
 # Determine the correct path based on how the script is invoked
 if [ -L "$0" ]; then

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

@@ -1,18 +1,47 @@
-#!/usr/bin/env -S deno run --allow-all
-import { promises as fs } from 'node:fs';
+#!/usr/bin/env node
 import { executeCommand, hasCommand, showCommandHelp, listCommands } from './command-registry.js';
 import { parseFlags } from './utils.js';
+import { args, cwd, isMainModule, exit, readTextFile, writeTextFile, mkdirAsync, errors } from './node-compat.js';
+import { spawn } from 'child_process';
+import process from 'process';
+import readline from 'readline';
+import { getMainHelp, getCommandHelp, getStandardizedCommandHelp } from './help-text.js';
 import { VERSION } from '../core/version.js';
-function printHelp() {
+const LEGACY_AGENT_MAPPING = {
+    analyst: 'code-analyzer',
+    coordinator: 'task-orchestrator',
+    optimizer: 'perf-analyzer',
+    documenter: 'api-docs',
+    monitor: 'performance-benchmarker',
+    specialist: 'system-architect',
+    architect: 'system-architect'
+};
+function resolveLegacyAgentType(legacyType) {
+    return LEGACY_AGENT_MAPPING[legacyType] || legacyType;
+}
+function printHelp(plain = false) {
+    console.log(getMainHelp(plain));
+}
+function printCommandHelp(command) {
+    const standardCommands = [
+        'agent',
+        'sparc',
+        'memory'
+    ];
+    if (standardCommands.includes(command)) {
+        const help = getStandardizedCommandHelp(command);
+        console.log(help);
+    } else {
+        const help = getCommandHelp(command);
+        console.log(help);
+    }
+}
+function printLegacyHelp() {
     console.log(`
 🌊 Claude-Flow v${VERSION} - Enterprise-Grade AI Agent Orchestration Platform
 
-🎯 NEW IN v2.6.0: Multi-Provider Execution Engine with Agentic-Flow Integration
-   • 66+ specialized agents with multi-provider support (Anthropic, OpenRouter, ONNX, Gemini)
-   • 99% cost savings with OpenRouter, 352x faster local edits with Agent Booster
-   • Complete backwards compatibility with existing features
-
-🎯 ENTERPRISE FEATURES: Complete ruv-swarm integration with 27 MCP tools, neural networking, and production-ready infrastructure
+🎯 ENTERPRISE FEATURES: Complete ruv-swarm integration with 90+ MCP tools, neural networking, and production-ready infrastructure
+⚡ ALPHA 85: Advanced automation capabilities & stream-JSON chaining for multi-agent pipelines
 
 USAGE:
   claude-flow <command> [options]
@@ -48,10 +77,9 @@ USAGE:
   init [--sparc]              # Initialize with enterprise environment + ruv-swarm
   start [--ui] [--swarm]      # Start orchestration with swarm intelligence
   spawn <type> [--name]       # Create AI agent with swarm coordination
-  agent <subcommand>          # 🆕 Multi-provider agent execution + management
+  agent <subcommand>          # Advanced agent management with neural patterns
   sparc <subcommand>          # 17 SPARC modes with neural enhancement
   memory <subcommand>         # Cross-session persistent memory with neural learning
-  config <subcommand>         # 🆕 Provider configuration management
   status                      # Comprehensive system status with performance metrics
 
 🤖 NEURAL AGENT TYPES (ruv-swarm Integration):
@@ -66,25 +94,20 @@ USAGE:
 
 🎮 ENTERPRISE QUICK START:
   # Initialize enterprise environment
-  npx claude-flow@2.6.0-alpha.1 init --sparc
-
-  # 🆕 Execute agents with multi-provider support
-  ./claude-flow agent run coder "Build REST API with auth" --provider anthropic
-  ./claude-flow agent run researcher "Research React 19" --provider openrouter  # 99% cost savings
-  ./claude-flow agent agents  # List all 66+ available agents
-
+  npx claude-flow@2.0.0 init --sparc
+  
   # Start enterprise orchestration with swarm intelligence
   ./claude-flow start --ui --swarm
-
+  
   # Deploy intelligent multi-agent development workflow
   ./claude-flow swarm "build enterprise API" --strategy development --parallel --monitor
-
+  
   # GitHub workflow automation
   ./claude-flow github pr-manager "coordinate release with automated testing"
-
+  
   # Neural memory management
   ./claude-flow memory store "architecture" "microservices with API gateway pattern"
-
+  
   # Real-time system monitoring
   ./claude-flow status --verbose
 
@@ -152,8 +175,8 @@ function printSuccess(message) {
 function printWarning(message) {
     console.warn(`⚠️  Warning: ${message}`);
 }
-function showHelpWithCommands() {
-    printHelp();
+function showHelpWithCommands(plain = false) {
+    printHelp(plain);
     console.log('\nRegistered Commands:');
     const commands = listCommands();
     for (const command of commands){
@@ -162,14 +185,58 @@ function showHelpWithCommands() {
     console.log('\nUse "claude-flow help <command>" for detailed usage information');
 }
 async function main() {
-    const args = Deno.args;
     if (args.length === 0) {
-        printHelp();
+        printHelp(usePlainHelp);
         return;
     }
     const command = args[0];
     const { flags, args: parsedArgs } = parseFlags(args.slice(1));
+    const usePlainHelp = args.includes('--plain');
+    let enhancedFlags = flags;
+    try {
+        const { detectExecutionEnvironment, applySmartDefaults } = await import('./utils/environment-detector.js');
+        enhancedFlags = applySmartDefaults(flags);
+        enhancedFlags._environment = detectExecutionEnvironment({
+            skipWarnings: true
+        });
+    } catch (e) {
+        enhancedFlags = flags;
+    }
+    if (command !== 'help' && command !== '--help' && command !== '-h' && (enhancedFlags.help || enhancedFlags.h)) {
+        const detailedHelp = getCommandHelp(command);
+        if (detailedHelp && !detailedHelp.includes('Help not available')) {
+            printCommandHelp(command);
+        } else if (hasCommand(command)) {
+            showCommandHelp(command);
+        } else {
+            printError(`Unknown command: ${command}`);
+            console.log('\nRun "claude-flow --help" to see available commands.');
+        }
+        return;
+    }
     switch(command){
+        case 'env-check':
+        case 'environment':
+            if (enhancedFlags._environment) {
+                const env = enhancedFlags._environment;
+                console.log(`\n🖥️  Environment Detection Results:`);
+                console.log(`   Terminal: ${env.terminalType}`);
+                console.log(`   Interactive: ${env.isInteractive ? 'Yes' : 'No'}`);
+                console.log(`   TTY Support: ${env.supportsRawMode ? 'Yes' : 'No'}`);
+                console.log(`   Detected: ${env.isVSCode ? 'VS Code' : env.isCI ? 'CI/CD' : env.isDocker ? 'Docker' : env.isSSH ? 'SSH' : 'Standard Terminal'}`);
+                if (env.recommendedFlags.length > 0) {
+                    console.log(`\n💡 Recommended flags:`);
+                    console.log(`   ${env.recommendedFlags.join(' ')}`);
+                }
+                if (enhancedFlags.appliedDefaults && enhancedFlags.appliedDefaults.length > 0) {
+                    console.log(`\n✅ Auto-applied:`);
+                    console.log(`   ${enhancedFlags.appliedDefaults.join(' ')}`);
+                }
+                console.log();
+            } else {
+                console.log('Environment detection not available');
+            }
+            return;
         case 'version':
         case '--version':
         case '-v':
@@ -179,9 +246,14 @@ async function main() {
         case '--help':
         case '-h':
             if (parsedArgs.length > 0) {
-                showCommandHelp(parsedArgs[0]);
+                const detailedHelp = getCommandHelp(parsedArgs[0]);
+                if (detailedHelp && !detailedHelp.includes('Help not available')) {
+                    printCommandHelp(parsedArgs[0]);
+                } else {
+                    showCommandHelp(parsedArgs[0]);
+                }
             } else {
-                showHelpWithCommands();
+                printHelp(usePlainHelp);
             }
             return;
     }
@@ -191,6 +263,7 @@ async function main() {
             return;
         } catch (err) {
             printError(err.message);
+            console.log(`\nRun "claude-flow ${command} --help" for usage information.`);
             return;
         }
     }
@@ -210,11 +283,12 @@ async function main() {
             console.log('📊 Real-time monitoring would display here');
             break;
         case 'spawn':
-            const spawnType = subArgs[0] || 'general';
+            const rawSpawnType = subArgs[0] || 'general';
+            const spawnType = resolveLegacyAgentType(rawSpawnType);
             const spawnName = flags.name || `agent-${Date.now()}`;
             printSuccess(`Spawning ${spawnType} agent: ${spawnName}`);
             console.log('🤖 Agent would be created with the following configuration:');
-            console.log(`   Type: ${spawnType}`);
+            console.log(`   Type: ${spawnType}${rawSpawnType !== spawnType ? ` (resolved from: ${rawSpawnType})` : ''}`);
             console.log(`   Name: ${spawnName}`);
             console.log('   Capabilities: Research, Analysis, Code Generation');
             console.log('   Status: Ready');
@@ -239,7 +313,7 @@ async function main() {
                             console.log('     • Max Pool Size: 10');
                             console.log('     • Idle Timeout: 5 minutes');
                             console.log('     • Shell: /bin/bash');
-                            console.log('     • Working Directory: ' + process.cwd());
+                            console.log('     • Working Directory: ' + cwd());
                             console.log('   Performance:');
                             console.log('     • Average Response Time: N/A');
                             console.log('     • Terminal Creation Time: N/A');
@@ -288,7 +362,7 @@ async function main() {
                     const terminalConfig = {
                         name: nameIndex >= 0 ? subArgs[nameIndex + 1] : 'terminal-' + Date.now(),
                         shell: shellIndex >= 0 ? subArgs[shellIndex + 1] : 'bash',
-                        workingDirectory: wdIndex >= 0 ? subArgs[wdIndex + 1] : process.cwd(),
+                        workingDirectory: wdIndex >= 0 ? subArgs[wdIndex + 1] : cwd(),
                         env: envIndex >= 0 ? subArgs[envIndex + 1] : '',
                         persistent: persistentIndex >= 0
                     };
@@ -1245,10 +1319,9 @@ ${flags1.mode === 'full' || !flags1.mode ? `Full-stack development covering all
                                 console.log('Debug - Executing command:');
                                 console.log(`claude ${claudeArgs.map((arg)=>arg.includes(' ') || arg.includes('\n') ? `"${arg}"` : arg).join(' ')}`);
                             }
-                            const command = new Deno.Command('claude', {
-                                args: claudeArgs,
+                            const child = spawn('claude', claudeArgs, {
                                 env: {
-                                    ...Deno.env.toObject(),
+                                    ...process.env,
                                     CLAUDE_INSTANCE_ID: instanceId,
                                     CLAUDE_FLOW_MODE: flags1.mode || 'full',
                                     CLAUDE_FLOW_COVERAGE: (flags1.coverage || 80).toString(),
@@ -1258,17 +1331,18 @@ ${flags1.mode === 'full' || !flags1.mode ? `Full-stack development covering all
                                     CLAUDE_FLOW_COORDINATION_ENABLED: flags1.parallel ? 'true' : 'false',
                                     CLAUDE_FLOW_FEATURES: 'memory,coordination,swarm'
                                 },
-                                stdin: 'inherit',
-                                stdout: 'inherit',
-                                stderr: 'inherit'
+                                stdio: 'inherit'
+                            });
+                            await new Promise((resolve)=>{
+                                child.on('exit', (code)=>{
+                                    if (code === 0) {
+                                        printSuccess(`Claude instance ${instanceId} completed successfully`);
+                                    } else {
+                                        printError(`Claude instance ${instanceId} exited with code ${code}`);
+                                    }
+                                    resolve();
+                                });
                             });
-                            const child = command.spawn();
-                            const status = await child.status;
-                            if (status.success) {
-                                printSuccess(`Claude instance ${instanceId} completed successfully`);
-                            } else {
-                                printError(`Claude instance ${instanceId} exited with code ${status.code}`);
-                            }
                         } catch (err) {
                             printError(`Failed to spawn Claude: ${err.message}`);
                             console.log('Make sure you have the Claude CLI installed.');
@@ -1821,7 +1895,7 @@ ${flags1.mode === 'full' || !flags1.mode ? `Full-stack development covering all
                 console.log('\nDid you mean:');
                 suggestions.forEach((cmd)=>console.log(`  claude-flow ${cmd}`));
             }
-            process.exit(1);
+            exit(1);
     }
 }
 async function startRepl() {
@@ -1899,7 +1973,7 @@ Shortcuts:
         },
         config: async (key)=>{
             try {
-                const config = JSON.parse(await fs.readFile('claude-flow.config.json', 'utf-8'));
+                const config = JSON.parse(await readTextFile('claude-flow.config.json'));
                 if (key) {
                     const keys = key.split('.');
                     let value = config;
@@ -1927,21 +2001,25 @@ Shortcuts:
         if (trimmed.startsWith('!')) {
             const shellCmd = trimmed.substring(1);
             try {
-                const command = new Deno.Command('sh', {
-                    args: [
+                await new Promise((resolve)=>{
+                    const proc = spawn('sh', [
                         '-c',
                         shellCmd
-                    ],
-                    stdout: 'piped',
-                    stderr: 'piped'
+                    ], {
+                        stdio: [
+                            'inherit',
+                            'pipe',
+                            'pipe'
+                        ]
+                    });
+                    proc.stdout.on('data', (data)=>{
+                        console.log(data.toString());
+                    });
+                    proc.stderr.on('data', (data)=>{
+                        console.error(data.toString());
+                    });
+                    proc.on('exit', resolve);
                 });
-                const { stdout, stderr } = await command.output();
-                if (stdout.length > 0) {
-                    console.log(new TextDecoder().decode(stdout));
-                }
-                if (stderr.length > 0) {
-                    console.error(new TextDecoder().decode(stderr));
-                }
             } catch (err) {
                 console.error(`Shell error: ${err.message}`);
             }
@@ -1961,7 +2039,7 @@ Shortcuts:
         const parts = trimmed.split(' ');
         const command = parts[0];
         const args = parts.slice(1);
-        if (command in replCommands) {
+        if (replCommands[command]) {
             await replCommands[command](...args);
             return true;
         }
@@ -1982,7 +2060,8 @@ Shortcuts:
         const subCmd = args[0];
         switch(subCmd){
             case 'spawn':
-                const type = args[1] || 'researcher';
+                const rawType = args[1] || 'researcher';
+                const type = resolveLegacyAgentType(rawType);
                 const name = args[2] || `agent-${Date.now()}`;
                 const agent = {
                     id: `agent-${Date.now()}`,
@@ -2187,18 +2266,33 @@ Shortcuts:
                 console.log('Terminal commands: create, list, exec, attach, detach');
         }
     }
-    const decoder = new TextDecoder();
-    const encoder = new TextEncoder();
-    while(true){
-        const prompt = replState.currentSession ? `claude-flow:${replState.currentSession}> ` : 'claude-flow> ';
-        await Deno.stdout.write(encoder.encode(prompt));
-        const buf = new Uint8Array(1024);
-        const n = await Deno.stdin.read(buf);
-        if (n === null) break;
-        const input = decoder.decode(buf.subarray(0, n)).trim();
-        const shouldContinue = await processReplCommand(input);
-        if (!shouldContinue) break;
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    function updatePrompt() {
+        rl.setPrompt(replState.currentSession ? `claude-flow:${replState.currentSession}> ` : 'claude-flow> ');
     }
+    updatePrompt();
+    rl.prompt();
+    rl.on('line', async (input)=>{
+        input = input.trim();
+        const shouldContinue = await processReplCommand(input);
+        if (!shouldContinue) {
+            rl.close();
+        } else {
+            updatePrompt();
+            rl.prompt();
+        }
+    });
+    rl.on('SIGINT', ()=>{
+        console.log('\nExiting Claude-Flow...');
+        rl.close();
+        process.exit(0);
+    });
+    return new Promise((resolve)=>{
+        rl.on('close', resolve);
+    });
 }
 function createMinimalClaudeMd() {
     return `# Claude Code Integration
@@ -2515,30 +2609,30 @@ async function createSparcStructureManually() {
         ];
         for (const dir of rooDirectories){
             try {
-                await Deno.mkdir(dir, {
+                await mkdirAsync(dir, {
                     recursive: true
                 });
                 console.log(`  ✓ Created ${dir}/`);
             } catch (err) {
-                if (!(err instanceof Deno.errors.AlreadyExists)) {
+                if (!(err instanceof errors.AlreadyExists)) {
                     throw err;
                 }
             }
         }
         let roomodesContent;
         try {
-            roomodesContent = await fs.readFile('.roomodes');
+            roomodesContent = await readTextFile('.roomodes');
             console.log('  ✓ Using existing .roomodes configuration');
         } catch  {
             roomodesContent = createBasicRoomodesConfig();
-            await fs.writeFile('.roomodes', roomodesContent);
+            await writeTextFile('.roomodes', roomodesContent);
             console.log('  ✓ Created .roomodes configuration');
         }
         const basicWorkflow = createBasicSparcWorkflow();
-        await fs.writeFile('.roo/workflows/basic-tdd.json', basicWorkflow);
+        await writeTextFile('.roo/workflows/basic-tdd.json', basicWorkflow);
         console.log('  ✓ Created .roo/workflows/basic-tdd.json');
         const rooReadme = createRooReadme();
-        await fs.writeFile('.roo/README.md', rooReadme);
+        await writeTextFile('.roo/README.md', rooReadme);
         console.log('  ✓ Created .roo/README.md');
         console.log('  ✅ Basic SPARC structure created successfully');
     } catch (err) {
@@ -2969,7 +3063,7 @@ This SPARC-enabled project follows a systematic development approach:
 For more information about SPARC methodology, see: https://github.com/ruvnet/claude-code-flow/docs/sparc.md
 `;
 }
-if (import.meta.url === `file://${process.argv[1]}`) {
+if (isMainModule(import.meta.url)) {
     await main();
 }