@hanzo/dev 2.0.0 → 2.1.1

package/src/lib/editor.ts

@@ -29,6 +29,10 @@ export class FileEditor {
   private editHistory: Map<string, string[]> = new Map();
   private currentFile: string | null = null;
 
+  constructor(workingDir: string = process.cwd()) {
+    // No need to instantiate ChunkLocalizer as it has static methods
+  }
+
   async execute(command: EditCommand): Promise<EditResult> {
     switch (command.command) {
       case 'view':
@@ -290,6 +294,29 @@ export class FileEditor {
     if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(2)} KB`;
     return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
   }
+
+  async getRelevantChunks(filePath: string, query: string): Promise<any[]> {
+    try {
+      if (!fs.existsSync(filePath)) {
+        return [];
+      }
+
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const chunk = ChunkLocalizer.findRelevantChunk(content, query);
+      
+      if (!chunk) {
+        return [];
+      }
+
+      return [{
+        startLine: chunk.startLine,
+        endLine: chunk.endLine,
+        content: chunk.content
+      }];
+    } catch (error) {
+      return [];
+    }
+  }
 }
 
 // Chunk localizer for finding relevant code sections

package/src/lib/swarm-runner.ts

@@ -0,0 +1,389 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { glob } from 'glob';
+import chalk from 'chalk';
+import ora from 'ora';
+import { spawn, ChildProcess } from 'child_process';
+import { EventEmitter } from 'events';
+
+export interface SwarmOptions {
+  provider: 'claude' | 'openai' | 'gemini' | 'grok' | 'local';
+  count: number;
+  prompt: string;
+  cwd?: string;
+  pattern?: string;
+  autoLogin?: boolean;
+}
+
+export interface SwarmAgent {
+  id: string;
+  process?: ChildProcess;
+  file?: string;
+  status: 'idle' | 'busy' | 'done' | 'error';
+  result?: string;
+  error?: string;
+}
+
+export class SwarmRunner extends EventEmitter {
+  private agents: Map<string, SwarmAgent> = new Map();
+  private fileQueue: string[] = [];
+  private options: SwarmOptions;
+  private activeCount: number = 0;
+
+  constructor(options: SwarmOptions) {
+    super();
+    this.options = {
+      cwd: process.cwd(),
+      pattern: '**/*',
+      autoLogin: true,
+      ...options
+    };
+  }
+
+  async run(): Promise<void> {
+    const spinner = ora(`Initializing swarm with ${this.options.count} agents...`).start();
+
+    try {
+      // Find files to process
+      spinner.text = `Searching for files in ${this.options.cwd || process.cwd()}...`;
+      this.fileQueue = await this.findFiles();
+      spinner.succeed(`Found ${this.fileQueue.length} files to process`);
+
+      if (this.fileQueue.length === 0) {
+        console.log(chalk.yellow('No files found matching pattern'));
+        return;
+      }
+
+      // Initialize agent pool
+      const agentCount = Math.min(this.options.count, this.fileQueue.length);
+      spinner.start(`Spawning ${agentCount} agents...`);
+      
+      for (let i = 0; i < agentCount; i++) {
+        const agent: SwarmAgent = {
+          id: `agent-${i}`,
+          status: 'idle'
+        };
+        this.agents.set(agent.id, agent);
+      }
+      
+      spinner.succeed(`Spawned ${agentCount} agents`);
+
+      // Process files in parallel
+      spinner.start('Processing files...');
+      const startTime = Date.now();
+      
+      // Start processing
+      await this.processFiles();
+      
+      const duration = (Date.now() - startTime) / 1000;
+      spinner.succeed(`Completed in ${duration.toFixed(1)}s`);
+
+      // Show results
+      this.showResults();
+
+    } catch (error) {
+      spinner.fail(`Swarm error: ${error}`);
+      throw error;
+    }
+  }
+
+  private async findFiles(): Promise<string[]> {
+    return new Promise((resolve, reject) => {
+      const options = {
+        cwd: this.options.cwd,
+        nodir: true,
+        ignore: [
+          '**/node_modules/**',
+          '**/.git/**',
+          '**/dist/**',
+          '**/build/**',
+          '**/*.min.js',
+          '**/*.map'
+        ]
+      };
+
+      // Add timeout to prevent hanging
+      const timeout = setTimeout(() => {
+        reject(new Error('File search timed out'));
+      }, 30000);
+
+      const pattern = this.options.pattern || '**/*';
+      console.log(chalk.gray(`Searching with pattern: ${pattern} in ${options.cwd || process.cwd()}`));
+      
+      glob(pattern, options, (err, files) => {
+        clearTimeout(timeout);
+        if (err) {
+          console.error(chalk.red('Glob error:'), err);
+          reject(err);
+        } else {
+          console.log(chalk.gray(`Found ${files.length} total files`));
+          // Filter to only editable files
+          const editableFiles = files.filter(file => {
+            const ext = path.extname(file);
+            return ['.js', '.ts', '.jsx', '.tsx', '.py', '.java', '.cpp', '.c', '.h', '.go', '.rs', '.rb', '.php', '.swift', '.kt', '.scala', '.r', '.m', '.mm', '.md', '.txt', '.json', '.xml', '.yaml', '.yml', '.toml', '.ini', '.conf', '.sh', '.bash', '.zsh', '.fish', '.ps1', '.bat', '.cmd'].includes(ext);
+          });
+          console.log(chalk.gray(`Filtered to ${editableFiles.length} editable files`));
+          resolve(editableFiles);
+        }
+      });
+    });
+  }
+
+  private async processFiles(): Promise<void> {
+    const promises: Promise<void>[] = [];
+
+    // Start initial batch of work
+    for (const [id, agent] of this.agents) {
+      if (this.fileQueue.length > 0) {
+        promises.push(this.processNextFile(agent));
+      }
+    }
+
+    // Wait for all agents to complete
+    await Promise.all(promises);
+  }
+
+  private async processNextFile(agent: SwarmAgent): Promise<void> {
+    while (this.fileQueue.length > 0) {
+      const file = this.fileQueue.shift();
+      if (!file) break;
+
+      agent.file = file;
+      agent.status = 'busy';
+      this.activeCount++;
+
+      try {
+        await this.processFile(agent, file);
+        agent.status = 'done';
+      } catch (error) {
+        agent.status = 'error';
+        agent.error = error instanceof Error ? error.message : String(error);
+      } finally {
+        this.activeCount--;
+      }
+    }
+  }
+
+  private async processFile(agent: SwarmAgent, file: string): Promise<void> {
+    const fullPath = path.join(this.options.cwd!, file);
+    
+    // Build command based on provider
+    const command = this.buildCommand(file);
+    
+    return new Promise((resolve, reject) => {
+      const child = spawn(command.cmd, command.args, {
+        cwd: this.options.cwd,
+        env: {
+          ...process.env,
+          ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY,
+          OPENAI_API_KEY: process.env.OPENAI_API_KEY,
+          GOOGLE_API_KEY: process.env.GOOGLE_API_KEY,
+          GROK_API_KEY: process.env.GROK_API_KEY,
+          // Auto-accept edits for non-interactive mode
+          CLAUDE_CODE_PERMISSION_MODE: 'acceptEdits'
+        }
+      });
+
+      agent.process = child;
+      
+      let output = '';
+      let error = '';
+
+      child.stdout?.on('data', (data) => {
+        output += data.toString();
+      });
+
+      child.stderr?.on('data', (data) => {
+        error += data.toString();
+      });
+
+      child.on('close', (code) => {
+        if (code === 0) {
+          agent.result = output;
+          resolve();
+        } else {
+          reject(new Error(`Process exited with code ${code}: ${error}`));
+        }
+      });
+
+      child.on('error', (err) => {
+        reject(err);
+      });
+    });
+  }
+
+  private buildCommand(file: string): { cmd: string, args: string[] } {
+    const fullPath = path.join(this.options.cwd!, file);
+    const filePrompt = `${this.options.prompt}\n\nFile: ${file}`;
+
+    switch (this.options.provider) {
+      case 'claude':
+        return {
+          cmd: 'claude',
+          args: [
+            '-p',
+            filePrompt,
+            '--max-turns', '5',
+            '--allowedTools', 'Read,Write,Edit',
+            '--permission-mode', 'acceptEdits'
+          ]
+        };
+
+      case 'openai':
+        return {
+          cmd: 'openai',
+          args: [
+            'chat',
+            '--prompt', filePrompt,
+            '--file', fullPath,
+            '--edit'
+          ]
+        };
+
+      case 'gemini':
+        return {
+          cmd: 'gemini',
+          args: [
+            'edit',
+            fullPath,
+            '--prompt', filePrompt
+          ]
+        };
+
+      case 'grok':
+        return {
+          cmd: 'grok',
+          args: [
+            '--edit',
+            fullPath,
+            '--prompt', filePrompt
+          ]
+        };
+
+      case 'local':
+        return {
+          cmd: 'dev',
+          args: [
+            'agent',
+            filePrompt
+          ]
+        };
+
+      default:
+        throw new Error(`Unknown provider: ${this.options.provider}`);
+    }
+  }
+
+  private showResults(): void {
+    console.log(chalk.bold.cyan('\n📊 Swarm Results\n'));
+
+    let successful = 0;
+    let failed = 0;
+
+    for (const [id, agent] of this.agents) {
+      if (agent.status === 'done') {
+        successful++;
+        console.log(chalk.green(`✓ ${agent.file || id}`));
+      } else if (agent.status === 'error') {
+        failed++;
+        console.log(chalk.red(`✗ ${agent.file || id}: ${agent.error}`));
+      }
+    }
+
+    console.log(chalk.gray('\n─────────────────'));
+    console.log(chalk.white('Total files:'), this.fileQueue.length + successful + failed);
+    console.log(chalk.green('Successful:'), successful);
+    if (failed > 0) {
+      console.log(chalk.red('Failed:'), failed);
+    }
+  }
+
+  async ensureProviderAuth(): Promise<boolean> {
+    switch (this.options.provider) {
+      case 'claude':
+        return this.ensureClaudeAuth();
+      case 'openai':
+        return !!process.env.OPENAI_API_KEY;
+      case 'gemini':
+        return !!process.env.GOOGLE_API_KEY || !!process.env.GEMINI_API_KEY;
+      case 'grok':
+        return !!process.env.GROK_API_KEY;
+      case 'local':
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  private async ensureClaudeAuth(): Promise<boolean> {
+    // Check if already authenticated
+    try {
+      const testResult = await new Promise<boolean>((resolve) => {
+        const child = spawn('claude', ['-p', 'test', '--max-turns', '1'], {
+          env: process.env
+        });
+
+        let hasError = false;
+        let resolved = false;
+        
+        const cleanup = () => {
+          if (!resolved) {
+            resolved = true;
+            clearTimeout(timeout);
+            child.kill();
+          }
+        };
+
+        child.stderr?.on('data', (data) => {
+          const output = data.toString();
+          if (output.includes('not authenticated') || output.includes('API key')) {
+            hasError = true;
+          }
+        });
+
+        child.on('close', () => {
+          cleanup();
+          resolve(!hasError);
+        });
+
+        // Timeout after 5 seconds
+        const timeout = setTimeout(() => {
+          cleanup();
+          resolve(!hasError);
+        }, 5000);
+      });
+
+      if (testResult) {
+        return true;
+      }
+
+      // Try to login automatically if we have API key
+      if (process.env.ANTHROPIC_API_KEY && this.options.autoLogin) {
+        console.log(chalk.yellow('Attempting automatic Claude login...'));
+        
+        const loginResult = await new Promise<boolean>((resolve) => {
+          const child = spawn('claude', ['login'], {
+            env: {
+              ...process.env,
+              ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY
+            },
+            stdio: 'inherit'
+          });
+
+          child.on('close', (code) => {
+            resolve(code === 0);
+          });
+        });
+
+        if (loginResult) {
+          console.log(chalk.green('✓ Claude login successful'));
+          return true;
+        }
+      }
+
+      return false;
+    } catch (error) {
+      return false;
+    }
+  }
+}

package/test-swarm/file1.js

@@ -0,0 +1,6 @@
+// Sample JavaScript file
+function calculateTotal(items) {
+  return items.reduce((sum, item) => sum + item.price, 0);
+}
+
+module.exports = { calculateTotal };

package/test-swarm/file2.ts

@@ -0,0 +1,12 @@
+// TypeScript utility functions
+export function formatDate(date: Date): string {
+  return date.toISOString().split('T')[0];
+}
+
+export function parseJSON<T>(json: string): T | null {
+  try {
+    return JSON.parse(json);
+  } catch {
+    return null;
+  }
+}

package/test-swarm/file3.py

@@ -0,0 +1,15 @@
+# Python data processing
+import json
+from typing import List, Dict
+
+def process_data(items: List[Dict]) -> Dict:
+    """Process a list of items and return summary statistics."""
+    total = sum(item.get('value', 0) for item in items)
+    count = len(items)
+    average = total / count if count > 0 else 0
+    
+    return {
+        'total': total,
+        'count': count,
+        'average': average
+    }

package/test-swarm/file4.md

@@ -0,0 +1,13 @@
+# Documentation
+
+This is a sample markdown file for testing the swarm functionality.
+
+## Features
+
+- Parallel processing
+- Multiple file types
+- Automatic edits
+
+## Usage
+
+Run the swarm command to process multiple files at once.

package/test-swarm/file5.json

@@ -0,0 +1,12 @@
+{
+  "name": "test-project",
+  "version": "1.0.0",
+  "description": "Test project for swarm processing",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": ["test", "swarm"],
+  "author": "",
+  "license": "ISC"
+}

package/test-swarm-demo.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+echo "🐝 Hanzo Dev Swarm Demo"
+echo "======================"
+echo ""
+echo "This demo will add copyright headers to 5 test files in parallel"
+echo ""
+echo "Files before:"
+echo "-------------"
+head -n 1 test-swarm/*.{js,ts,py,md,json} 2>/dev/null
+
+echo ""
+echo "Running swarm with 5 agents..."
+echo ""
+
+# Run the swarm command
+node dist/cli/dev.js --claude --swarm 5 -p "Add this copyright header at the very top of each file: '// Copyright 2025 Hanzo Industries Inc.' (use # for Python, // for JS/TS/JSON)"
+
+echo ""
+echo "Files after:"
+echo "------------"
+head -n 2 test-swarm/*.{js,ts,py,md,json} 2>/dev/null

package/tests/editor.test.ts

@@ -1,11 +1,11 @@
-import { describe, test, expect, beforeEach, afterEach } from '@jest/globals';
+import { describe, test, expect, beforeEach, afterEach } from 'vitest';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
-import { Editor, EditCommand } from '../src/lib/editor';
+import { FileEditor, EditCommand } from '../src/lib/editor';
 
 describe('Editor', () => {
-  let editor: Editor;
+  let editor: FileEditor;
   let testDir: string;
   let testFile: string;
 
@@ -13,7 +13,7 @@ describe('Editor', () => {
     // Create temporary test directory
     testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'hanzo-dev-test-'));
     testFile = path.join(testDir, 'test.txt');
-    editor = new Editor(testDir);
+    editor = new FileEditor(testDir);
   });
 
   afterEach(() => {
@@ -46,7 +46,7 @@ describe('Editor', () => {
 
       const result = await editor.execute(command);
       expect(result.success).toBe(false);
-      expect(result.error).toContain('already exists');
+      expect(result.error).toBe('FILE_EXISTS');
     });
   });
 
@@ -121,7 +121,7 @@ describe('Editor', () => {
 
       const result = await editor.execute(command);
       expect(result.success).toBe(false);
-      expect(result.error).toContain('not found');
+      expect(result.error).toBe('STRING_NOT_FOUND');
     });
 
     test('should fail when old string appears multiple times', async () => {
@@ -137,7 +137,7 @@ describe('Editor', () => {
 
       const result = await editor.execute(command);
       expect(result.success).toBe(false);
-      expect(result.error).toContain('multiple');
+      expect(result.error).toBe('STRING_NOT_UNIQUE');
     });
   });
 

package/tests/fixtures/sample-code.js

@@ -0,0 +1,13 @@
+// Sample JavaScript code for testing
+function calculateSum(numbers) {
+  return numbers.reduce((sum, num) => sum + num, 0);
+}
+
+function findMax(numbers) {
+  return Math.max(...numbers);
+}
+
+module.exports = {
+  calculateSum,
+  findMax
+};

package/tests/fixtures/sample-code.py

@@ -0,0 +1,28 @@
+# Sample Python code for testing
+import json
+from typing import List, Dict, Optional
+
+class DataProcessor:
+    """Process and analyze data."""
+    
+    def __init__(self):
+        self.data = []
+    
+    def add_item(self, item: Dict) -> None:
+        """Add an item to the dataset."""
+        self.data.append(item)
+    
+    def get_summary(self) -> Dict:
+        """Get summary statistics."""
+        if not self.data:
+            return {"count": 0, "total": 0, "average": 0}
+        
+        values = [item.get("value", 0) for item in self.data]
+        total = sum(values)
+        count = len(values)
+        
+        return {
+            "count": count,
+            "total": total,
+            "average": total / count if count > 0 else 0
+        }

package/tests/fixtures/sample-code.ts

@@ -0,0 +1,22 @@
+// Sample TypeScript code for testing
+interface User {
+  id: number;
+  name: string;
+  email: string;
+}
+
+export class UserService {
+  private users: User[] = [];
+
+  addUser(user: User): void {
+    this.users.push(user);
+  }
+
+  getUser(id: number): User | undefined {
+    return this.users.find(user => user.id === id);
+  }
+
+  getAllUsers(): User[] {
+    return [...this.users];
+  }
+}

package/tests/mcp-client.test.ts

@@ -1,10 +1,10 @@
-import { describe, test, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import { describe, test, expect, beforeEach, afterEach, vi } from 'vitest';
 import { MCPClient, MCPSession, MCPServerConfig } from '../src/lib/mcp-client';
 import { EventEmitter } from 'events';
 import * as child_process from 'child_process';
 
 // Mock child_process
-jest.mock('child_process');
+vi.mock('child_process');
 
 describe('MCPClient', () => {
   let client: MCPClient;
@@ -15,16 +15,16 @@ describe('MCPClient', () => {
     
     // Mock spawn to return a fake process
     mockProcess = new EventEmitter();
-    mockProcess.stdin = { write: jest.fn() };
+    mockProcess.stdin = { write: vi.fn() };
     mockProcess.stdout = new EventEmitter();
     mockProcess.stderr = new EventEmitter();
-    mockProcess.kill = jest.fn();
+    mockProcess.kill = vi.fn();
 
-    (child_process.spawn as jest.Mock).mockReturnValue(mockProcess);
+    vi.mocked(child_process.spawn).mockReturnValue(mockProcess as any);
   });
 
   afterEach(() => {
-    jest.clearAllMocks();
+    vi.clearAllMocks();
   });
 
   describe('stdio transport', () => {