@hanzo/dev 1.2.0 → 2.1.0

package/src/cli/dev.ts

@@ -2,10 +2,20 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import inquirer from 'inquirer';
-import { spawn } from 'child_process';
+import { spawn, execSync } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
+import { FileEditor } from '../lib/editor';
+import { MCPClient, DEFAULT_MCP_SERVERS } from '../lib/mcp-client';
+import { FunctionCallingSystem } from '../lib/function-calling';
+import { ConfigManager } from '../lib/config';
+import { CodeActAgent } from '../lib/code-act-agent';
+import { UnifiedWorkspace, WorkspaceSession } from '../lib/unified-workspace';
+import { PeerAgentNetwork } from '../lib/peer-agent-network';
+import { BenchmarkRunner, BenchmarkConfig } from '../lib/benchmark-runner';
+import { ConfigurableAgentLoop, LLMProvider } from '../lib/agent-loop';
+import { SwarmRunner, SwarmOptions } from '../lib/swarm-runner';
 
 const program = new Command();
 
@@ -23,7 +33,6 @@ function loadEnvFiles(): void {
         if (match) {
           const key = match[1].trim();
           const value = match[2].trim();
-          // Only set if not already in environment
           if (!process.env[key]) {
             process.env[key] = value;
           }
@@ -36,8 +45,28 @@ function loadEnvFiles(): void {
 // Load env files on startup
 loadEnvFiles();
 
-// Available tools configuration with API key detection
+// Check if uvx is available
+function hasUvx(): boolean {
+  try {
+    execSync('which uvx', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Available tools configuration
 const TOOLS = {
+  'hanzo-dev': {
+    name: 'Hanzo Dev (OpenHands)',
+    command: hasUvx() ? 'uvx hanzo-dev' : 'hanzo-dev',
+    checkCommand: hasUvx() ? 'which uvx' : 'which hanzo-dev',
+    description: 'Hanzo AI software development agent - Full featured dev environment',
+    color: chalk.magenta,
+    apiKeys: ['OPENAI_API_KEY', 'ANTHROPIC_API_KEY', 'LLM_API_KEY', 'HANZO_API_KEY'],
+    priority: 1,
+    isDefault: true
+  },
   claude: {
     name: 'Claude (Anthropic)',
     command: 'claude-code',
@@ -45,7 +74,7 @@ const TOOLS = {
     description: 'Claude Code - AI coding assistant',
     color: chalk.blue,
     apiKeys: ['ANTHROPIC_API_KEY', 'CLAUDE_API_KEY'],
-    priority: 1
+    priority: 2
   },
   aider: {
     name: 'Aider',
@@ -54,15 +83,6 @@ const TOOLS = {
     description: 'AI pair programming in your terminal',
     color: chalk.green,
     apiKeys: ['OPENAI_API_KEY', 'ANTHROPIC_API_KEY', 'CLAUDE_API_KEY'],
-    priority: 2
-  },
-  openhands: {
-    name: 'OpenHands',
-    command: 'openhands',
-    checkCommand: 'which openhands',
-    description: 'AI software development agent',
-    color: chalk.magenta,
-    apiKeys: ['OPENAI_API_KEY', 'ANTHROPIC_API_KEY', 'LLM_API_KEY'],
     priority: 3
   },
   gemini: {
@@ -104,7 +124,7 @@ async function isToolInstalled(tool: string): Promise<boolean> {
   });
 }
 
-// Get list of available tools (installed OR has API key)
+// Get list of available tools
 async function getAvailableTools(): Promise<string[]> {
   const available: string[] = [];
   for (const toolKey of Object.keys(TOOLS)) {
@@ -114,7 +134,6 @@ async function getAvailableTools(): Promise<string[]> {
       available.push(toolKey);
     }
   }
-  // Sort by priority
   return available.sort((a, b) => {
     const priorityA = TOOLS[a as keyof typeof TOOLS].priority;
     const priorityB = TOOLS[b as keyof typeof TOOLS].priority;
@@ -122,23 +141,25 @@ async function getAvailableTools(): Promise<string[]> {
   });
 }
 
-// Get default tool based on API keys and installation
+// Get default tool
 async function getDefaultTool(): Promise<string | null> {
   const availableTools = await getAvailableTools();
   if (availableTools.length === 0) return null;
   
-  // Prefer tools that have both API key and are installed
+  if (availableTools.includes('hanzo-dev')) {
+    return 'hanzo-dev';
+  }
+  
   for (const tool of availableTools) {
     if (await isToolInstalled(tool) && hasApiKey(tool)) {
       return tool;
     }
   }
   
-  // Otherwise return first available
   return availableTools[0];
 }
 
-// Run a tool with optional arguments
+// Run a tool
 function runTool(tool: string, args: string[] = []): void {
   const toolConfig = TOOLS[tool as keyof typeof TOOLS];
   if (!toolConfig) {
@@ -148,19 +169,24 @@ function runTool(tool: string, args: string[] = []): void {
 
   console.log(toolConfig.color(`\n🚀 Launching ${toolConfig.name}...\n`));
   
+  if (tool === 'hanzo-dev' && hasUvx()) {
+    console.log(chalk.gray('Using uvx to run hanzo-dev...'));
+  }
+  
   const child = spawn(toolConfig.command, args, {
     stdio: 'inherit',
     shell: true,
-    env: process.env // Pass through all environment variables
+    env: process.env
   });
 
   child.on('error', (error) => {
     console.error(chalk.red(`Failed to start ${toolConfig.name}: ${error.message}`));
-    if (!hasApiKey(tool)) {
-      console.log(chalk.yellow(`\nMake sure you have one of these API keys configured:`));
-      toolConfig.apiKeys?.forEach(key => {
-        console.log(chalk.gray(`  - ${key}`));
-      });
+    
+    if (tool === 'hanzo-dev') {
+      console.log(chalk.yellow('\nTo install hanzo-dev:'));
+      console.log(chalk.gray('  pip install hanzo-dev'));
+      console.log(chalk.gray('  # or'));
+      console.log(chalk.gray('  uvx hanzo-dev  # (if you have uv installed)'));
     }
     process.exit(1);
   });
@@ -173,11 +199,220 @@ function runTool(tool: string, args: string[] = []): void {
   });
 }
 
-// Interactive mode
+// Interactive editing mode using built-in editor
+async function interactiveEditMode(): Promise<void> {
+  const editor = new FileEditor();
+  const functionCalling = new FunctionCallingSystem();
+  const mcpClient = new MCPClient();
+  
+  console.log(chalk.bold.cyan('\n📝 Hanzo Dev Editor - Interactive Mode\n'));
+  console.log(chalk.gray('Commands: view, create, str_replace, insert, undo_edit, run, list, search, mcp, help, exit\n'));
+
+  // Connect to default MCP servers if available
+  for (const serverConfig of DEFAULT_MCP_SERVERS) {
+    try {
+      console.log(chalk.gray(`Connecting to MCP server: ${serverConfig.name}...`));
+      const session = await mcpClient.connect(serverConfig);
+      await functionCalling.registerMCPServer(serverConfig.name, session);
+      console.log(chalk.green(`✓ Connected to ${serverConfig.name}`));
+    } catch (error) {
+      console.log(chalk.yellow(`⚠ Could not connect to ${serverConfig.name}`));
+    }
+  }
+
+  while (true) {
+    const { command } = await inquirer.prompt([{
+      type: 'input',
+      name: 'command',
+      message: chalk.green('editor>'),
+      prefix: ''
+    }]);
+
+    if (command === 'exit' || command === 'quit') {
+      break;
+    }
+
+    if (command === 'help') {
+      console.log(chalk.cyan('\nAvailable commands:'));
+      console.log('  view <file> [start] [end]  - View file contents');
+      console.log('  create <file>              - Create new file');
+      console.log('  str_replace <file>         - Replace string in file');
+      console.log('  insert <file> <line>       - Insert line in file');
+      console.log('  undo_edit <file>           - Undo last edit');
+      console.log('  run <command>              - Run shell command');
+      console.log('  list <directory>           - List directory contents');
+      console.log('  search <pattern> [path]    - Search for files');
+      console.log('  mcp                        - List MCP tools');
+      console.log('  tools                      - List all available tools');
+      console.log('  help                       - Show this help');
+      console.log('  exit                       - Exit editor\n');
+      continue;
+    }
+
+    if (command === 'tools') {
+      const tools = functionCalling.getAvailableTools();
+      console.log(chalk.cyan('\nAvailable tools:'));
+      tools.forEach(tool => {
+        console.log(`  ${chalk.yellow(tool.name)} - ${tool.description}`);
+      });
+      console.log();
+      continue;
+    }
+
+    if (command === 'mcp') {
+      const sessions = mcpClient.getAllSessions();
+      console.log(chalk.cyan('\nMCP Sessions:'));
+      sessions.forEach(session => {
+        console.log(`  ${chalk.yellow(session.id)}:`);
+        session.tools.forEach(tool => {
+          console.log(`    - ${tool.name}: ${tool.description}`);
+        });
+      });
+      console.log();
+      continue;
+    }
+
+    // Parse and execute commands
+    const parts = command.split(' ');
+    const cmd = parts[0];
+    
+    try {
+      let result;
+      
+      switch (cmd) {
+        case 'view':
+          result = await editor.execute({
+            command: 'view',
+            path: parts[1],
+            startLine: parts[2] ? parseInt(parts[2]) : undefined,
+            endLine: parts[3] ? parseInt(parts[3]) : undefined
+          });
+          break;
+          
+        case 'create':
+          const { content } = await inquirer.prompt([{
+            type: 'editor',
+            name: 'content',
+            message: 'Enter file content:'
+          }]);
+          result = await editor.execute({
+            command: 'create',
+            path: parts[1],
+            content
+          });
+          break;
+          
+        case 'str_replace':
+          const { oldStr } = await inquirer.prompt([{
+            type: 'input',
+            name: 'oldStr',
+            message: 'String to replace:'
+          }]);
+          const { newStr } = await inquirer.prompt([{
+            type: 'input',
+            name: 'newStr',
+            message: 'Replacement string:'
+          }]);
+          result = await editor.execute({
+            command: 'str_replace',
+            path: parts[1],
+            oldStr,
+            newStr
+          });
+          break;
+          
+        case 'insert':
+          const { lineContent } = await inquirer.prompt([{
+            type: 'input',
+            name: 'lineContent',
+            message: 'Line content:'
+          }]);
+          result = await editor.execute({
+            command: 'insert',
+            path: parts[1],
+            lineNumber: parseInt(parts[2]),
+            content: lineContent
+          });
+          break;
+          
+        case 'undo_edit':
+          result = await editor.execute({
+            command: 'undo_edit',
+            path: parts[1]
+          });
+          break;
+          
+        case 'run':
+          const runCommand = parts.slice(1).join(' ');
+          result = await functionCalling.callFunction({
+            id: Date.now().toString(),
+            name: 'run_command',
+            arguments: { command: runCommand }
+          });
+          break;
+          
+        case 'list':
+          result = await functionCalling.callFunction({
+            id: Date.now().toString(),
+            name: 'list_directory',
+            arguments: { path: parts[1] || '.' }
+          });
+          break;
+          
+        case 'search':
+          result = await functionCalling.callFunction({
+            id: Date.now().toString(),
+            name: 'search_files',
+            arguments: { 
+              pattern: parts[1],
+              path: parts[2] || '.',
+              regex: false
+            }
+          });
+          break;
+          
+        default:
+          console.log(chalk.red(`Unknown command: ${cmd}`));
+          continue;
+      }
+      
+      if (result) {
+        if (result.success || result.result?.success) {
+          console.log(chalk.green('✓'), result.message || 'Success');
+          if (result.content || result.result?.stdout) {
+            console.log(result.content || result.result.stdout);
+          }
+          if (result.result?.files) {
+            result.result.files.forEach((file: any) => {
+              const icon = file.type === 'directory' ? '📁' : '📄';
+              console.log(`  ${icon} ${file.name}`);
+            });
+          }
+          if (result.result?.matches) {
+            console.log(`Found ${result.result.total} matches:`);
+            result.result.matches.forEach((match: string) => {
+              console.log(`  📄 ${match}`);
+            });
+          }
+        } else {
+          console.log(chalk.red('✗'), result.message || result.error || 'Error');
+          if (result.result?.stderr) {
+            console.log(chalk.red(result.result.stderr));
+          }
+        }
+      }
+    } catch (error) {
+      console.log(chalk.red('Error:'), error);
+    }
+  }
+
+  console.log(chalk.gray('\nExiting editor mode...'));
+}
+
+// Interactive mode for tool selection
 async function interactiveMode(): Promise<void> {
   console.log(chalk.bold.cyan('\n🤖 Hanzo Dev - AI Development Assistant\n'));
   
-  // Show detected environment files
   const envFiles = ['.env', '.env.local', '.env.development', '.env.production'];
   const detectedEnvFiles = envFiles.filter(file => fs.existsSync(path.join(process.cwd(), file)));
   if (detectedEnvFiles.length > 0) {
@@ -191,41 +426,34 @@ async function interactiveMode(): Promise<void> {
   const availableTools = await getAvailableTools();
   const defaultTool = await getDefaultTool();
   
-  if (availableTools.length === 0) {
+  if (availableTools.length === 0 && !hasApiKey('hanzo-dev')) {
     console.log(chalk.yellow('No AI tools available. Please either:'));
-    console.log(chalk.yellow('\n1. Install a tool:'));
+    console.log(chalk.yellow('\n1. Install hanzo-dev (recommended):'));
+    console.log(chalk.gray('   pip install hanzo-dev'));
+    console.log(chalk.gray('   # or'));
+    console.log(chalk.gray('   uvx hanzo-dev'));
+    
+    console.log(chalk.yellow('\n2. Install other tools:'));
     console.log(chalk.gray('   npm install -g @hanzo/claude-code'));
     console.log(chalk.gray('   pip install aider-chat'));
-    console.log(chalk.gray('   pip install openhands'));
     
-    console.log(chalk.yellow('\n2. Or configure API keys in your .env file:'));
+    console.log(chalk.yellow('\n3. Or configure API keys in your .env file:'));
     console.log(chalk.gray('   ANTHROPIC_API_KEY=sk-ant-...'));
     console.log(chalk.gray('   OPENAI_API_KEY=sk-...'));
-    console.log(chalk.gray('   GOOGLE_API_KEY=...'));
     process.exit(1);
   }
 
-  // Show available API keys
-  console.log(chalk.gray('🔑 Detected API keys:'));
-  const allApiKeys = new Set<string>();
-  Object.values(TOOLS).forEach(tool => {
-    tool.apiKeys?.forEach(key => allApiKeys.add(key));
-  });
-  
-  let hasAnyKey = false;
-  allApiKeys.forEach(key => {
-    if (process.env[key]) {
-      console.log(chalk.green(`   ✓ ${key}`));
-      hasAnyKey = true;
+  // Add built-in editor option
+  const choices = [
+    {
+      name: chalk.bold.yellow('🔧 Built-in Editor - Interactive file editing and MCP tools'),
+      value: 'builtin-editor',
+      short: 'Built-in Editor'
     }
-  });
-  
-  if (!hasAnyKey) {
-    console.log(chalk.gray('   (none detected)'));
-  }
-  console.log();
+  ];
 
-  const choices = await Promise.all(availableTools.map(async tool => {
+  // Add external tools
+  for (const tool of availableTools) {
     const toolConfig = TOOLS[tool as keyof typeof TOOLS];
     const isInstalled = await isToolInstalled(tool);
     const hasKey = hasApiKey(tool);
@@ -239,24 +467,32 @@ async function interactiveMode(): Promise<void> {
       status = chalk.cyan(' [API Key Only]');
     }
     
-    return {
+    if (toolConfig.isDefault) {
+      status += chalk.bold.magenta(' ★ DEFAULT');
+    }
+    
+    choices.push({
       name: `${toolConfig.name} - ${toolConfig.description}${status}`,
       value: tool,
       short: toolConfig.name
-    };
-  }));
+    });
+  }
 
   const { selectedTool } = await inquirer.prompt([
     {
       type: 'list',
       name: 'selectedTool',
-      message: 'Select an AI tool to launch:',
+      message: 'Select a tool to launch:',
       choices: choices,
-      default: defaultTool
+      default: defaultTool || 'builtin-editor'
     }
   ]);
 
-  // Check if we should pass the current directory
+  if (selectedTool === 'builtin-editor') {
+    await interactiveEditMode();
+    return;
+  }
+
   const { passDirectory } = await inquirer.prompt([
     {
       type: 'confirm',
@@ -270,23 +506,53 @@ async function interactiveMode(): Promise<void> {
   runTool(selectedTool, args);
 }
 
-// Setup version from package.json
+// Setup version
 const packagePath = path.join(__dirname, '../../package.json');
-let version = '1.2.0';
+let version = '2.0.0';
 try {
   const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf-8'));
   version = packageJson.version;
 } catch (error) {
-  // Use default version if package.json not found
+  // Use default version
 }
 
 program
   .name('dev')
-  .description('Hanzo Dev - Meta AI development CLI that manages and runs all AI coding assistants')
+  .description('Hanzo Dev - Meta AI development CLI with built-in editor and tool orchestration')
   .version(version);
 
-// Direct tool commands
+// Built-in editor command
+program
+  .command('edit [path]')
+  .description('Launch built-in editor with file editing and MCP tools')
+  .action(async (path) => {
+    if (path && fs.existsSync(path)) {
+      process.chdir(path);
+    }
+    await interactiveEditMode();
+  });
+
+// External tool commands
 Object.entries(TOOLS).forEach(([toolKey, toolConfig]) => {
+  if (toolKey === 'hanzo-dev') {
+    // Special alias for hanzo-dev
+    program
+      .command('python [args...]')
+      .description('Launch Python hanzo-dev (OpenHands)')
+      .action(async (args) => {
+        const isInstalled = await isToolInstalled('hanzo-dev');
+        if (!isInstalled && !hasUvx()) {
+          console.error(chalk.red('Hanzo Dev is not installed.'));
+          console.log(chalk.yellow('\nTo install:'));
+          console.log(chalk.gray('  pip install hanzo-dev'));
+          console.log(chalk.gray('  # or'));
+          console.log(chalk.gray('  pip install uv && uvx hanzo-dev'));
+          process.exit(1);
+        }
+        runTool('hanzo-dev', args);
+      });
+  }
+  
   program
     .command(`${toolKey} [args...]`)
     .description(`Launch ${toolConfig.name}`)
@@ -296,25 +562,14 @@ Object.entries(TOOLS).forEach(([toolKey, toolConfig]) => {
       
       if (!isInstalled && !hasKey) {
         console.error(chalk.red(`${toolConfig.name} is not available.`));
-        console.log(chalk.yellow(`\nTo use ${toolConfig.name}, you need to either:`));
-        console.log(chalk.yellow('1. Install it:'));
-        console.log(chalk.gray(`   Follow installation instructions for ${toolConfig.name}`));
-        console.log(chalk.yellow('\n2. Configure API keys:'));
-        toolConfig.apiKeys?.forEach(key => {
-          console.log(chalk.gray(`   ${key}=your-api-key`));
-        });
         process.exit(1);
       }
       
-      if (!isInstalled) {
-        console.log(chalk.yellow(`Note: ${toolConfig.name} is not installed locally, using API mode.`));
-      }
-      
       runTool(toolKey, args);
     });
 });
 
-// List installed tools
+// List command
 program
   .command('list')
   .alias('ls')
@@ -322,7 +577,6 @@ program
   .action(async () => {
     console.log(chalk.bold.cyan('\n📋 AI Tools Status:\n'));
     
-    // Show environment files
     const envFiles = ['.env', '.env.local', '.env.development', '.env.production'];
     const detectedEnvFiles = envFiles.filter(file => fs.existsSync(path.join(process.cwd(), file)));
     if (detectedEnvFiles.length > 0) {
@@ -333,34 +587,27 @@ program
       console.log();
     }
     
-    // Show API keys
-    console.log(chalk.bold('API Keys:'));
-    const allApiKeys = new Set<string>();
-    Object.values(TOOLS).forEach(tool => {
-      tool.apiKeys?.forEach(key => allApiKeys.add(key));
-    });
-    
-    let hasAnyKey = false;
-    allApiKeys.forEach(key => {
-      if (process.env[key]) {
-        console.log(chalk.green(`  ✓ ${key} = ${process.env[key]?.substring(0, 10)}...`));
-        hasAnyKey = true;
-      }
-    });
+    console.log(chalk.bold('Built-in Features:'));
+    console.log(chalk.green('  ✓ Interactive Editor') + chalk.gray(' - File editing with view, create, str_replace'));
+    console.log(chalk.green('  ✓ MCP Client') + chalk.gray(' - Model Context Protocol tool integration'));
+    console.log(chalk.green('  ✓ Function Calling') + chalk.gray(' - Unified tool interface'));
+    console.log();
     
-    if (!hasAnyKey) {
-      console.log(chalk.gray('  (no API keys detected)'));
+    if (hasUvx()) {
+      console.log(chalk.bold('Package Manager:'));
+      console.log(chalk.green('  ✓ uvx available (can run Python tools without installation)'));
+      console.log();
     }
-    console.log();
     
-    // Show tools
-    console.log(chalk.bold('Tools:'));
+    console.log(chalk.bold('External Tools:'));
     for (const [toolKey, toolConfig] of Object.entries(TOOLS)) {
       const isInstalled = await isToolInstalled(toolKey);
       const hasKey = hasApiKey(toolKey);
       
       let status = chalk.red('✗ Not Available');
-      if (isInstalled && hasKey) {
+      if (toolKey === 'hanzo-dev' && hasUvx()) {
+        status = chalk.green('✓ Ready (via uvx)');
+      } else if (isInstalled && hasKey) {
         status = chalk.green('✓ Ready (Installed + API Key)');
       } else if (isInstalled) {
         status = chalk.yellow('⚠ Installed (No API Key)');
@@ -368,11 +615,13 @@ program
         status = chalk.cyan('☁ API Mode (Not Installed)');
       }
       
-      console.log(`  ${status} ${toolConfig.color(toolConfig.name)}`);
-      console.log(chalk.gray(`     ${toolConfig.description}`));
-      if (!hasKey && toolConfig.apiKeys) {
-        console.log(chalk.gray(`     Requires: ${toolConfig.apiKeys.join(' or ')}`));
+      let displayName = toolConfig.color(toolConfig.name);
+      if (toolConfig.isDefault) {
+        displayName += chalk.bold.magenta(' ★');
       }
+      
+      console.log(`  ${status} ${displayName}`);
+      console.log(chalk.gray(`     ${toolConfig.description}`));
     }
   });
 
@@ -381,13 +630,19 @@ program
   .command('status')
   .description('Show current working directory and environment')
   .action(() => {
+    const config = new ConfigManager();
+    
     console.log(chalk.bold.cyan('\n📊 Hanzo Dev Status\n'));
     console.log(`Current Directory: ${chalk.green(process.cwd())}`);
     console.log(`User: ${chalk.green(os.userInfo().username)}`);
     console.log(`Node Version: ${chalk.green(process.version)}`);
     console.log(`Platform: ${chalk.green(os.platform())}`);
+    console.log(`Dev Version: ${chalk.green(version)}`);
+    
+    if (hasUvx()) {
+      console.log(`UV/UVX: ${chalk.green('✓ Available')}`);
+    }
     
-    // Show environment files
     const envFiles = ['.env', '.env.local', '.env.development', '.env.production'];
     const detectedEnvFiles = envFiles.filter(file => fs.existsSync(path.join(process.cwd(), file)));
     if (detectedEnvFiles.length > 0) {
@@ -396,18 +651,280 @@ program
         console.log(chalk.green(`  ✓ ${file}`));
       });
     }
+    
+    console.log(`\nConfiguration:`);
+    const cfg = config.getConfig();
+    console.log(`  Default Agent: ${chalk.yellow(cfg.defaultAgent)}`);
+    console.log(`  Runtime: ${chalk.yellow(cfg.runtime || 'cli')}`);
+    console.log(`  Confirmation Mode: ${chalk.yellow(cfg.security.confirmationMode ? 'On' : 'Off')}`);
   });
 
-// Default action - run default tool or interactive mode
+// Workspace command - unified workspace with shell, editor, browser, planner
 program
+  .command('workspace')
+  .alias('ws')
+  .description('Launch unified workspace with shell, editor, browser, and planner')
   .action(async () => {
+    const session = new WorkspaceSession();
+    await session.start();
+  });
+
+// Swarm command - spawn multiple agents for parallel work
+program
+  .command('swarm [path]')
+  .description('Spawn agent swarm for codebase (one agent per file/directory)')
+  .option('-t, --type <type>', 'Agent type (claude-code, aider, openhands)', 'claude-code')
+  .option('-s, --strategy <strategy>', 'Assignment strategy (one-per-file, one-per-directory, by-complexity)', 'one-per-file')
+  .action(async (path, options) => {
+    const targetPath = path || process.cwd();
+    const network = new PeerAgentNetwork();
+    
+    try {
+      await network.spawnAgentsForCodebase(targetPath, options.type, options.strategy);
+      
+      // Show network status
+      const status = network.getNetworkStatus();
+      console.log(chalk.cyan('\n📊 Network Status:'));
+      console.log(`  Agents: ${status.totalAgents} (${status.activeAgents} active)`);
+      console.log(`  Connections: ${status.totalConnections}`);
+      
+      // Interactive swarm control
+      const { action } = await inquirer.prompt([{
+        type: 'list',
+        name: 'action',
+        message: 'What would you like to do?',
+        choices: [
+          { name: 'Execute task on swarm', value: 'task' },
+          { name: 'Run parallel tasks', value: 'parallel' },
+          { name: 'Show network status', value: 'status' },
+          { name: 'Exit', value: 'exit' }
+        ]
+      }]);
+      
+      if (action === 'task') {
+        const { task } = await inquirer.prompt([{
+          type: 'input',
+          name: 'task',
+          message: 'Enter task for swarm:'
+        }]);
+        
+        await network.coordinateSwarm(task);
+      } else if (action === 'parallel') {
+        console.log(chalk.yellow('Enter tasks (one per line, empty line to finish):'));
+        const tasks: Array<{task: string}> = [];
+        
+        while (true) {
+          const { task } = await inquirer.prompt([{
+            type: 'input',
+            name: 'task',
+            message: '>'
+          }]);
+          
+          if (!task) break;
+          tasks.push({ task });
+        }
+        
+        if (tasks.length > 0) {
+          await network.executeParallelTasks(tasks);
+        }
+      } else if (action === 'status') {
+        const status = network.getNetworkStatus();
+        console.log(chalk.cyan('\n📊 Detailed Network Status:'));
+        console.log(JSON.stringify(status, null, 2));
+      }
+      
+      await network.cleanup();
+    } catch (error) {
+      console.error(chalk.red(`Swarm error: ${error}`));
+      await network.cleanup();
+    }
+  });
+
+// Agent command - run a task with CodeAct agent
+program
+  .command('agent <task>')
+  .description('Execute a task using CodeAct agent with automatic planning and error correction')
+  .action(async (task) => {
+    const agent = new CodeActAgent();
+    try {
+      await agent.executeTask(task);
+    } catch (error) {
+      console.error(chalk.red(`Agent error: ${error}`));
+    }
+  });
+
+// Benchmark command - run SWE-bench evaluation
+program
+  .command('benchmark')
+  .alias('bench')
+  .description('Run SWE-bench evaluation to measure performance')
+  .option('-d, --dataset <dataset>', 'Dataset to use (swe-bench, swe-bench-lite, custom)', 'swe-bench-lite')
+  .option('-a, --agents <number>', 'Number of agents for parallel execution', '5')
+  .option('-p, --parallel', 'Run tasks in parallel', true)
+  .option('-t, --timeout <ms>', 'Timeout per task in milliseconds', '300000')
+  .option('-o, --output <file>', 'Output file for results', 'benchmark-results.json')
+  .option('--provider <provider>', 'LLM provider (claude, openai, gemini, local)')
+  .option('--max-tasks <number>', 'Maximum number of tasks to run')
+  .action(async (options) => {
+    console.log(chalk.bold.cyan('\n🏃 Starting Hanzo Dev Benchmark\n'));
+    
+    // Parse options
+    const config: BenchmarkConfig = {
+      dataset: options.dataset as any,
+      agents: parseInt(options.agents),
+      parallel: options.parallel !== 'false',
+      timeout: parseInt(options.timeout),
+      output: options.output,
+      maxTasks: options.maxTasks ? parseInt(options.maxTasks) : undefined
+    };
+
+    // Set provider if specified
+    if (options.provider) {
+      const providers = ConfigurableAgentLoop.getAvailableProviders();
+      const provider = providers.find(p => 
+        p.type === options.provider || 
+        p.name.toLowerCase().includes(options.provider.toLowerCase())
+      );
+      
+      if (provider) {
+        config.provider = provider;
+      } else {
+        console.error(chalk.red(`Provider '${options.provider}' not found or not configured`));
+        console.log(chalk.yellow('\nAvailable providers:'));
+        providers.forEach(p => {
+          console.log(`  - ${p.name} (${p.type})`);
+        });
+        process.exit(1);
+      }
+    }
+
+    // Run benchmark
+    const runner = new BenchmarkRunner(config);
+    
+    try {
+      await runner.run();
+      console.log(chalk.green('\n✅ Benchmark completed successfully'));
+    } catch (error) {
+      console.error(chalk.red(`\n❌ Benchmark failed: ${error}`));
+      process.exit(1);
+    }
+  });
+
+// Add global options for provider and swarm
+program
+  .option('--claude', 'Use Claude AI provider')
+  .option('--openai', 'Use OpenAI provider') 
+  .option('--gemini', 'Use Gemini provider')
+  .option('--grok', 'Use Grok provider')
+  .option('--local', 'Use local AI provider')
+  .option('--swarm <count>', 'Launch swarm of agents (up to 100)')
+  .option('-p, --prompt <prompt>', 'Task prompt for agents');
+
+// Swarm mode function
+async function runSwarmMode(options: any): Promise<void> {
+  // Determine provider
+  let provider: SwarmOptions['provider'] = 'claude';
+  if (options.claude) provider = 'claude';
+  else if (options.openai) provider = 'openai';
+  else if (options.gemini) provider = 'gemini';
+  else if (options.grok) provider = 'grok';
+  else if (options.local) provider = 'local';
+
+  // Parse swarm count
+  const count = Math.min(parseInt(options.swarm) || 5, 100);
+
+  if (!options.prompt) {
+    console.error(chalk.red('Error: --prompt is required when using --swarm'));
+    process.exit(1);
+  }
+
+  const swarmOptions: SwarmOptions = {
+    provider,
+    count,
+    prompt: options.prompt,
+    cwd: process.cwd(),
+    autoLogin: true
+  };
+
+  console.log(chalk.bold.cyan(`\n🐝 Hanzo Dev Swarm Mode\n`));
+  console.log(chalk.gray(`Provider: ${provider}`));
+  console.log(chalk.gray(`Agents: ${count}`));
+  console.log(chalk.gray(`Prompt: ${options.prompt}\n`));
+
+  const runner = new SwarmRunner(swarmOptions);
+
+  // Check authentication
+  const hasAuth = await runner.ensureProviderAuth();
+  if (!hasAuth) {
+    console.error(chalk.red(`\nError: ${provider} is not authenticated`));
+    console.log(chalk.yellow('\nTo authenticate:'));
+    
+    switch (provider) {
+      case 'claude':
+        console.log(chalk.gray('  1. Set ANTHROPIC_API_KEY environment variable'));
+        console.log(chalk.gray('  2. Run: claude login'));
+        break;
+      case 'openai':
+        console.log(chalk.gray('  Set OPENAI_API_KEY environment variable'));
+        break;
+      case 'gemini':
+        console.log(chalk.gray('  Set GOOGLE_API_KEY or GEMINI_API_KEY environment variable'));
+        break;
+      case 'grok':
+        console.log(chalk.gray('  Set GROK_API_KEY environment variable'));
+        break;
+    }
+    process.exit(1);
+  }
+
+  try {
+    await runner.run();
+  } catch (error) {
+    console.error(chalk.red(`\nSwarm error: ${error}`));
+    process.exit(1);
+  }
+}
+
+// Default action
+program
+  .action(async (options) => {
+    // Check if swarm mode is requested
+    if (options.swarm) {
+      await runSwarmMode(options);
+      return;
+    }
+
+    // Check if a specific provider is requested
+    if (options.claude || options.openai || options.gemini || options.grok || options.local) {
+      let provider = 'claude';
+      if (options.claude) provider = 'claude';
+      else if (options.openai) provider = 'openai';
+      else if (options.gemini) provider = 'gemini';
+      else if (options.grok) provider = 'grok';
+      else if (options.local) provider = 'local';
+
+      // Map provider to tool name
+      const toolMap: Record<string, string> = {
+        claude: 'claude',
+        openai: 'codex',
+        gemini: 'gemini',
+        grok: 'grok',
+        local: 'hanzo-dev'
+      };
+
+      const toolName = toolMap[provider];
+      if (toolName && TOOLS[toolName as keyof typeof TOOLS]) {
+        console.log(chalk.gray(`Launching ${TOOLS[toolName as keyof typeof TOOLS].name}...`));
+        runTool(toolName, options.prompt ? [options.prompt] : ['.']);
+        return;
+      }
+    }
+
     const defaultTool = await getDefaultTool();
     if (defaultTool && process.argv.length === 2) {
-      // If we have a default tool and no arguments, run it directly
-      console.log(chalk.gray(`Auto-selecting ${TOOLS[defaultTool as keyof typeof TOOLS].name} based on available API keys...`));
+      console.log(chalk.gray(`Auto-launching ${TOOLS[defaultTool as keyof typeof TOOLS].name}...`));
       runTool(defaultTool, ['.']);
     } else {
-      // Otherwise show interactive mode
       interactiveMode();
     }
   });
@@ -415,12 +932,12 @@ program
 // Parse arguments
 program.parse();
 
-// If no arguments provided, check for default tool
+// If no arguments, run interactive mode
 if (process.argv.length === 2) {
   (async () => {
     const defaultTool = await getDefaultTool();
     if (defaultTool) {
-      console.log(chalk.gray(`Auto-selecting ${TOOLS[defaultTool as keyof typeof TOOLS].name} based on available API keys...`));
+      console.log(chalk.gray(`Auto-launching ${TOOLS[defaultTool as keyof typeof TOOLS].name}...`));
       runTool(defaultTool, ['.']);
     } else {
       interactiveMode();