claude-flow 2.5.0-alpha.136 → 2.5.0-alpha.138

package/bin/claude-flow

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

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

@@ -1,13 +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
 
-🎯 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]
@@ -141,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){
@@ -151,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':
@@ -168,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;
     }
@@ -180,6 +263,7 @@ async function main() {
             return;
         } catch (err) {
             printError(err.message);
+            console.log(`\nRun "claude-flow ${command} --help" for usage information.`);
             return;
         }
     }
@@ -199,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');
@@ -228,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');
@@ -277,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
                     };
@@ -1234,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(),
@@ -1247,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.');
@@ -1810,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() {
@@ -1888,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;
@@ -1916,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}`);
             }
@@ -1950,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;
         }
@@ -1971,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()}`,
@@ -2176,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
@@ -2504,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) {
@@ -2955,134 +3060,6 @@ This SPARC-enabled project follows a systematic development approach:
 - Document architectural decisions in memory for future reference
 - Regular security reviews for any authentication or data handling code
 
-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]}`) {
-    await main();
-}
-
-//# sourceMappingURL=simple-cli.js.mapsign choices"
-
-# Store test results and coverage
-npx claude-flow memory store test_coverage "Authentication module: 95% coverage, all tests passing"
-
-# Query previous work
-npx claude-flow memory query auth_implementation
-
-# Export project memory
-npx claude-flow memory export project_backup.json
-\`\`\`
-
-### Memory Namespaces
-- **\`spec\`**: Requirements and specifications
-- **\`arch\`**: Architecture and design decisions
-- **\`impl\`**: Implementation notes and code patterns
-- **\`test\`**: Test results and coverage reports
-- **\`debug\`**: Bug reports and resolution notes
-
-## Workflow Examples
-
-### Feature Development Workflow
-\`\`\`bash
-# 1. Start with specification
-npx claude-flow sparc run spec-pseudocode "User profile management feature"
-
-# 2. Design architecture
-npx claude-flow sparc run architect "Profile service architecture with data validation"
-
-# 3. Implement with TDD
-npx claude-flow sparc tdd "user profile CRUD operations"
-
-# 4. Security review
-npx claude-flow sparc run security-review "profile data access and validation"
-
-# 5. Integration testing
-npx claude-flow sparc run integration "profile service with authentication system"
-
-# 6. Documentation
-npx claude-flow sparc run docs-writer "profile service API documentation"
-\`\`\`
-
-### Bug Fix Workflow
-\`\`\`bash
-# 1. Debug and analyze
-npx claude-flow sparc run debug "authentication token expiration issue"
-
-# 2. Write regression tests
-npx claude-flow sparc run tdd "token refresh mechanism tests"
-
-# 3. Implement fix
-npx claude-flow sparc run code "fix token refresh in authentication service"
-
-# 4. Security review
-npx claude-flow sparc run security-review "token handling security implications"
-\`\`\`
-
-## Configuration Files
-
-### SPARC Configuration
-- **\`.roomodes\`**: SPARC mode definitions and configurations
-- **\`.roo/\`**: Templates, workflows, and mode-specific rules
-
-### Claude-Flow Configuration
-- **\`memory/\`**: Persistent memory and session data
-- **\`coordination/\`**: Multi-agent coordination settings
-
-## Git Workflow Integration
-
-### Commit Strategy with SPARC
-- **Specification commits**: After completing requirements analysis
-- **Architecture commits**: After design phase completion
-- **TDD commits**: After each Red-Green-Refactor cycle
-- **Integration commits**: After successful component integration
-- **Documentation commits**: After completing documentation updates
-
-### Branch Strategy
-- **\`feature/sparc-<feature-name>\`**: Feature development with SPARC methodology
-- **\`hotfix/sparc-<issue>\`**: Bug fixes using SPARC debugging workflow
-- **\`refactor/sparc-<component>\`**: Refactoring using optimization mode
-
-## Troubleshooting
-
-### Common SPARC Issues
-- **Mode not found**: Check \`.roomodes\` file exists and is valid JSON
-- **Memory persistence**: Ensure \`memory/\` directory has write permissions
-- **Tool access**: Verify required tools are available for the selected mode
-- **Namespace conflicts**: Use unique memory namespaces for different features
-
-### Debug Commands
-\`\`\`bash
-# Check SPARC configuration
-npx claude-flow sparc modes
-
-# Verify memory system
-npx claude-flow memory stats
-
-# Check system status
-npx claude-flow status
-
-# View detailed mode information
-npx claude-flow sparc info <mode-name>
-\`\`\`
-
-## Project Architecture
-
-This SPARC-enabled project follows a systematic development approach:
-- **Clear separation of concerns** through modular design
-- **Test-driven development** ensuring reliability and maintainability
-- **Iterative refinement** for continuous improvement
-- **Comprehensive documentation** for team collaboration
-- **AI-assisted development** through specialized SPARC modes
-
-## Important Notes
-
-- Always run tests before committing (\`npm run test\`)
-- Use SPARC memory system to maintain context across sessions
-- Follow the Red-Green-Refactor cycle during TDD phases
-- Document architectural decisions in memory for future reference
-- Regular security reviews for any authentication or data handling code
-
 For more information about SPARC methodology, see: https://github.com/ruvnet/claude-code-flow/docs/sparc.md
 `;
 }