claude-flow-novice 1.3.0 → 1.3.2

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

@@ -0,0 +1,530 @@
+// sparc.js - SPARC development mode commands
+import { printSuccess, printError, printWarning } from '../utils.js';
+import { promises as fs } from 'fs';
+import { spawn } from 'child_process';
+import { promisify } from 'util';
+import { createSparcPrompt } from './sparc-modes/index.js';
+import { cwd, exit, existsSync } from '../node-compat.js';
+import process from 'process';
+
+export async function sparcCommand(subArgs, flags) {
+  const sparcCmd = subArgs[0];
+
+  // Show help if requested or no args
+  if (
+    flags.help ||
+    flags.h ||
+    sparcCmd === '--help' ||
+    sparcCmd === '-h' ||
+    (!sparcCmd && Object.keys(flags).length === 0)
+  ) {
+    showSparcHelp();
+    return;
+  }
+
+  // Merge flags back into subArgs for backward compatibility
+  const mergedArgs = [...subArgs];
+  for (const [key, value] of Object.entries(flags)) {
+    if (key === 'non-interactive' || key === 'n') {
+      mergedArgs.push('--non-interactive');
+    } else if (key === 'dry-run' || key === 'd') {
+      mergedArgs.push('--dry-run');
+    } else if (key === 'verbose' || key === 'v') {
+      mergedArgs.push('--verbose');
+    } else if (key === 'no-permissions') {
+      mergedArgs.push('--no-permissions');
+    } else if (key === 'enable-permissions') {
+      mergedArgs.push('--enable-permissions');
+    } else if (key === 'namespace') {
+      mergedArgs.push('--namespace', value);
+    } else if (key === 'config') {
+      mergedArgs.push('--config', value);
+    } else if (key === 'interactive' || key === 'i') {
+      mergedArgs.push('--interactive');
+    }
+  }
+
+  // Check if first arg is a known subcommand
+  const knownSubcommands = ['modes', 'info', 'run', 'tdd'];
+
+  if (!knownSubcommands.includes(sparcCmd)) {
+    // If not a known subcommand, treat it as a task description for sparc orchestrator
+    // Insert 'run' and 'sparc' to make it: ['run', 'sparc', ...rest of args]
+    mergedArgs.unshift('run', 'sparc');
+  }
+
+  // Now process the command
+  const actualCmd = mergedArgs[0];
+
+  switch (actualCmd) {
+    case 'modes':
+      await listSparcModes(mergedArgs);
+      break;
+
+    case 'info':
+      await showModeInfo(mergedArgs);
+      break;
+
+    case 'run':
+      await runSparcMode(mergedArgs, flags);
+      break;
+
+    case 'tdd':
+      await runTddWorkflow(mergedArgs);
+      break;
+
+    default:
+      showSparcHelp();
+  }
+}
+
+async function listSparcModes(subArgs) {
+  try {
+    // Get the actual working directory where the command was run from
+    const workingDir = process.env.PWD || cwd();
+    const configPath = `${workingDir}/.roomodes`;
+    let configContent;
+    try {
+      configContent = await fs.readFile(configPath, 'utf8');
+    } catch (error) {
+      printError('SPARC configuration file (.roomodes) not found');
+      console.log(`Please ensure .roomodes file exists in: ${workingDir}`);
+      console.log();
+      console.log('To enable SPARC development modes, run:');
+      console.log('  npx claude-flow@latest init --sparc');
+      console.log();
+      console.log('This will create:');
+      console.log('  • .roomodes file with 17+ SPARC development modes');
+      console.log('  • .roo/ directory with templates and workflows');
+      console.log('  • SPARC-enhanced CLAUDE.md configuration');
+      return;
+    }
+
+    const config = JSON.parse(configContent);
+    const verbose = subArgs.includes('--verbose') || subArgs.includes('-v');
+
+    printSuccess('Available SPARC Modes:');
+    console.log();
+
+    for (const mode of config.customModes) {
+      console.log(`• ${mode.name} (${mode.slug})`);
+      if (verbose) {
+        console.log(`  ${mode.roleDefinition}`);
+        console.log(`  Tools: ${mode.groups.join(', ')}`);
+        console.log();
+      }
+    }
+
+    if (!verbose) {
+      console.log();
+      console.log('Use --verbose for detailed descriptions');
+    }
+  } catch (err) {
+    printError(`Failed to list SPARC modes: ${err.message}`);
+  }
+}
+
+async function showModeInfo(subArgs) {
+  const modeSlug = subArgs[1];
+  if (!modeSlug) {
+    printError('Usage: sparc info <mode-slug>');
+    return;
+  }
+
+  try {
+    // Get the actual working directory where the command was run from
+    const workingDir = process.env.PWD || cwd();
+    const configPath = `${workingDir}/.roomodes`;
+    let configContent;
+    try {
+      configContent = await fs.readFile(configPath, 'utf8');
+    } catch (error) {
+      printError('SPARC configuration file (.roomodes) not found');
+      console.log(`Please ensure .roomodes file exists in: ${workingDir}`);
+      console.log();
+      console.log('To enable SPARC development modes, run:');
+      console.log('  npx claude-flow@latest init --sparc');
+      return;
+    }
+    const config = JSON.parse(configContent);
+    const mode = config.customModes.find((m) => m.slug === modeSlug);
+
+    if (!mode) {
+      printError(`Mode not found: ${modeSlug}`);
+      console.log('Available modes:');
+      for (const m of config.customModes) {
+        console.log(`  ${m.slug} - ${m.name}`);
+      }
+      return;
+    }
+
+    printSuccess(`SPARC Mode: ${mode.name}`);
+    console.log();
+    console.log('Role Definition:');
+    console.log(mode.roleDefinition);
+    console.log();
+    console.log('Custom Instructions:');
+    console.log(mode.customInstructions);
+    console.log();
+    console.log('Tool Groups:');
+    console.log(mode.groups.join(', '));
+    console.log();
+    console.log('Source:');
+    console.log(mode.source);
+  } catch (err) {
+    printError(`Failed to show mode info: ${err.message}`);
+  }
+}
+
+async function runSparcMode(subArgs, flags) {
+  const runModeSlug = subArgs[1];
+  const taskDescription = subArgs
+    .slice(2)
+    .filter((arg) => !arg.startsWith('--'))
+    .join(' ');
+
+  if (!runModeSlug || !taskDescription) {
+    printError('Usage: sparc run <mode-slug> <task-description>');
+    return;
+  }
+
+  try {
+    // Get the actual working directory where the command was run from
+    const workingDir = process.env.PWD || cwd();
+    const configPath = `${workingDir}/.roomodes`;
+    let configContent;
+    try {
+      configContent = await fs.readFile(configPath, 'utf8');
+    } catch (error) {
+      printError('SPARC configuration file (.roomodes) not found');
+      console.log(`Please ensure .roomodes file exists in: ${workingDir}`);
+      console.log();
+      console.log('To enable SPARC development modes, run:');
+      console.log('  npx claude-flow@latest init --sparc');
+      return;
+    }
+    const config = JSON.parse(configContent);
+    const mode = config.customModes.find((m) => m.slug === runModeSlug);
+
+    if (!mode) {
+      printError(`Mode not found: ${runModeSlug}`);
+      return;
+    }
+
+    // Build enhanced SPARC prompt
+    const memoryNamespace = subArgs.includes('--namespace')
+      ? subArgs[subArgs.indexOf('--namespace') + 1]
+      : mode.slug;
+
+    const enhancedTask = createSparcPrompt(mode, taskDescription, memoryNamespace);
+
+    // Build tools based on mode groups
+    const tools = buildToolsFromGroups(mode.groups);
+    const toolsList = Array.from(tools).join(',');
+    const instanceId = `sparc-${runModeSlug}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+
+    if (subArgs.includes('--dry-run') || subArgs.includes('-d')) {
+      printWarning('DRY RUN - SPARC Mode Configuration:');
+      console.log(`Mode: ${mode.name} (${mode.slug})`);
+      console.log(`Instance ID: ${instanceId}`);
+
+      const enablePermissions = subArgs.includes('--enable-permissions');
+      if (!enablePermissions) {
+        console.log(`Tools: ALL (via --dangerously-skip-permissions)`);
+        console.log(`Permissions: Will be auto-skipped`);
+      } else {
+        console.log(`Tools: ${toolsList}`);
+        console.log(`Permissions: Will prompt for actions`);
+      }
+
+      console.log(`Task: ${taskDescription}`);
+      console.log();
+      console.log('Enhanced prompt preview:');
+      console.log(enhancedTask.substring(0, 300) + '...');
+      return;
+    }
+
+    printSuccess(`Starting SPARC mode: ${mode.name}`);
+    console.log(`📝 Instance ID: ${instanceId}`);
+    console.log(`🎯 Mode: ${mode.slug}`);
+
+    const isNonInteractive = subArgs.includes('--non-interactive') || subArgs.includes('-n');
+    const enablePermissions = subArgs.includes('--enable-permissions');
+
+    if (!enablePermissions) {
+      console.log(`🔧 Tools: ALL (including MCP and WebSearch via --dangerously-skip-permissions)`);
+      console.log(`⚡ Permissions: Auto-skipped (--dangerously-skip-permissions)`);
+    } else {
+      console.log(`🔧 Tools: ${toolsList}`);
+      console.log(`✅ Permissions: Enabled (will prompt for actions)`);
+    }
+    console.log(`📋 Task: ${taskDescription}`);
+
+    if (isNonInteractive) {
+      console.log(`🚀 Running in non-interactive mode with stream-json output`);
+      console.log();
+
+      // Show debug info immediately for non-interactive mode
+      console.log('🔍 Debug: Preparing claude command...');
+      console.log(`Enhanced prompt length: ${enhancedTask.length} characters`);
+      console.log(`First 200 chars of prompt: ${enhancedTask.substring(0, 200)}...`);
+    }
+    console.log();
+
+    // Execute Claude with SPARC configuration
+    await executeClaude(enhancedTask, toolsList, instanceId, memoryNamespace, subArgs);
+  } catch (err) {
+    printError(`Failed to run SPARC mode: ${err.message}`);
+  }
+}
+
+async function runTddWorkflow(subArgs) {
+  const tddTaskDescription = subArgs.slice(1).join(' ');
+
+  if (!tddTaskDescription) {
+    printError('Usage: sparc tdd <task-description>');
+    return;
+  }
+
+  printSuccess('Starting SPARC TDD Workflow');
+  console.log('Following Test-Driven Development with SPARC methodology');
+  console.log();
+
+  const phases = [
+    { name: 'Red', description: 'Write failing tests', mode: 'tdd' },
+    { name: 'Green', description: 'Minimal implementation', mode: 'code' },
+    { name: 'Refactor', description: 'Optimize and clean', mode: 'tdd' },
+  ];
+
+  console.log('TDD Phases:');
+  for (const phase of phases) {
+    console.log(`  ${phase.name}: ${phase.description} (${phase.mode} mode)`);
+  }
+  console.log();
+
+  if (subArgs.includes('--interactive') || subArgs.includes('-i')) {
+    printSuccess('Starting interactive TDD workflow');
+    console.log('This would walk through each phase interactively');
+    console.log('Run each phase with: sparc run <mode> "Phase: <task>"');
+  } else {
+    printSuccess('Starting full TDD workflow');
+    console.log('This would execute all phases automatically');
+    console.log('Use --interactive for step-by-step control');
+  }
+}
+
+// Remove the createSparcPrompt function from here as it's now imported from sparc-modes/index.js
+
+function buildToolsFromGroups(groups) {
+  const toolMappings = {
+    read: ['View', 'LS', 'GlobTool', 'GrepTool'],
+    edit: ['Edit', 'Replace', 'MultiEdit', 'Write'],
+    browser: ['WebFetch'],
+    mcp: ['mcp_tools'],
+    command: ['Bash', 'Terminal'],
+  };
+
+  const tools = new Set(['View', 'Edit', 'Bash']); // Always include basic tools
+
+  for (const group of groups) {
+    if (Array.isArray(group)) {
+      const groupName = group[0];
+      if (toolMappings[groupName]) {
+        toolMappings[groupName].forEach((tool) => tools.add(tool));
+      }
+    } else if (toolMappings[group]) {
+      toolMappings[group].forEach((tool) => tools.add(tool));
+    }
+  }
+
+  return tools;
+}
+
+async function executeClaude(enhancedTask, toolsList, instanceId, memoryNamespace, subArgs) {
+  // Check for non-interactive mode
+  const isNonInteractive = subArgs.includes('--non-interactive') || subArgs.includes('-n');
+  const enablePermissions = subArgs.includes('--enable-permissions');
+
+  // Build arguments array correctly
+  const claudeArgs = [];
+  claudeArgs.push(enhancedTask);
+
+  // Add --dangerously-skip-permissions by default unless --enable-permissions is set
+  if (!enablePermissions) {
+    claudeArgs.push('--dangerously-skip-permissions');
+  }
+
+  if (isNonInteractive) {
+    // Non-interactive mode: add additional flags
+    claudeArgs.push('-p'); // Use short form for print
+    claudeArgs.push('--output-format', 'stream-json');
+    claudeArgs.push('--verbose');
+  } else {
+    // Interactive mode - check for verbose flag
+    if (subArgs.includes('--verbose') || subArgs.includes('-v')) {
+      claudeArgs.push('--verbose');
+    }
+  }
+
+  // When using --dangerously-skip-permissions, we don't need to specify individual tools
+  // as it enables ALL tools including mcp and websearch
+  // Only add --allowedTools if permissions are enabled
+  if (enablePermissions) {
+    claudeArgs.push('--allowedTools', toolsList);
+  }
+
+  if (subArgs.includes('--config')) {
+    const configIndex = subArgs.indexOf('--config');
+    claudeArgs.push('--mcp-config', subArgs[configIndex + 1]);
+  }
+
+  // Show debug info for non-interactive mode or when verbose
+  if (isNonInteractive || subArgs.includes('--verbose') || subArgs.includes('-v')) {
+    console.log('\n🔍 Debug: Executing claude with:');
+    console.log('Command: claude');
+    console.log(
+      'Permissions:',
+      enablePermissions
+        ? '✅ Enabled (will prompt)'
+        : '⚡ Skipped (--dangerously-skip-permissions)',
+    );
+    console.log(
+      'Tools:',
+      enablePermissions ? `Specified: ${toolsList}` : 'ALL tools enabled (MCP, WebSearch, etc.)',
+    );
+    console.log('Mode:', isNonInteractive ? '🤖 Non-interactive' : '💬 Interactive');
+    console.log('Args array length:', claudeArgs.length);
+    console.log('First arg (prompt) length:', claudeArgs[0].length, 'characters');
+
+    if (isNonInteractive) {
+      console.log('First 200 chars of prompt:', claudeArgs[0].substring(0, 200) + '...');
+      console.log('\nAll arguments:');
+      claudeArgs.forEach((arg, i) => {
+        if (i === 0) {
+          console.log(`  [0] <SPARC prompt with ${arg.length} characters>`);
+        } else {
+          console.log(`  [${i}] ${arg}`);
+        }
+      });
+      console.log('\nFull command structure:');
+      console.log('claude "<SPARC prompt>" ' + claudeArgs.slice(1).join(' '));
+    }
+    console.log();
+  }
+
+  try {
+    // Log the actual command being executed
+    console.log('\n🚀 Executing command:');
+    console.log(`Command: claude`);
+    console.log(`Working Directory: ${cwd()}`);
+    console.log(`Number of args: ${claudeArgs.length}`);
+
+    // Check if claude command exists
+    try {
+      const checkResult = await new Promise((resolve) => {
+        const child = spawn('which', ['claude'], {
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        child.stdout?.on('data', (data) => {
+          stdout += data;
+        });
+        child.on('close', (code) => {
+          resolve({ success: code === 0, stdout: Buffer.from(stdout) });
+        });
+      });
+      if (!checkResult.success) {
+        console.error('❌ Error: claude command not found in PATH');
+        console.error('Please ensure claude CLI is installed and in your PATH');
+        return;
+      }
+      const claudePath = new TextDecoder().decode(checkResult.stdout).trim();
+      console.log(`Claude path: ${claudePath}`);
+    } catch (e) {
+      console.warn('⚠️  Could not verify claude command location');
+    }
+
+    // Use spawn for claude command
+    const env = { ...process.env, CLAUDE_INSTANCE_ID: instanceId };
+
+    console.log('\n📡 Spawning claude process...\n');
+    const child = spawn('claude', claudeArgs, {
+      cwd: cwd(),
+      env: env,
+      stdio: 'inherit',
+    });
+    const status = await new Promise((resolve) => {
+      child.on('close', (code) => {
+        resolve({ code, success: code === 0 });
+      });
+    });
+
+    if (status.success) {
+      printSuccess(`SPARC instance ${instanceId} completed successfully`);
+    } else {
+      printError(`SPARC instance ${instanceId} exited with code ${status.code}`);
+    }
+  } catch (err) {
+    printError(`Failed to execute Claude: ${err.message}`);
+    console.error('Stack trace:', err.stack);
+  }
+}
+
+function showSparcHelp() {
+  console.log('SPARC commands:');
+  console.log('  <task>                   Run SPARC orchestrator (default mode)');
+  console.log('  modes                    List available SPARC development modes');
+  console.log('  info <mode>              Show detailed information about a mode');
+  console.log('  run <mode> <task>        Execute a task in specified SPARC mode');
+  console.log('  tdd <task>               Run Test-Driven Development workflow');
+  console.log();
+  console.log('Examples:');
+  console.log('  claude-flow sparc "orchestrate app development"    # Uses sparc orchestrator');
+  console.log('  claude-flow sparc modes --verbose');
+  console.log('  claude-flow sparc info architect');
+  console.log('  claude-flow sparc run code "implement user authentication"');
+  console.log('  claude-flow sparc run code "add login feature" --non-interactive');
+  console.log('  claude-flow sparc run tdd "create test suite" --namespace tests');
+  console.log('  claude-flow sparc tdd "payment processing system" --interactive');
+  console.log();
+  console.log('Parallel Execution with BatchTool:');
+  console.log('  # Run multiple SPARC modes concurrently');
+  console.log('  batchtool run --parallel \\');
+  console.log('    "npx claude-flow sparc run code \'user service\' --non-interactive" \\');
+  console.log('    "npx claude-flow sparc run code \'auth service\' --non-interactive" \\');
+  console.log('    "npx claude-flow sparc run tdd \'test suite\' --non-interactive"');
+  console.log();
+  console.log('  # Boomerang orchestration pattern');
+  console.log('  batchtool orchestrate --boomerang \\');
+  console.log(
+    '    --research "npx claude-flow sparc run ask \'requirements\' --non-interactive" \\',
+  );
+  console.log('    --design "npx claude-flow sparc run architect \'system\' --non-interactive" \\');
+  console.log('    --implement "npx claude-flow sparc run code \'features\' --non-interactive" \\');
+  console.log('    --test "npx claude-flow sparc run tdd \'validation\' --non-interactive"');
+  console.log();
+  console.log('Flags:');
+  console.log('  --dry-run, -d            Show configuration without executing');
+  console.log('  --verbose, -v            Show detailed output');
+  console.log('  --interactive, -i        Run TDD workflow interactively');
+  console.log('  --non-interactive, -n    Run in non-interactive mode with stream-json output');
+  console.log('  --enable-permissions     Enable permission prompts (default: skip permissions)');
+  console.log('  --namespace <ns>         Use custom memory namespace (default: mode slug)');
+  console.log('  --config <path>          Use custom MCP configuration file');
+  console.log();
+  console.log('Permission Behavior:');
+  console.log('  By default, SPARC runs with --dangerously-skip-permissions for efficiency');
+  console.log('  Use --enable-permissions to restore permission prompts if needed');
+  console.log();
+  console.log('Non-Interactive Mode:');
+  console.log('  When using --non-interactive, claude will be executed with:');
+  console.log('  - --dangerously-skip-permissions (unless --enable-permissions is set)');
+  console.log('  - -p (print mode for streaming output)');
+  console.log('  - --output-format stream-json (structured output format)');
+  console.log('  - --verbose (detailed execution logs)');
+  console.log();
+  console.log('Boomerang Pattern:');
+  console.log('  A cyclical orchestration where outputs from one phase feed into the next:');
+  console.log('  Research → Design → Implement → Test → Optimize → Loop back');
+  console.log('  Perfect for iterative development with continuous refinement');
+}

package/src/cli/simple-commands/start-ui.js

@@ -0,0 +1,147 @@
+// start-ui.js - Standalone UI launcher (Web UI by default)
+import { printSuccess, printError, printWarning, printInfo } from '../utils.js';
+import { compat } from '../runtime-detector.js';
+
+export async function launchUI(args = []) {
+  try {
+    // Parse arguments
+    const portValue = getArgValue(args, '--port') || getArgValue(args, '-p');
+    const port = portValue ? parseInt(portValue) : 3000;
+
+    const terminal = args.includes('--terminal') || args.includes('-t');
+    const web = !terminal; // Default to web UI unless terminal is specified
+
+    if (web) {
+      // Launch Web UI
+      try {
+        const { ClaudeCodeWebServer } = await import('./web-server.js');
+        const webServer = new ClaudeCodeWebServer(port);
+        await webServer.start();
+
+        printSuccess('🌐 Claude Flow Web UI is running!');
+        console.log(`📍 Open your browser to: http://localhost:${port}/console`);
+        console.log();
+        console.log('Features:');
+        console.log('  ✨ Access all 71+ MCP tools through the web interface');
+        console.log('  📊 Real-time monitoring and analytics');
+        console.log('  🧠 Neural network training and management');
+        console.log('  🔄 Workflow automation and SPARC modes');
+        console.log('  🐙 GitHub integration and DAA management');
+        console.log();
+        console.log('Press Ctrl+C to stop the server');
+
+        // Open browser if possible
+        try {
+          const openCommand =
+            process.platform === 'darwin'
+              ? 'open'
+              : process.platform === 'win32'
+                ? 'start'
+                : 'xdg-open';
+
+          const { exec } = await import('child_process');
+          exec(`${openCommand} http://localhost:${port}/console`);
+        } catch {
+          // Browser opening failed, that's okay
+        }
+
+        // Handle shutdown
+        const shutdown = async () => {
+          console.log('\n' + '⏹️  Shutting down Web UI...');
+          await webServer.stop();
+          printSuccess('✓ Shutdown complete');
+          process.exit(0);
+        };
+
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+
+        // Keep process alive
+        await new Promise(() => {});
+      } catch (err) {
+        printError(`Failed to launch Web UI: ${err.message}`);
+        console.error('Stack trace:', err.stack);
+        console.log();
+        printWarning('Falling back to terminal UI...');
+        // Fall back to terminal UI
+        await launchTerminalUI(port);
+      }
+    }
+
+    if (terminal) {
+      await launchTerminalUI(port);
+    }
+  } catch (err) {
+    printError(`Failed to launch UI: ${err.message}`);
+    console.error('Stack trace:', err.stack);
+  }
+}
+
+async function launchTerminalUI(port) {
+  // Launch Terminal UI
+  try {
+    // Try enhanced UI first
+    const { launchEnhancedUI } = await import('./process-ui-enhanced.js');
+    await launchEnhancedUI();
+  } catch (err) {
+    // Try simple UI as fallback
+    try {
+      let ProcessManager, ProcessUI;
+      try {
+        // Try the compiled version first (for production/npm packages)
+        const pmModule = await import('../../../dist/cli/commands/start/process-manager.js');
+        const puiModule = await import('../../../dist/cli/commands/start/process-ui-simple.js');
+        ProcessManager = pmModule.ProcessManager;
+        ProcessUI = puiModule.ProcessUI;
+      } catch (distError) {
+        // If dist version not found, try TypeScript version (for development)
+        const pmModule = await import('../commands/start/process-manager.ts');
+        const puiModule = await import('../commands/start/process-ui-simple.ts');
+        ProcessManager = pmModule.ProcessManager;
+        ProcessUI = puiModule.ProcessUI;
+      }
+
+      printSuccess('🚀 Claude-Flow Process Management UI');
+      console.log('─'.repeat(60));
+
+      // Initialize process manager
+      const processManager = new ProcessManager();
+      await processManager.initialize();
+
+      // Start the UI
+      const ui = new ProcessUI(processManager);
+      await ui.start();
+
+      // Cleanup on exit
+      await processManager.stopAll();
+      console.log();
+      printSuccess('✓ Shutdown complete');
+    } catch (fallbackErr) {
+      printError(`Failed to launch Terminal UI: ${fallbackErr.message}`);
+      console.error('Stack trace:', fallbackErr.stack);
+
+      // Final fallback
+      console.log();
+      printWarning('UI launch failed. Use these commands instead:');
+      console.log();
+      console.log('Process Management Commands:');
+      console.log('  • Start all: claude-flow start');
+      console.log('  • Check status: claude-flow status');
+      console.log('  • View logs: claude-flow logs');
+      console.log('  • Stop: claude-flow stop');
+    }
+  }
+}
+
+function getArgValue(args, flag) {
+  const index = args.indexOf(flag);
+  if (index !== -1 && index < args.length - 1) {
+    return args[index + 1];
+  }
+  return null;
+}
+
+// Run if called directly
+if (import.meta.main) {
+  await launchUI();
+}