claude-flow 1.0.0

package/src/cli/commands/start.ts

@@ -0,0 +1,156 @@
+/**
+ * Start command for Claude-Flow
+ */
+
+import { Command } from '@cliffy/command';
+import { colors } from '@cliffy/ansi/colors';
+import { Orchestrator } from '../../core/orchestrator.ts';
+import { eventBus } from '../../core/event-bus.ts';
+import { logger } from '../../core/logger.ts';
+import { configManager } from '../../core/config.ts';
+import { TerminalManager } from '../../terminal/manager.ts';
+import { MemoryManager } from '../../memory/manager.ts';
+import { CoordinationManager } from '../../coordination/manager.ts';
+import { MCPServer } from '../../mcp/server.ts';
+import { SystemEvents } from '../../utils/types.ts';
+// Spinner is not available in the current cliffy version, use simple text instead
+
+export const startCommand = new Command()
+  .description('Start the Claude-Flow orchestration system')
+  .option('-d, --daemon', 'Run as daemon in background')
+  .option('-p, --port <port:number>', 'MCP server port', { default: 3000 })
+  .option('--mcp-transport <transport:string>', 'MCP transport type (stdio, http)', {
+    default: 'stdio',
+  })
+  .action(async (options: any) => {
+    console.log(colors.cyan('Starting Claude-Flow...'));
+
+    try {
+      // Load configuration
+      const config = await configManager.load(options.config || undefined);
+      
+      // Override MCP settings from CLI options
+      if (options.port) {
+        config.mcp.port = options.port;
+      }
+      if (options.mcpTransport) {
+        config.mcp.transport = options.mcpTransport as any;
+      }
+
+      // Create components
+      const terminalManager = new TerminalManager(
+        config.terminal,
+        eventBus,
+        logger,
+      );
+
+      const memoryManager = new MemoryManager(
+        config.memory,
+        eventBus,
+        logger,
+      );
+
+      const coordinationManager = new CoordinationManager(
+        config.coordination,
+        eventBus,
+        logger,
+      );
+
+      const mcpServer = new MCPServer(
+        config.mcp,
+        eventBus,
+        logger,
+      );
+
+      // Create orchestrator
+      const orchestrator = new Orchestrator(
+        config,
+        terminalManager,
+        memoryManager,
+        coordinationManager,
+        mcpServer,
+        eventBus,
+        logger,
+      );
+
+      // Initialize orchestrator
+      await orchestrator.initialize();
+
+      // spinner.stop();
+      console.log(colors.green.bold('✓'), 'Claude-Flow started successfully!');
+      
+      if (config.mcp.transport === 'http') {
+        console.log(colors.cyan('MCP server listening on'), 
+          colors.yellow(`http://${config.mcp.host || 'localhost'}:${config.mcp.port}`));
+      } else {
+        console.log(colors.cyan('MCP server listening on'), colors.yellow('stdio'));
+      }
+
+      // Set up graceful shutdown
+      const shutdown = async () => {
+        console.log('\n' + colors.yellow('Shutting down Claude-Flow...'));
+        eventBus.emit('shutdown');
+        await orchestrator.shutdown();
+        console.log(colors.green.bold('✓'), 'Shutdown complete');
+        Deno.exit(0);
+      };
+
+      Deno.addSignalListener('SIGINT', shutdown);
+      Deno.addSignalListener('SIGTERM', shutdown);
+
+      // Set up event listeners for logging
+      setupEventListeners();
+
+      if (options.daemon) {
+        console.log(colors.gray('Running in daemon mode. Press Ctrl+C to stop.'));
+        // Keep the process running
+        await new Promise<void>((resolve) => {
+          // This promise will only resolve when shutdown is called
+          eventBus.once('shutdown', resolve);
+        });
+      } else {
+        console.log(colors.gray('Press Ctrl+C to stop.'));
+        // Keep the process running in interactive mode
+        await new Promise<void>((resolve) => {
+          // This promise will only resolve when shutdown is called
+          eventBus.once('shutdown', resolve);
+        });
+      }
+    } catch (error) {
+      // spinner.stop();
+      throw error;
+    }
+  });
+
+function setupEventListeners(): void {
+  // Log important events
+  eventBus.on(SystemEvents.AGENT_SPAWNED, (data: any) => {
+    const { agentId, profile } = data;
+    console.log(colors.blue('→'), `Agent spawned: ${colors.cyan(agentId)} (${profile.type})`);
+  });
+
+  eventBus.on(SystemEvents.AGENT_TERMINATED, (data: any) => {
+    const { agentId, reason } = data;
+    console.log(colors.red('←'), `Agent terminated: ${colors.cyan(agentId)} - ${reason}`);
+  });
+
+  eventBus.on(SystemEvents.TASK_ASSIGNED, (data: any) => {
+    const { taskId, agentId } = data;
+    console.log(colors.magenta('◆'), `Task ${colors.yellow(taskId)} assigned to ${colors.cyan(agentId)}`);
+  });
+
+  eventBus.on(SystemEvents.TASK_COMPLETED, (data: any) => {
+    const { taskId } = data;
+    console.log(colors.green('✓'), `Task completed: ${colors.yellow(taskId)}`);
+  });
+
+  eventBus.on(SystemEvents.TASK_FAILED, (data: any) => {
+    const { taskId, error } = data;
+    console.log(colors.red('✗'), `Task failed: ${colors.yellow(taskId)} - ${error.message}`);
+  });
+
+  eventBus.on(SystemEvents.SYSTEM_ERROR, (data: any) => {
+    const { component, error } = data;
+    console.error(colors.red.bold('System Error:'), `${component} - ${error.message}`);
+  });
+}

package/src/cli/commands/status.ts

@@ -0,0 +1,345 @@
+/**
+ * Status command for Claude-Flow
+ */
+
+import { Command } from '@cliffy/command';
+import { colors } from '@cliffy/ansi/colors';
+import { Table } from '@cliffy/table';
+import { formatHealthStatus, formatDuration, formatStatusIndicator } from '../formatter.ts';
+
+export const statusCommand = new Command()
+  .description('Show Claude-Flow system status')
+  .option('-w, --watch', 'Watch mode - continuously update status')
+  .option('-i, --interval <seconds:number>', 'Update interval in seconds', { default: 5 })
+  .option('-c, --component <name:string>', 'Show status for specific component')
+  .option('--json', 'Output in JSON format')
+  .action(async (options: any) => {
+    if (options.watch) {
+      await watchStatus(options);
+    } else {
+      await showStatus(options);
+    }
+  });
+
+async function showStatus(options: any): Promise<void> {
+  try {
+    // In a real implementation, this would connect to the running orchestrator
+    const status = await getSystemStatus();
+    
+    if (options.json) {
+      console.log(JSON.stringify(status, null, 2));
+      return;
+    }
+
+    if (options.component) {
+      showComponentStatus(status, options.component);
+    } else {
+      showFullStatus(status);
+    }
+  } catch (error) {
+    if ((error as Error).message.includes('ECONNREFUSED') || (error as Error).message.includes('connection refused')) {
+      console.error(colors.red('✗ Claude-Flow is not running'));
+      console.log(colors.gray('Start it with: claude-flow start'));
+    } else {
+      console.error(colors.red('Error getting status:'), (error as Error).message);
+    }
+  }
+}
+
+async function watchStatus(options: any): Promise<void> {
+  const interval = options.interval * 1000;
+  
+  console.log(colors.cyan('Watching Claude-Flow status...'));
+  console.log(colors.gray(`Update interval: ${options.interval}s`));
+  console.log(colors.gray('Press Ctrl+C to stop\n'));
+
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    // Clear screen and show status
+    console.clear();
+    console.log(colors.cyan.bold('Claude-Flow Status Monitor'));
+    console.log(colors.gray(`Last updated: ${new Date().toLocaleTimeString()}\n`));
+    
+    try {
+      await showStatus({ ...options, json: false });
+    } catch (error) {
+      console.error(colors.red('Status update failed:'), (error as Error).message);
+    }
+    
+    await new Promise(resolve => setTimeout(resolve, interval));
+  }
+}
+
+function showFullStatus(status: any): void {
+  // System overview
+  console.log(colors.cyan.bold('System Overview'));
+  console.log('─'.repeat(50));
+  
+  const statusIcon = formatStatusIndicator(status.overall);
+  console.log(`${statusIcon} Overall Status: ${getStatusColor(status.overall)(status.overall.toUpperCase())}`);
+  console.log(`${colors.white('Uptime:')} ${formatDuration(status.uptime)}`);
+  console.log(`${colors.white('Version:')} ${status.version}`);
+  console.log(`${colors.white('Started:')} ${new Date(status.startTime).toLocaleString()}`);
+  console.log();
+
+  // Components status
+  console.log(colors.cyan.bold('Components'));
+  console.log('─'.repeat(50));
+  
+  const componentTable = new Table()
+    .header(['Component', 'Status', 'Uptime', 'Details'])
+    .border(true);
+
+  for (const [name, component] of Object.entries(status.components)) {
+    const comp = component as any;
+    const statusIcon = formatStatusIndicator(comp.status);
+    const statusText = getStatusColor(comp.status)(comp.status.toUpperCase());
+    
+    componentTable.push([
+      colors.white(name),
+      `${statusIcon} ${statusText}`,
+      formatDuration(comp.uptime || 0),
+      comp.details || '-'
+    ]);
+  }
+  
+  componentTable.render();
+  console.log();
+
+  // Resource usage
+  if (status.resources) {
+    console.log(colors.cyan.bold('Resource Usage'));
+    console.log('─'.repeat(50));
+    
+    const resourceTable = new Table()
+      .header(['Resource', 'Used', 'Total', 'Percentage'])
+      .border(true);
+
+    for (const [name, resource] of Object.entries(status.resources)) {
+      const res = resource as any;
+      const percentage = ((res.used / res.total) * 100).toFixed(1);
+      const color = getResourceColor(parseFloat(percentage));
+      
+      resourceTable.push([
+        colors.white(name),
+        res.used.toString(),
+        res.total.toString(),
+        color(`${percentage}%`)
+      ]);
+    }
+    
+    resourceTable.render();
+    console.log();
+  }
+
+  // Active agents
+  if (status.agents) {
+    console.log(colors.cyan.bold(`Active Agents (${status.agents.length})`));
+    console.log('─'.repeat(50));
+    
+    if (status.agents.length > 0) {
+      const agentTable = new Table()
+        .header(['ID', 'Name', 'Type', 'Status', 'Tasks'])
+        .border(true);
+
+      for (const agent of status.agents) {
+        const statusIcon = formatStatusIndicator(agent.status);
+        const statusText = getStatusColor(agent.status)(agent.status);
+        
+        agentTable.push([
+          colors.gray(agent.id.substring(0, 8) + '...'),
+          colors.white(agent.name),
+          colors.cyan(agent.type),
+          `${statusIcon} ${statusText}`,
+          agent.activeTasks.toString()
+        ]);
+      }
+      
+      agentTable.render();
+    } else {
+      console.log(colors.gray('No active agents'));
+    }
+    console.log();
+  }
+
+  // Recent tasks
+  if (status.recentTasks) {
+    console.log(colors.cyan.bold(`Recent Tasks (${status.recentTasks.length})`));
+    console.log('─'.repeat(50));
+    
+    if (status.recentTasks.length > 0) {
+      const taskTable = new Table()
+        .header(['ID', 'Type', 'Status', 'Agent', 'Duration'])
+        .border(true);
+
+      for (const task of status.recentTasks.slice(0, 10)) { // Show last 10
+        const statusIcon = formatStatusIndicator(task.status);
+        const statusText = getStatusColor(task.status)(task.status);
+        
+        taskTable.push([
+          colors.gray(task.id.substring(0, 8) + '...'),
+          colors.white(task.type),
+          `${statusIcon} ${statusText}`,
+          task.agent ? colors.cyan(task.agent.substring(0, 12) + '...') : '-',
+          task.duration ? formatDuration(task.duration) : '-'
+        ]);
+      }
+      
+      taskTable.render();
+    } else {
+      console.log(colors.gray('No recent tasks'));
+    }
+  }
+}
+
+function showComponentStatus(status: any, componentName: string): void {
+  const component = status.components[componentName];
+  
+  if (!component) {
+    console.error(colors.red(`Component '${componentName}' not found`));
+    console.log(colors.gray('Available components:'), Object.keys(status.components).join(', '));
+    return;
+  }
+
+  console.log(colors.cyan.bold(`${componentName} Status`));
+  console.log('─'.repeat(30));
+  
+  const statusIcon = formatStatusIndicator(component.status);
+  console.log(`${statusIcon} Status: ${getStatusColor(component.status)(component.status.toUpperCase())}`);
+  
+  if (component.uptime) {
+    console.log(`${colors.white('Uptime:')} ${formatDuration(component.uptime)}`);
+  }
+  
+  if (component.details) {
+    console.log(`${colors.white('Details:')} ${component.details}`);
+  }
+  
+  if (component.metrics) {
+    console.log('\n' + colors.cyan.bold('Metrics'));
+    console.log('─'.repeat(20));
+    
+    for (const [metric, value] of Object.entries(component.metrics)) {
+      console.log(`${colors.white(metric + ':')} ${value}`);
+    }
+  }
+  
+  if (component.errors && component.errors.length > 0) {
+    console.log('\n' + colors.red.bold('Recent Errors'));
+    console.log('─'.repeat(20));
+    
+    for (const error of component.errors.slice(0, 5)) {
+      console.log(colors.red(`• ${error.message}`));
+      console.log(colors.gray(`  ${new Date(error.timestamp).toLocaleString()}`));
+    }
+  }
+}
+
+async function getSystemStatus(): Promise<any> {
+  // Mock status for now - in production, this would call the orchestrator API
+  return {
+    overall: 'healthy',
+    version: '1.0.0',
+    uptime: Date.now() - (Date.now() - 3600000), // 1 hour ago
+    startTime: new Date(Date.now() - 3600000),
+    components: {
+      orchestrator: {
+        status: 'healthy',
+        uptime: 3600000,
+        details: 'Managing 3 agents'
+      },
+      terminal: {
+        status: 'healthy',
+        uptime: 3600000,
+        details: 'Pool: 2/5 active sessions'
+      },
+      memory: {
+        status: 'healthy',
+        uptime: 3600000,
+        details: 'SQLite + 95MB cache'
+      },
+      coordination: {
+        status: 'healthy',
+        uptime: 3600000,
+        details: '12 active tasks'
+      },
+      mcp: {
+        status: 'healthy',
+        uptime: 3600000,
+        details: 'Listening on stdio'
+      }
+    },
+    resources: {
+      'Memory (MB)': { used: 256, total: 1024 },
+      'CPU (%)': { used: 15, total: 100 },
+      'Agents': { used: 3, total: 10 },
+      'Tasks': { used: 12, total: 100 }
+    },
+    agents: [
+      {
+        id: 'agent-001',
+        name: 'Coordinator Agent',
+        type: 'coordinator',
+        status: 'active',
+        activeTasks: 2
+      },
+      {
+        id: 'agent-002',
+        name: 'Research Agent',
+        type: 'researcher',
+        status: 'active',
+        activeTasks: 5
+      },
+      {
+        id: 'agent-003',
+        name: 'Implementation Agent',
+        type: 'implementer',
+        status: 'idle',
+        activeTasks: 0
+      }
+    ],
+    recentTasks: [
+      {
+        id: 'task-001',
+        type: 'research',
+        status: 'completed',
+        agent: 'agent-002',
+        duration: 45000
+      },
+      {
+        id: 'task-002',
+        type: 'coordination',
+        status: 'running',
+        agent: 'agent-001',
+        duration: null
+      }
+    ]
+  };
+}
+
+function getStatusColor(status: string) {
+  switch (status.toLowerCase()) {
+    case 'healthy':
+    case 'active':
+    case 'completed':
+      return colors.green;
+    case 'degraded':
+    case 'warning':
+    case 'idle':
+      return colors.yellow;
+    case 'unhealthy':
+    case 'error':
+    case 'failed':
+      return colors.red;
+    case 'running':
+      return colors.cyan;
+    default:
+      return colors.white;
+  }
+}
+
+function getResourceColor(percentage: number) {
+  if (percentage >= 90) return colors.red;
+  if (percentage >= 75) return colors.yellow;
+  return colors.green;
+}

package/src/cli/commands/task.ts

@@ -0,0 +1,79 @@
+/**
+ * Task management commands
+ */
+
+import { Command } from '@cliffy/command';
+import { colors } from '@cliffy/ansi/colors';
+import { Task } from '../../utils/types.ts';
+import { generateId } from '../../utils/helpers.ts';
+
+export const taskCommand = new Command()
+  .description('Manage tasks')
+  .action(() => {
+    taskCommand.showHelp();
+  })
+  .command('create', new Command()
+    .description('Create a new task')
+    .arguments('<type:string> <description:string>')
+    .option('-p, --priority <priority:number>', 'Task priority', { default: 0 })
+    .option('-d, --dependencies <deps:string>', 'Comma-separated list of dependency task IDs')
+    .option('-i, --input <input:string>', 'Task input as JSON')
+    .option('-a, --assign <agent:string>', 'Assign to specific agent')
+    .action(async (options: any, type: string, description: string) => {
+      const task: Task = {
+        id: generateId('task'),
+        type,
+        description,
+        priority: options.priority,
+        dependencies: options.dependencies ? options.dependencies.split(',') : [],
+        assignedAgent: options.assign,
+        status: 'pending',
+        input: options.input ? JSON.parse(options.input) : {},
+        createdAt: new Date(),
+      };
+
+      console.log(colors.green('Task created:'));
+      console.log(JSON.stringify(task, null, 2));
+      console.log(colors.yellow('\nTo submit this task, ensure Claude-Flow is running'));
+    }),
+  )
+  .command('list', new Command()
+    .description('List all tasks')
+    .option('-s, --status <status:string>', 'Filter by status')
+    .option('-a, --agent <agent:string>', 'Filter by assigned agent')
+    .action(async (options: any) => {
+      console.log(colors.yellow('Task listing requires a running Claude-Flow instance'));
+    }),
+  )
+  .command('status', new Command()
+    .description('Get task status')
+    .arguments('<task-id:string>')
+    .action(async (options: any, taskId: string) => {
+      console.log(colors.yellow(`Task status requires a running Claude-Flow instance`));
+    }),
+  )
+  .command('cancel', new Command()
+    .description('Cancel a task')
+    .arguments('<task-id:string>')
+    .option('-r, --reason <reason:string>', 'Cancellation reason')
+    .action(async (options: any, taskId: string) => {
+      console.log(colors.yellow(`Cancelling task ${taskId} requires a running Claude-Flow instance`));
+    }),
+  )
+  .command('workflow', new Command()
+    .description('Execute a workflow from file')
+    .arguments('<workflow-file:string>')
+    .action(async (options: any, workflowFile: string) => {
+      try {
+        const content = await Deno.readTextFile(workflowFile);
+        const workflow = JSON.parse(content);
+        
+        console.log(colors.green('Workflow loaded:'));
+        console.log(`- Name: ${workflow.name || 'Unnamed'}`);
+        console.log(`- Tasks: ${workflow.tasks?.length || 0}`);
+        console.log(colors.yellow('\nTo execute this workflow, ensure Claude-Flow is running'));
+      } catch (error) {
+        console.error(colors.red('Failed to load workflow:'), (error as Error).message);
+      }
+    }),
+  );