@claude-flow/cli 3.0.0-alpha.2 → 3.0.0-alpha.20

package/src/commands/start.ts

@@ -1,457 +0,0 @@
-/**
- * V3 CLI Start Command
- * System startup for Claude Flow orchestration
- */
-
-import type { Command, CommandContext, CommandResult } from '../types.js';
-import { output } from '../output.js';
-import { confirm, select } from '../prompt.js';
-import { callMCPTool, MCPClientError } from '../mcp-client.js';
-import * as fs from 'fs';
-import * as path from 'path';
-
-// Default configuration
-const DEFAULT_PORT = 3000;
-const DEFAULT_TOPOLOGY = 'hierarchical-mesh';
-const DEFAULT_MAX_AGENTS = 15;
-
-// Check if project is initialized
-function isInitialized(cwd: string): boolean {
-  const configPath = path.join(cwd, '.claude-flow', 'config.yaml');
-  return fs.existsSync(configPath);
-}
-
-// Simple YAML parser for config (basic implementation)
-function parseSimpleYaml(content: string): Record<string, unknown> {
-  const result: Record<string, unknown> = {};
-  const lines = content.split('\n');
-  const stack: Array<{ indent: number; obj: Record<string, unknown>; key?: string }> = [
-    { indent: -1, obj: result }
-  ];
-
-  for (const line of lines) {
-    // Skip comments and empty lines
-    if (line.trim().startsWith('#') || line.trim() === '') continue;
-
-    const match = line.match(/^(\s*)(\w+):\s*(.*)$/);
-    if (!match) continue;
-
-    const indent = match[1].length;
-    const key = match[2];
-    let value: unknown = match[3].trim();
-
-    // Parse value
-    if (value === '' || value === undefined) {
-      value = {};
-    } else if (value === 'true') {
-      value = true;
-    } else if (value === 'false') {
-      value = false;
-    } else if (value === 'null') {
-      value = null;
-    } else if (!isNaN(Number(value as string)) && value !== '') {
-      value = Number(value);
-    } else if (typeof value === 'string' && value.startsWith('"') && value.endsWith('"')) {
-      value = value.slice(1, -1);
-    }
-
-    // Find parent based on indentation
-    while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
-      stack.pop();
-    }
-
-    const parent = stack[stack.length - 1].obj;
-
-    if (typeof value === 'object' && value !== null) {
-      parent[key] = value;
-      stack.push({ indent, obj: value as Record<string, unknown>, key });
-    } else {
-      parent[key] = value;
-    }
-  }
-
-  return result;
-}
-
-// Load configuration
-function loadConfig(cwd: string): Record<string, unknown> | null {
-  const configPath = path.join(cwd, '.claude-flow', 'config.yaml');
-  if (!fs.existsSync(configPath)) return null;
-
-  try {
-    const content = fs.readFileSync(configPath, 'utf-8');
-    return parseSimpleYaml(content);
-  } catch {
-    return null;
-  }
-}
-
-// Main start action
-const startAction = async (ctx: CommandContext): Promise<CommandResult> => {
-  const daemon = ctx.flags.daemon as boolean;
-  const port = (ctx.flags.port as number) || DEFAULT_PORT;
-  const topology = (ctx.flags.topology as string) || DEFAULT_TOPOLOGY;
-  const skipMcp = ctx.flags['skip-mcp'] as boolean;
-  const cwd = ctx.cwd;
-
-  // Check initialization
-  if (!isInitialized(cwd)) {
-    output.printError('Claude Flow is not initialized in this directory');
-    output.printInfo('Run "claude-flow init" first to initialize');
-    return { success: false, exitCode: 1 };
-  }
-
-  // Load configuration
-  const config = loadConfig(cwd);
-  const swarmConfig = (config?.swarm as Record<string, unknown>) || {};
-  const mcpConfig = (config?.mcp as Record<string, unknown>) || {};
-
-  const finalTopology = topology || (swarmConfig.topology as string) || DEFAULT_TOPOLOGY;
-  const maxAgents = (swarmConfig.maxAgents as number) || DEFAULT_MAX_AGENTS;
-  const autoStartMcp = (mcpConfig.autoStart as boolean) !== false && !skipMcp;
-  const mcpPort = port || (mcpConfig.serverPort as number) || DEFAULT_PORT;
-
-  output.writeln();
-  output.writeln(output.bold('Starting Claude Flow V3'));
-  output.writeln();
-
-  const spinner = output.createSpinner({ text: 'Initializing system...' });
-
-  try {
-    // Step 1: Initialize swarm
-    spinner.start();
-    spinner.setText('Initializing V3 swarm...');
-
-    const swarmResult = await callMCPTool<{
-      swarmId: string;
-      topology: string;
-      initializedAt: string;
-      config: Record<string, unknown>;
-    }>('swarm/init', {
-      topology: finalTopology,
-      maxAgents,
-      autoScaling: swarmConfig.autoScale !== false,
-      v3Mode: true
-    });
-
-    spinner.succeed(`Swarm initialized (${finalTopology})`);
-
-    // Step 2: Start MCP server if configured
-    let mcpResult: Record<string, unknown> | null = null;
-    if (autoStartMcp) {
-      spinner.setText('Starting MCP server...');
-      spinner.start();
-
-      try {
-        mcpResult = await callMCPTool<{
-          serverId: string;
-          port: number;
-          transport: string;
-          startedAt: string;
-        }>('mcp/start', {
-          port: mcpPort,
-          transport: mcpConfig.transportType || 'stdio',
-          tools: mcpConfig.tools || ['agent', 'swarm', 'memory', 'task']
-        });
-
-        spinner.succeed(`MCP server started on port ${mcpPort}`);
-      } catch (error) {
-        spinner.fail('MCP server failed to start');
-        output.printWarning(
-          error instanceof MCPClientError
-            ? error.message
-            : String(error)
-        );
-        // Continue without MCP
-      }
-    }
-
-    // Step 3: Run health check
-    spinner.setText('Running health checks...');
-    spinner.start();
-
-    const healthResult = await callMCPTool<{
-      status: 'healthy' | 'degraded' | 'unhealthy';
-      checks: Array<{ name: string; status: string; message?: string }>;
-    }>('swarm/health', {
-      swarmId: swarmResult.swarmId
-    });
-
-    if (healthResult.status === 'healthy') {
-      spinner.succeed('Health checks passed');
-    } else {
-      spinner.fail(`Health check: ${healthResult.status}`);
-    }
-
-    // Success output
-    output.writeln();
-    output.printSuccess('Claude Flow V3 is running!');
-    output.writeln();
-
-    // Status display
-    output.printBox(
-      [
-        `Swarm ID:  ${swarmResult.swarmId}`,
-        `Topology:  ${finalTopology}`,
-        `Max Agents: ${maxAgents}`,
-        `MCP Server: ${autoStartMcp ? `localhost:${mcpPort}` : 'disabled'}`,
-        `Mode:      ${daemon ? 'Daemon' : 'Foreground'}`,
-        `Health:    ${healthResult.status}`
-      ].join('\n'),
-      'System Status'
-    );
-
-    output.writeln();
-    output.writeln(output.bold('Quick Commands:'));
-    output.printList([
-      `${output.highlight('claude-flow status')} - View system status`,
-      `${output.highlight('claude-flow agent spawn -t coder')} - Spawn an agent`,
-      `${output.highlight('claude-flow swarm status')} - View swarm details`,
-      `${output.highlight('claude-flow stop')} - Stop the system`
-    ]);
-
-    // Daemon mode
-    if (daemon) {
-      output.writeln();
-      output.printInfo('Running in daemon mode. Use "claude-flow stop" to stop.');
-
-      // In a real implementation, this would fork a background process
-      // For now, we simulate daemon behavior
-      const daemonPidPath = path.join(cwd, '.claude-flow', 'daemon.pid');
-      fs.writeFileSync(daemonPidPath, String(process.pid));
-    }
-
-    const result = {
-      swarmId: swarmResult.swarmId,
-      topology: finalTopology,
-      maxAgents,
-      mcp: mcpResult ? {
-        port: mcpPort,
-        transport: mcpConfig.transportType || 'stdio'
-      } : null,
-      health: healthResult.status,
-      daemon,
-      startedAt: new Date().toISOString()
-    };
-
-    if (ctx.flags.format === 'json') {
-      output.printJson(result);
-    }
-
-    return { success: true, data: result };
-  } catch (error) {
-    spinner.fail('Startup failed');
-    if (error instanceof MCPClientError) {
-      output.printError(`Failed to start: ${error.message}`);
-    } else {
-      output.printError(`Unexpected error: ${String(error)}`);
-    }
-    return { success: false, exitCode: 1 };
-  }
-};
-
-// Stop subcommand
-const stopCommand: Command = {
-  name: 'stop',
-  description: 'Stop the Claude Flow system',
-  options: [
-    {
-      name: 'force',
-      short: 'f',
-      description: 'Force stop without graceful shutdown',
-      type: 'boolean',
-      default: false
-    },
-    {
-      name: 'timeout',
-      description: 'Shutdown timeout in seconds',
-      type: 'number',
-      default: 30
-    }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const force = ctx.flags.force as boolean;
-    const timeout = ctx.flags.timeout as number;
-
-    output.writeln();
-    output.writeln(output.bold('Stopping Claude Flow'));
-    output.writeln();
-
-    if (!force && ctx.interactive) {
-      const confirmed = await confirm({
-        message: 'Are you sure you want to stop Claude Flow?',
-        default: false
-      });
-
-      if (!confirmed) {
-        output.printInfo('Operation cancelled');
-        return { success: true };
-      }
-    }
-
-    const spinner = output.createSpinner({ text: 'Stopping system...' });
-    spinner.start();
-
-    try {
-      // Stop MCP server
-      spinner.setText('Stopping MCP server...');
-      try {
-        await callMCPTool('mcp/stop', { graceful: !force, timeout });
-        spinner.succeed('MCP server stopped');
-      } catch {
-        spinner.fail('MCP server was not running');
-      }
-
-      // Stop swarm
-      spinner.setText('Stopping swarm...');
-      spinner.start();
-      try {
-        await callMCPTool('swarm/stop', {
-          graceful: !force,
-          timeout,
-          saveState: true
-        });
-        spinner.succeed('Swarm stopped');
-      } catch {
-        spinner.fail('Swarm was not running');
-      }
-
-      // Clean up daemon PID
-      const daemonPidPath = path.join(ctx.cwd, '.claude-flow', 'daemon.pid');
-      if (fs.existsSync(daemonPidPath)) {
-        fs.unlinkSync(daemonPidPath);
-      }
-
-      output.writeln();
-      output.printSuccess('Claude Flow stopped successfully');
-
-      return {
-        success: true,
-        data: { stopped: true, force, stoppedAt: new Date().toISOString() }
-      };
-    } catch (error) {
-      spinner.fail('Stop failed');
-      output.printError(`Failed to stop: ${error instanceof Error ? error.message : String(error)}`);
-      return { success: false, exitCode: 1 };
-    }
-  }
-};
-
-// Restart subcommand
-const restartCommand: Command = {
-  name: 'restart',
-  description: 'Restart the Claude Flow system',
-  options: [
-    {
-      name: 'force',
-      short: 'f',
-      description: 'Force restart',
-      type: 'boolean',
-      default: false
-    }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    output.writeln();
-    output.writeln(output.bold('Restarting Claude Flow'));
-    output.writeln();
-
-    // Stop first
-    const stopCtx = { ...ctx, flags: { ...ctx.flags } };
-    const stopResult = await stopCommand.action!(stopCtx);
-
-    if (stopResult && !stopResult.success) {
-      output.printWarning('Stop failed, attempting to start anyway...');
-    }
-
-    // Wait briefly
-    await new Promise(resolve => setTimeout(resolve, 1000));
-
-    // Start again
-    const startResult = await startAction(ctx);
-
-    return {
-      success: startResult.success,
-      data: {
-        restarted: startResult.success,
-        restartedAt: new Date().toISOString()
-      }
-    };
-  }
-};
-
-// Quick start subcommand
-const quickCommand: Command = {
-  name: 'quick',
-  aliases: ['q'],
-  description: 'Quick start with default settings',
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    // Initialize if needed
-    if (!isInitialized(ctx.cwd)) {
-      output.printInfo('Project not initialized, running init first...');
-      output.writeln();
-
-      // Call init with minimal settings
-      const { initCommand } = await import('./init.js');
-      const initCtx = {
-        ...ctx,
-        flags: { ...ctx.flags, minimal: true }
-      };
-      await initCommand.action!(initCtx);
-      output.writeln();
-    }
-
-    // Start with defaults
-    return startAction({
-      ...ctx,
-      flags: { ...ctx.flags, topology: 'mesh' }
-    });
-  }
-};
-
-// Main start command
-export const startCommand: Command = {
-  name: 'start',
-  description: 'Start the Claude Flow orchestration system',
-  subcommands: [stopCommand, restartCommand, quickCommand],
-  options: [
-    {
-      name: 'daemon',
-      short: 'd',
-      description: 'Run as daemon in background',
-      type: 'boolean',
-      default: false
-    },
-    {
-      name: 'port',
-      short: 'p',
-      description: 'MCP server port',
-      type: 'number',
-      default: DEFAULT_PORT
-    },
-    {
-      name: 'topology',
-      short: 't',
-      description: 'Swarm topology (hierarchical-mesh, mesh, hierarchical, ring, star)',
-      type: 'string',
-      choices: ['hierarchical-mesh', 'mesh', 'hierarchical', 'ring', 'star']
-    },
-    {
-      name: 'skip-mcp',
-      description: 'Skip starting MCP server',
-      type: 'boolean',
-      default: false
-    }
-  ],
-  examples: [
-    { command: 'claude-flow start', description: 'Start with configuration defaults' },
-    { command: 'claude-flow start --daemon', description: 'Start as background daemon' },
-    { command: 'claude-flow start --port 3001', description: 'Start MCP on custom port' },
-    { command: 'claude-flow start --topology mesh', description: 'Start with mesh topology' },
-    { command: 'claude-flow start --skip-mcp', description: 'Start without MCP server' },
-    { command: 'claude-flow start quick', description: 'Quick start with defaults' },
-    { command: 'claude-flow start stop', description: 'Stop the running system' }
-  ],
-  action: startAction
-};
-
-export default startCommand;