claude-flow 1.0.0

package/src/cli/commands/mcp.ts

@@ -0,0 +1,191 @@
+/**
+ * MCP command for Claude-Flow
+ */
+
+import { Command } from '@cliffy/command';
+import { colors } from '@cliffy/ansi/colors';
+import { logger } from '../../core/logger.ts';
+import { configManager } from '../../core/config.ts';
+import { MCPServer } from '../../mcp/server.ts';
+import { eventBus } from '../../core/event-bus.ts';
+
+let mcpServer: MCPServer | null = null;
+
+export const mcpCommand = new Command()
+  .description('Manage MCP server and tools')
+  .action(() => {
+    console.log(colors.yellow('Please specify a subcommand:'));
+    console.log('  start   - Start the MCP server');
+    console.log('  stop    - Stop the MCP server');
+    console.log('  status  - Show MCP server status');
+    console.log('  tools   - List available MCP tools');
+    console.log('  config  - Show MCP configuration');
+    console.log('  restart - Restart the MCP server');
+    console.log('  logs    - Show MCP server logs');
+  })
+  .command('start', new Command()
+    .description('Start the MCP server')
+    .option('-p, --port <port:number>', 'Port for MCP server', { default: 3000 })
+    .option('-h, --host <host:string>', 'Host for MCP server', { default: 'localhost' })
+    .option('--transport <transport:string>', 'Transport type (stdio, http)', { default: 'stdio' })
+    .action(async (options: any) => {
+      try {
+        const config = await configManager.load();
+        
+        // Override with CLI options
+        const mcpConfig = {
+          ...config.mcp,
+          port: options.port,
+          host: options.host,
+          transport: options.transport,
+        };
+
+        mcpServer = new MCPServer(mcpConfig, eventBus, logger);
+        await mcpServer.start();
+
+        console.log(colors.green(`✅ MCP server started on ${options.host}:${options.port}`));
+        console.log(colors.cyan(`📡 Server URL: http://${options.host}:${options.port}`));
+        console.log(colors.cyan(`🔧 Available tools: Research, Code, Terminal, Memory`));
+        console.log(colors.cyan(`📚 API documentation: http://${options.host}:${options.port}/docs`));
+      } catch (error) {
+        console.error(colors.red(`❌ Failed to start MCP server: ${(error as Error).message}`));
+        Deno.exit(1);
+      }
+    })
+  )
+  .command('stop', new Command()
+    .description('Stop the MCP server')
+    .action(async () => {
+      try {
+        if (mcpServer) {
+          await mcpServer.stop();
+          mcpServer = null;
+          console.log(colors.green('✅ MCP server stopped'));
+        } else {
+          console.log(colors.yellow('⚠️  MCP server is not running'));
+        }
+      } catch (error) {
+        console.error(colors.red(`❌ Failed to stop MCP server: ${(error as Error).message}`));
+        Deno.exit(1);
+      }
+    })
+  )
+  .command('status', new Command()
+    .description('Show MCP server status')
+    .action(async () => {
+      try {
+        const config = await configManager.load();
+        const isRunning = mcpServer !== null;
+
+        console.log(colors.cyan('MCP Server Status:'));
+        console.log(`🌐 Status: ${isRunning ? colors.green('Running') : colors.red('Stopped')}`);
+        
+        if (isRunning) {
+          console.log(`📍 Address: ${config.mcp.host}:${config.mcp.port}`);
+          console.log(`🔐 Authentication: ${config.mcp.auth ? colors.green('Enabled') : colors.yellow('Disabled')}`);
+          console.log(`🔧 Tools: ${colors.green('Available')}`);
+          console.log(`📊 Metrics: ${colors.green('Collecting')}`);
+        } else {
+          console.log(colors.gray('Use "claude-flow mcp start" to start the server'));
+        }
+      } catch (error) {
+        console.error(colors.red(`❌ Failed to get MCP status: ${(error as Error).message}`));
+      }
+    })
+  )
+  .command('tools', new Command()
+    .description('List available MCP tools')
+    .action(() => {
+      console.log(colors.cyan('Available MCP Tools:'));
+      
+      console.log('\n📊 Research Tools:');
+      console.log('  • web_search - Search the web for information');
+      console.log('  • web_fetch - Fetch content from URLs');
+      console.log('  • knowledge_query - Query knowledge base');
+      
+      console.log('\n💻 Code Tools:');
+      console.log('  • code_edit - Edit code files');
+      console.log('  • code_search - Search through codebase');
+      console.log('  • code_analyze - Analyze code quality');
+      
+      console.log('\n🖥️  Terminal Tools:');
+      console.log('  • terminal_execute - Execute shell commands');
+      console.log('  • terminal_session - Manage terminal sessions');
+      console.log('  • file_operations - File system operations');
+      
+      console.log('\n💾 Memory Tools:');
+      console.log('  • memory_store - Store information');
+      console.log('  • memory_query - Query stored information');
+      console.log('  • memory_index - Index and search content');
+    })
+  )
+  .command('config', new Command()
+    .description('Show MCP configuration')
+    .action(async () => {
+      try {
+        const config = await configManager.load();
+        
+        console.log(colors.cyan('MCP Configuration:'));
+        console.log(JSON.stringify(config.mcp, null, 2));
+      } catch (error) {
+        console.error(colors.red(`❌ Failed to show MCP config: ${(error as Error).message}`));
+      }
+    })
+  )
+  .command('restart', new Command()
+    .description('Restart the MCP server')
+    .action(async () => {
+      try {
+        console.log(colors.yellow('🔄 Stopping MCP server...'));
+        if (mcpServer) {
+          await mcpServer.stop();
+        }
+        
+        console.log(colors.yellow('🔄 Starting MCP server...'));
+        const config = await configManager.load();
+        mcpServer = new MCPServer(config.mcp, eventBus, logger);
+        await mcpServer.start();
+        
+        console.log(colors.green(`✅ MCP server restarted on ${config.mcp.host}:${config.mcp.port}`));
+      } catch (error) {
+        console.error(colors.red(`❌ Failed to restart MCP server: ${(error as Error).message}`));
+        Deno.exit(1);
+      }
+    })
+  )
+  .command('logs', new Command()
+    .description('Show MCP server logs')
+    .option('-n, --lines <lines:number>', 'Number of log lines to show', { default: 50 })
+    .action((options: any) => {
+      console.log(colors.cyan(`MCP Server Logs (last ${options.lines} lines):`));
+      
+      // Mock logs since logging system might not be fully implemented
+      const logEntries = [
+        '2024-01-10 10:00:00 [INFO] MCP server started on localhost:3000',
+        '2024-01-10 10:00:01 [INFO] Tools registered: 12',
+        '2024-01-10 10:00:02 [INFO] Authentication disabled',
+        '2024-01-10 10:01:00 [INFO] Client connected: claude-desktop',
+        '2024-01-10 10:01:05 [INFO] Tool called: web_search',
+        '2024-01-10 10:01:10 [INFO] Tool response sent successfully',
+        '2024-01-10 10:02:00 [INFO] Tool called: terminal_execute',
+        '2024-01-10 10:02:05 [INFO] Command executed successfully',
+        '2024-01-10 10:03:00 [INFO] Memory operation: store',
+        '2024-01-10 10:03:01 [INFO] Data stored in namespace: default',
+      ];
+      
+      const startIndex = Math.max(0, logEntries.length - options.lines);
+      const displayLogs = logEntries.slice(startIndex);
+      
+      for (const entry of displayLogs) {
+        if (entry.includes('[ERROR]')) {
+          console.log(colors.red(entry));
+        } else if (entry.includes('[WARN]')) {
+          console.log(colors.yellow(entry));
+        } else if (entry.includes('[INFO]')) {
+          console.log(colors.green(entry));
+        } else {
+          console.log(colors.gray(entry));
+        }
+      }
+    })
+  );

package/src/cli/commands/memory.ts

@@ -0,0 +1,74 @@
+/**
+ * Memory management commands
+ */
+
+import { Command } from '@cliffy/command';
+import { colors } from '@cliffy/ansi/colors';
+import { Table } from '@cliffy/table';
+
+export const memoryCommand = new Command()
+  .description('Manage agent memory')
+  .action(() => {
+    memoryCommand.showHelp();
+  })
+  .command('query', new Command()
+    .description('Query memory entries')
+    .option('-a, --agent <agent:string>', 'Filter by agent ID')
+    .option('-s, --session <session:string>', 'Filter by session ID')
+    .option('-t, --type <type:string>', 'Filter by entry type')
+    .option('--tags <tags:string>', 'Filter by tags (comma-separated)')
+    .option('--search <search:string>', 'Search in content')
+    .option('--limit <limit:number>', 'Limit results', { default: 10 })
+    .action(async (options: any) => {
+      console.log(colors.yellow('Memory query requires a running Claude-Flow instance'));
+      console.log(colors.gray('Query parameters:'));
+      console.log(JSON.stringify(options, null, 2));
+    }),
+  )
+  .command('export', new Command()
+    .description('Export memory to file')
+    .arguments('<output-file:string>')
+    .option('-a, --agent <agent:string>', 'Export specific agent memory')
+    .option('-f, --format <format:string>', 'Export format (json, markdown)', {
+      default: 'json',
+    })
+    .action(async (options: any, outputFile: string) => {
+      console.log(colors.yellow('Memory export requires a running Claude-Flow instance'));
+    }),
+  )
+  .command('import', new Command()
+    .description('Import memory from file')
+    .arguments('<input-file:string>')
+    .option('-a, --agent <agent:string>', 'Import to specific agent')
+    .action(async (options: any, inputFile: string) => {
+      try {
+        const content = await Deno.readTextFile(inputFile);
+        const data = JSON.parse(content);
+        
+        console.log(colors.green('Memory data loaded:'));
+        console.log(`- Entries: ${Array.isArray(data) ? data.length : 1}`);
+        console.log(colors.yellow('\nTo import this data, ensure Claude-Flow is running'));
+      } catch (error) {
+        console.error(colors.red('Failed to load memory file:'), (error as Error).message);
+      }
+    }),
+  )
+  .command('stats', new Command()
+    .description('Show memory statistics')
+    .action(async () => {
+      console.log(colors.yellow('Memory statistics require a running Claude-Flow instance'));
+    }),
+  )
+  .command('cleanup', new Command()
+    .description('Clean up old memory entries')
+    .option('--older-than <days:number>', 'Delete entries older than N days', {
+      default: 30,
+    })
+    .option('--dry-run', 'Show what would be deleted without deleting')
+    .action(async (options: any) => {
+      console.log(colors.yellow('Memory cleanup requires a running Claude-Flow instance'));
+      if (options.dryRun) {
+        console.log(colors.gray('(Dry run mode - no changes would be made)'));
+      }
+    }),
+  );

package/src/cli/commands/monitor.ts

@@ -0,0 +1,403 @@
+/**
+ * Monitor command for Claude-Flow - Live dashboard mode
+ */
+
+import { Command } from '@cliffy/command';
+import { colors } from '@cliffy/ansi/colors';
+import { Table } from '@cliffy/table';
+import { formatProgressBar, formatDuration, formatStatusIndicator } from '../formatter.ts';
+
+export const monitorCommand = new Command()
+  .description('Start live monitoring dashboard')
+  .option('-i, --interval <seconds:number>', 'Update interval in seconds', { default: 2 })
+  .option('-c, --compact', 'Compact view mode')
+  .option('--no-graphs', 'Disable ASCII graphs')
+  .option('--focus <component:string>', 'Focus on specific component')
+  .action(async (options: any) => {
+    await startMonitorDashboard(options);
+  });
+
+interface MonitorData {
+  timestamp: Date;
+  system: {
+    cpu: number;
+    memory: number;
+    agents: number;
+    tasks: number;
+  };
+  components: Record<string, any>;
+  agents: any[];
+  tasks: any[];
+  events: any[];
+}
+
+class Dashboard {
+  private data: MonitorData[] = [];
+  private maxDataPoints = 60; // 2 minutes at 2-second intervals
+  private running = true;
+
+  constructor(private options: any) {}
+
+  async start(): Promise<void> {
+    // Hide cursor and clear screen
+    Deno.stdout.writeSync(new TextEncoder().encode('\x1b[?25l'));
+    console.clear();
+
+    // Setup signal handlers
+    const cleanup = () => {
+      this.running = false;
+      Deno.stdout.writeSync(new TextEncoder().encode('\x1b[?25h')); // Show cursor
+      console.log('\n' + colors.gray('Monitor stopped'));
+      Deno.exit(0);
+    };
+
+    Deno.addSignalListener('SIGINT', cleanup);
+    Deno.addSignalListener('SIGTERM', cleanup);
+
+    // Start monitoring loop
+    await this.monitoringLoop();
+  }
+
+  private async monitoringLoop(): Promise<void> {
+    while (this.running) {
+      try {
+        const data = await this.collectData();
+        this.data.push(data);
+        
+        // Keep only recent data points
+        if (this.data.length > this.maxDataPoints) {
+          this.data = this.data.slice(-this.maxDataPoints);
+        }
+
+        this.render();
+        await new Promise(resolve => setTimeout(resolve, this.options.interval * 1000));
+      } catch (error) {
+        this.renderError(error);
+        await new Promise(resolve => setTimeout(resolve, this.options.interval * 1000));
+      }
+    }
+  }
+
+  private async collectData(): Promise<MonitorData> {
+    // Mock data collection - in production, this would connect to the orchestrator
+    const timestamp = new Date();
+    const cpuUsage = 10 + Math.random() * 20; // 10-30%
+    const memoryUsage = 200 + Math.random() * 100; // 200-300MB
+    
+    return {
+      timestamp,
+      system: {
+        cpu: cpuUsage,
+        memory: memoryUsage,
+        agents: 3 + Math.floor(Math.random() * 3),
+        tasks: 5 + Math.floor(Math.random() * 10)
+      },
+      components: {
+        orchestrator: { status: 'healthy', load: Math.random() * 100 },
+        terminal: { status: 'healthy', load: Math.random() * 100 },
+        memory: { status: 'healthy', load: Math.random() * 100 },
+        coordination: { status: 'healthy', load: Math.random() * 100 },
+        mcp: { status: 'healthy', load: Math.random() * 100 }
+      },
+      agents: this.generateMockAgents(),
+      tasks: this.generateMockTasks(),
+      events: this.generateMockEvents()
+    };
+  }
+
+  private render(): void {
+    console.clear();
+    
+    const latest = this.data[this.data.length - 1];
+    if (!latest) return;
+
+    // Header
+    this.renderHeader(latest);
+    
+    if (this.options.focus) {
+      this.renderFocusedComponent(latest, this.options.focus);
+    } else {
+      // System overview
+      this.renderSystemOverview(latest);
+      
+      // Components status
+      this.renderComponentsStatus(latest);
+      
+      if (!this.options.compact) {
+        // Agents and tasks
+        this.renderAgentsAndTasks(latest);
+        
+        // Recent events
+        this.renderRecentEvents(latest);
+        
+        // Performance graphs
+        if (!this.options.noGraphs) {
+          this.renderPerformanceGraphs();
+        }
+      }
+    }
+
+    // Footer
+    this.renderFooter();
+  }
+
+  private renderHeader(data: MonitorData): void {
+    const time = data.timestamp.toLocaleTimeString();
+    console.log(colors.cyan.bold('Claude-Flow Live Monitor') + colors.gray(` - ${time}`));
+    console.log('═'.repeat(80));
+  }
+
+  private renderSystemOverview(data: MonitorData): void {
+    console.log(colors.white.bold('System Overview'));
+    console.log('─'.repeat(40));
+    
+    const cpuBar = formatProgressBar(data.system.cpu, 100, 20, 'CPU');
+    const memoryBar = formatProgressBar(data.system.memory, 1024, 20, 'Memory');
+    
+    console.log(`${cpuBar} ${data.system.cpu.toFixed(1)}%`);
+    console.log(`${memoryBar} ${data.system.memory.toFixed(0)}MB`);
+    console.log(`${colors.white('Agents:')} ${data.system.agents} active`);
+    console.log(`${colors.white('Tasks:')} ${data.system.tasks} in queue`);
+    console.log();
+  }
+
+  private renderComponentsStatus(data: MonitorData): void {
+    console.log(colors.white.bold('Components'));
+    console.log('─'.repeat(40));
+    
+    const table = new Table()
+      .header(['Component', 'Status', 'Load'])
+      .border(false);
+
+    for (const [name, component] of Object.entries(data.components)) {
+      const statusIcon = formatStatusIndicator(component.status);
+      const loadBar = this.createMiniProgressBar(component.load, 100, 10);
+      
+      table.push([
+        colors.cyan(name),
+        `${statusIcon} ${component.status}`,
+        `${loadBar} ${component.load.toFixed(0)}%`
+      ]);
+    }
+    
+    table.render();
+    console.log();
+  }
+
+  private renderAgentsAndTasks(data: MonitorData): void {
+    // Agents table
+    console.log(colors.white.bold('Active Agents'));
+    console.log('─'.repeat(40));
+    
+    if (data.agents.length > 0) {
+      const agentTable = new Table()
+        .header(['ID', 'Type', 'Status', 'Tasks'])
+        .border(false);
+
+      for (const agent of data.agents.slice(0, 5)) {
+        const statusIcon = formatStatusIndicator(agent.status);
+        
+        agentTable.push([
+          colors.gray(agent.id.substring(0, 8) + '...'),
+          colors.cyan(agent.type),
+          `${statusIcon} ${agent.status}`,
+          agent.activeTasks.toString()
+        ]);
+      }
+      
+      agentTable.render();
+    } else {
+      console.log(colors.gray('No active agents'));
+    }
+    console.log();
+
+    // Recent tasks
+    console.log(colors.white.bold('Recent Tasks'));
+    console.log('─'.repeat(40));
+    
+    if (data.tasks.length > 0) {
+      const taskTable = new Table()
+        .header(['ID', 'Type', 'Status', 'Duration'])
+        .border(false);
+
+      for (const task of data.tasks.slice(0, 5)) {
+        const statusIcon = formatStatusIndicator(task.status);
+        
+        taskTable.push([
+          colors.gray(task.id.substring(0, 8) + '...'),
+          colors.white(task.type),
+          `${statusIcon} ${task.status}`,
+          task.duration ? formatDuration(task.duration) : '-'
+        ]);
+      }
+      
+      taskTable.render();
+    } else {
+      console.log(colors.gray('No recent tasks'));
+    }
+    console.log();
+  }
+
+  private renderRecentEvents(data: MonitorData): void {
+    console.log(colors.white.bold('Recent Events'));
+    console.log('─'.repeat(40));
+    
+    if (data.events.length > 0) {
+      for (const event of data.events.slice(0, 3)) {
+        const time = new Date(event.timestamp).toLocaleTimeString();
+        const icon = this.getEventIcon(event.type);
+        console.log(`${colors.gray(time)} ${icon} ${event.message}`);
+      }
+    } else {
+      console.log(colors.gray('No recent events'));
+    }
+    console.log();
+  }
+
+  private renderPerformanceGraphs(): void {
+    console.log(colors.white.bold('Performance (Last 60s)'));
+    console.log('─'.repeat(40));
+    
+    if (this.data.length >= 2) {
+      // CPU graph
+      console.log(colors.cyan('CPU Usage:'));
+      console.log(this.createSparkline(this.data.map(d => d.system.cpu), 30));
+      
+      // Memory graph
+      console.log(colors.cyan('Memory Usage:'));
+      console.log(this.createSparkline(this.data.map(d => d.system.memory), 30));
+    } else {
+      console.log(colors.gray('Collecting data...'));
+    }
+    console.log();
+  }
+
+  private renderFocusedComponent(data: MonitorData, componentName: string): void {
+    const component = data.components[componentName];
+    if (!component) {
+      console.log(colors.red(`Component '${componentName}' not found`));
+      return;
+    }
+
+    console.log(colors.white.bold(`${componentName} Details`));
+    console.log('─'.repeat(40));
+    
+    const statusIcon = formatStatusIndicator(component.status);
+    console.log(`${statusIcon} Status: ${component.status}`);
+    console.log(`Load: ${formatProgressBar(component.load, 100, 30)} ${component.load.toFixed(1)}%`);
+    
+    // Add component-specific metrics here
+    console.log();
+  }
+
+  private renderFooter(): void {
+    console.log('─'.repeat(80));
+    console.log(colors.gray('Press Ctrl+C to exit • Update interval: ') + 
+               colors.yellow(`${this.options.interval}s`));
+  }
+
+  private renderError(error: any): void {
+    console.clear();
+    console.log(colors.red.bold('Monitor Error'));
+    console.log('─'.repeat(40));
+    
+    if ((error as Error).message.includes('ECONNREFUSED')) {
+      console.log(colors.red('✗ Cannot connect to Claude-Flow'));
+      console.log(colors.gray('Make sure Claude-Flow is running with: claude-flow start'));
+    } else {
+      console.log(colors.red('Error:'), (error as Error).message);
+    }
+    
+    console.log('\n' + colors.gray('Retrying in ') + colors.yellow(`${this.options.interval}s...`));
+  }
+
+  private createMiniProgressBar(current: number, max: number, width: number): string {
+    const filled = Math.floor((current / max) * width);
+    const empty = width - filled;
+    return colors.green('█'.repeat(filled)) + colors.gray('░'.repeat(empty));
+  }
+
+  private createSparkline(data: number[], width: number): string {
+    if (data.length < 2) return colors.gray('▁'.repeat(width));
+    
+    const max = Math.max(...data);
+    const min = Math.min(...data);
+    const range = max - min || 1;
+    
+    const chars = ['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'];
+    const recent = data.slice(-width);
+    
+    return recent.map(value => {
+      const normalized = (value - min) / range;
+      const charIndex = Math.floor(normalized * (chars.length - 1));
+      return colors.cyan(chars[charIndex]);
+    }).join('');
+  }
+
+  private getEventIcon(type: string): string {
+    const icons = {
+      agent_spawned: colors.green('↗'),
+      agent_terminated: colors.red('↙'),
+      task_completed: colors.green('✓'),
+      task_failed: colors.red('✗'),
+      task_assigned: colors.blue('→'),
+      system_warning: colors.yellow('⚠'),
+      system_error: colors.red('✗'),
+    };
+    return icons[type as keyof typeof icons] || colors.blue('•');
+  }
+
+  private generateMockAgents(): any[] {
+    return [
+      {
+        id: 'agent-001',
+        type: 'coordinator',
+        status: 'active',
+        activeTasks: Math.floor(Math.random() * 5) + 1
+      },
+      {
+        id: 'agent-002',
+        type: 'researcher',
+        status: 'active',
+        activeTasks: Math.floor(Math.random() * 8) + 1
+      },
+      {
+        id: 'agent-003',
+        type: 'implementer',
+        status: Math.random() > 0.7 ? 'idle' : 'active',
+        activeTasks: Math.floor(Math.random() * 3)
+      }
+    ];
+  }
+
+  private generateMockTasks(): any[] {
+    const types = ['research', 'implementation', 'analysis', 'coordination'];
+    const statuses = ['running', 'pending', 'completed', 'failed'];
+    
+    return Array.from({ length: 8 }, (_, i) => ({
+      id: `task-${String(i + 1).padStart(3, '0')}`,
+      type: types[Math.floor(Math.random() * types.length)],
+      status: statuses[Math.floor(Math.random() * statuses.length)],
+      duration: Math.random() > 0.5 ? Math.floor(Math.random() * 120000) : null
+    }));
+  }
+
+  private generateMockEvents(): any[] {
+    const events = [
+      { type: 'task_completed', message: 'Research task completed successfully' },
+      { type: 'agent_spawned', message: 'New implementer agent spawned' },
+      { type: 'task_assigned', message: 'Task assigned to coordinator agent' },
+      { type: 'system_warning', message: 'High memory usage detected' }
+    ];
+    
+    return events.map((event, i) => ({
+      ...event,
+      timestamp: Date.now() - (i * 30000) // 30 seconds apart
+    }));
+  }
+}
+
+async function startMonitorDashboard(options: any): Promise<void> {
+  const dashboard = new Dashboard(options);
+  await dashboard.start();
+}