@hanzo/dev 1.2.0 → 2.1.0

package/tests/peer-agent-network.test.ts

@@ -0,0 +1,340 @@
+import { describe, test, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import { PeerAgentNetwork, AgentConfig } from '../src/lib/peer-agent-network';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+describe('PeerAgentNetwork', () => {
+  let network: PeerAgentNetwork;
+  let testDir: string;
+
+  beforeEach(() => {
+    network = new PeerAgentNetwork();
+    testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'peer-network-test-'));
+    
+    // Create test file structure
+    fs.mkdirSync(path.join(testDir, 'src'));
+    fs.mkdirSync(path.join(testDir, 'tests'));
+    fs.writeFileSync(path.join(testDir, 'src', 'index.js'), 'console.log("Hello");');
+    fs.writeFileSync(path.join(testDir, 'src', 'utils.js'), 'export function util() {}');
+    fs.writeFileSync(path.join(testDir, 'tests', 'index.test.js'), 'test("sample", () => {});');
+  });
+
+  afterEach(() => {
+    // Clean up
+    fs.rmSync(testDir, { recursive: true, force: true });
+  });
+
+  describe('agent spawning', () => {
+    test('should spawn agent with configuration', async () => {
+      const config: AgentConfig = {
+        id: 'test-agent',
+        name: 'Test Agent',
+        type: 'claude-code',
+        responsibility: 'Test file processing',
+        tools: ['edit_file', 'view_file']
+      };
+
+      await network.spawnAgent(config);
+      
+      const agents = network.getActiveAgents();
+      expect(agents).toHaveLength(1);
+      expect(agents[0].id).toBe('test-agent');
+      expect(agents[0].status).toBe('active');
+    });
+
+    test('should prevent duplicate agent IDs', async () => {
+      const config: AgentConfig = {
+        id: 'duplicate',
+        name: 'Agent 1',
+        type: 'claude-code'
+      };
+
+      await network.spawnAgent(config);
+      
+      // Try to spawn with same ID
+      await expect(network.spawnAgent({
+        ...config,
+        name: 'Agent 2'
+      })).rejects.toThrow('already exists');
+    });
+  });
+
+  describe('codebase agent spawning', () => {
+    test('should spawn one agent per file', async () => {
+      await network.spawnAgentsForCodebase(testDir, 'claude-code', 'one-per-file');
+      
+      const agents = network.getActiveAgents();
+      // Should have 3 agents (3 files)
+      expect(agents).toHaveLength(3);
+      
+      // Check agent responsibilities
+      const responsibilities = agents.map(a => a.responsibility);
+      expect(responsibilities).toContain(expect.stringContaining('src/index.js'));
+      expect(responsibilities).toContain(expect.stringContaining('src/utils.js'));
+      expect(responsibilities).toContain(expect.stringContaining('tests/index.test.js'));
+    });
+
+    test('should spawn one agent per directory', async () => {
+      await network.spawnAgentsForCodebase(testDir, 'claude-code', 'one-per-directory');
+      
+      const agents = network.getActiveAgents();
+      // Should have 2 agents (src and tests directories)
+      expect(agents).toHaveLength(2);
+      
+      const responsibilities = agents.map(a => a.responsibility);
+      expect(responsibilities).toContain(expect.stringContaining('src'));
+      expect(responsibilities).toContain(expect.stringContaining('tests'));
+    });
+
+    test('should respect file patterns', async () => {
+      await network.spawnAgentsForCodebase(
+        testDir, 
+        'claude-code', 
+        'one-per-file',
+        ['**/*.test.js'] // Only test files
+      );
+      
+      const agents = network.getActiveAgents();
+      expect(agents).toHaveLength(1);
+      expect(agents[0].responsibility).toContain('tests/index.test.js');
+    });
+  });
+
+  describe('agent communication', () => {
+    test('should enable agent-to-agent messaging', async () => {
+      // Spawn two agents
+      await network.spawnAgent({
+        id: 'agent1',
+        name: 'Agent 1',
+        type: 'claude-code'
+      });
+      
+      await network.spawnAgent({
+        id: 'agent2', 
+        name: 'Agent 2',
+        type: 'claude-code'
+      });
+
+      // Send message from agent1 to agent2
+      const response = await network.sendMessage('agent1', 'agent2', {
+        type: 'query',
+        content: 'What files are you working on?'
+      });
+
+      expect(response).toBeDefined();
+      expect(response.from).toBe('agent2');
+      expect(response.to).toBe('agent1');
+    });
+
+    test('should broadcast messages to all agents', async () => {
+      // Spawn three agents
+      for (let i = 1; i <= 3; i++) {
+        await network.spawnAgent({
+          id: `agent${i}`,
+          name: `Agent ${i}`,
+          type: 'claude-code'
+        });
+      }
+
+      const responses = await network.broadcast('agent1', {
+        type: 'announcement',
+        content: 'Starting code review'
+      });
+
+      expect(responses).toHaveLength(2); // Response from agent2 and agent3
+      expect(responses.every(r => r.from !== 'agent1')).toBe(true);
+    });
+  });
+
+  describe('MCP tool exposure', () => {
+    test('should expose agents as MCP tools to each other', async () => {
+      await network.spawnAgent({
+        id: 'file-agent',
+        name: 'File Agent',
+        type: 'claude-code',
+        responsibility: 'File operations',
+        tools: ['edit_file', 'create_file']
+      });
+
+      await network.spawnAgent({
+        id: 'test-agent',
+        name: 'Test Agent', 
+        type: 'aider',
+        responsibility: 'Test writing'
+      });
+
+      // Check that each agent can see the other as a tool
+      const fileAgentTools = await network.getAgentTools('file-agent');
+      expect(fileAgentTools).toContain(expect.objectContaining({
+        name: 'ask_test_agent',
+        description: expect.stringContaining('Test Agent')
+      }));
+
+      const testAgentTools = await network.getAgentTools('test-agent');
+      expect(testAgentTools).toContain(expect.objectContaining({
+        name: 'ask_file_agent',
+        description: expect.stringContaining('File Agent')
+      }));
+    });
+
+    test('should allow recursive agent calls via MCP', async () => {
+      // Set up agents
+      await network.spawnAgent({
+        id: 'coordinator',
+        name: 'Coordinator',
+        type: 'claude-code'
+      });
+
+      await network.spawnAgent({
+        id: 'worker1',
+        name: 'Worker 1',
+        type: 'claude-code'
+      });
+
+      await network.spawnAgent({
+        id: 'worker2',
+        name: 'Worker 2',
+        type: 'claude-code'
+      });
+
+      // Coordinator delegates to workers
+      const result = await network.callAgentTool('coordinator', 'delegate_to_worker1', {
+        task: 'Process data'
+      });
+
+      expect(result).toBeDefined();
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('task coordination', () => {
+    test('should coordinate parallel tasks across agents', async () => {
+      // Create a task that can be parallelized
+      const files = [
+        'file1.js',
+        'file2.js', 
+        'file3.js',
+        'file4.js'
+      ];
+
+      // Spawn agents for parallel processing
+      const agents = await network.spawnAgentsForTask(
+        'Process multiple files',
+        files.map(f => ({
+          subtask: `Process ${f}`,
+          data: { file: f }
+        }))
+      );
+
+      expect(agents).toHaveLength(4);
+      
+      // Execute all tasks in parallel
+      const results = await network.executeParallelTasks(
+        agents.map(a => ({
+          agentId: a.id,
+          task: a.config.responsibility!
+        }))
+      );
+
+      expect(results).toHaveLength(4);
+      expect(results.every(r => r.status === 'completed')).toBe(true);
+    });
+
+    test('should handle agent failures gracefully', async () => {
+      await network.spawnAgent({
+        id: 'failing-agent',
+        name: 'Failing Agent',
+        type: 'claude-code'
+      });
+
+      // Make agent fail
+      (network as any).agents.get('failing-agent').status = 'error';
+
+      const agents = network.getActiveAgents();
+      expect(agents).toHaveLength(0); // Failed agents not in active list
+
+      const allAgents = network.getAllAgents();
+      expect(allAgents).toHaveLength(1);
+      expect(allAgents[0].status).toBe('error');
+    });
+  });
+
+  describe('swarm optimization', () => {
+    test('should optimize agent allocation based on workload', async () => {
+      // Create initial agents
+      for (let i = 1; i <= 3; i++) {
+        await network.spawnAgent({
+          id: `agent${i}`,
+          name: `Agent ${i}`,
+          type: 'claude-code'
+        });
+      }
+
+      // Simulate workload
+      const metrics = {
+        agent1: { tasksCompleted: 10, avgTime: 2.5 },
+        agent2: { tasksCompleted: 5, avgTime: 5.0 },
+        agent3: { tasksCompleted: 8, avgTime: 3.0 }
+      };
+
+      const optimization = network.optimizeSwarm(metrics);
+      
+      // Should recommend spawning more agents like agent1 (best performance)
+      expect(optimization.recommendations).toContain(
+        expect.stringContaining('agent1')
+      );
+    });
+
+    test('should monitor swarm health', async () => {
+      // Spawn multiple agents
+      for (let i = 1; i <= 5; i++) {
+        await network.spawnAgent({
+          id: `agent${i}`,
+          name: `Agent ${i}`,
+          type: i % 2 === 0 ? 'aider' : 'claude-code'
+        });
+      }
+
+      const health = network.getSwarmHealth();
+      
+      expect(health.totalAgents).toBe(5);
+      expect(health.activeAgents).toBe(5);
+      expect(health.agentTypes).toContain('claude-code');
+      expect(health.agentTypes).toContain('aider');
+    });
+  });
+
+  describe('cleanup and lifecycle', () => {
+    test('should terminate individual agents', async () => {
+      await network.spawnAgent({
+        id: 'temp-agent',
+        name: 'Temporary Agent',
+        type: 'claude-code'
+      });
+
+      expect(network.getActiveAgents()).toHaveLength(1);
+
+      await network.terminateAgent('temp-agent');
+      
+      expect(network.getActiveAgents()).toHaveLength(0);
+    });
+
+    test('should terminate all agents on shutdown', async () => {
+      // Spawn multiple agents
+      for (let i = 1; i <= 3; i++) {
+        await network.spawnAgent({
+          id: `agent${i}`,
+          name: `Agent ${i}`,
+          type: 'claude-code'
+        });
+      }
+
+      expect(network.getActiveAgents()).toHaveLength(3);
+
+      await network.shutdown();
+      
+      expect(network.getActiveAgents()).toHaveLength(0);
+    });
+  });
+});

package/tests/swarm-runner.test.ts

@@ -0,0 +1,301 @@
+import { describe, test, expect, beforeEach, afterEach, afterAll, vi } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { SwarmRunner, SwarmOptions } from '../src/lib/swarm-runner';
+import { EventEmitter } from 'events';
+import * as child_process from 'child_process';
+import { glob } from 'glob';
+
+// Mock modules
+vi.mock('child_process');
+vi.mock('glob');
+vi.mock('ora', () => ({
+  default: () => ({
+    start: vi.fn().mockReturnThis(),
+    succeed: vi.fn().mockReturnThis(),
+    fail: vi.fn().mockReturnThis(),
+    stop: vi.fn().mockReturnThis()
+  })
+}));
+
+describe('SwarmRunner', () => {
+  let testDir: string;
+  let runner: SwarmRunner;
+
+  beforeEach(() => {
+    // Create test directory
+    testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarm-test-'));
+    
+    // Create test files
+    fs.writeFileSync(path.join(testDir, 'file1.js'), '// Test file 1');
+    fs.writeFileSync(path.join(testDir, 'file2.ts'), '// Test file 2');
+    fs.writeFileSync(path.join(testDir, 'file3.py'), '# Test file 3');
+
+    // Reset mocks
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    fs.rmSync(testDir, { recursive: true, force: true });
+    vi.clearAllMocks();
+    vi.restoreAllMocks();
+  });
+  
+  afterAll(() => {
+    // Force exit after all tests complete
+    setTimeout(() => process.exit(0), 100);
+  });
+
+  describe('initialization', () => {
+    test('should create swarm runner with options', () => {
+      const options: SwarmOptions = {
+        provider: 'claude',
+        count: 5,
+        prompt: 'Add copyright header',
+        cwd: testDir
+      };
+
+      runner = new SwarmRunner(options);
+      expect(runner).toBeDefined();
+    });
+
+    test('should limit agent count to 100', () => {
+      const options: SwarmOptions = {
+        provider: 'claude',
+        count: 150,
+        prompt: 'Test prompt',
+        cwd: testDir
+      };
+
+      runner = new SwarmRunner(options);
+      // We can't directly test private properties, but this ensures no crash
+      expect(runner).toBeDefined();
+    });
+  });
+
+  describe('file finding', () => {
+    test('should find editable files in directory', async () => {
+      // Mock glob to return our test files immediately
+      vi.mocked(glob).mockImplementation((pattern, options, callback) => {
+        if (typeof callback === 'function') {
+          // Call callback synchronously
+          callback(null, ['file1.js', 'file2.ts', 'file3.py']);
+        }
+        return undefined as any;
+      });
+
+      const options: SwarmOptions = {
+        provider: 'claude',
+        count: 3,
+        prompt: 'Test prompt',
+        cwd: testDir
+      };
+
+      runner = new SwarmRunner(options);
+      
+      // Mock auth to return true
+      vi.spyOn(runner, 'ensureProviderAuth').mockResolvedValue(true);
+      
+      // Mock spawn to return immediately closing processes
+      let spawnCount = 0;
+      vi.mocked(child_process.spawn).mockImplementation(() => {
+        spawnCount++;
+        const proc = new EventEmitter();
+        proc.stdout = new EventEmitter();
+        proc.stderr = new EventEmitter();
+        proc.kill = vi.fn();
+        
+        // Close immediately
+        process.nextTick(() => proc.emit('close', 0));
+        
+        return proc as any;
+      });
+
+      await runner.run();
+
+      // Should have spawned 3 processes (one for each file)
+      expect(spawnCount).toBe(3);
+    });
+  });
+
+  describe('provider authentication', () => {
+    test('should check Claude authentication', async () => {
+      const options: SwarmOptions = {
+        provider: 'claude',
+        count: 1,
+        prompt: 'Test',
+        cwd: testDir
+      };
+
+      runner = new SwarmRunner(options);
+
+      // Mock environment variable
+      process.env.ANTHROPIC_API_KEY = 'test-key';
+
+      // Mock successful auth check
+      vi.mocked(child_process.spawn).mockImplementationOnce(() => {
+        const authCheckProcess = new EventEmitter();
+        authCheckProcess.stderr = new EventEmitter();
+        authCheckProcess.kill = vi.fn();
+        
+        // Emit close immediately
+        process.nextTick(() => authCheckProcess.emit('close', 0));
+        
+        return authCheckProcess as any;
+      });
+
+      const result = await runner.ensureProviderAuth();
+      expect(result).toBe(true);
+    });
+
+    test('should return true for local provider', async () => {
+      const options: SwarmOptions = {
+        provider: 'local',
+        count: 1,
+        prompt: 'Test',
+        cwd: testDir
+      };
+
+      runner = new SwarmRunner(options);
+      const result = await runner.ensureProviderAuth();
+      expect(result).toBe(true);
+    });
+
+    test('should check API key for OpenAI', async () => {
+      const options: SwarmOptions = {
+        provider: 'openai',
+        count: 1,
+        prompt: 'Test',
+        cwd: testDir
+      };
+
+      runner = new SwarmRunner(options);
+
+      // Without API key
+      delete process.env.OPENAI_API_KEY;
+      expect(await runner.ensureProviderAuth()).toBe(false);
+
+      // With API key
+      process.env.OPENAI_API_KEY = 'test-key';
+      expect(await runner.ensureProviderAuth()).toBe(true);
+    });
+  });
+
+  describe('command building', () => {
+    test('should build correct command for Claude', () => {
+      const options: SwarmOptions = {
+        provider: 'claude',
+        count: 1,
+        prompt: 'Add header',
+        cwd: testDir
+      };
+
+      runner = new SwarmRunner(options);
+      const command = (runner as any).buildCommand('test.js');
+
+      expect(command.cmd).toBe('claude');
+      expect(command.args).toContain('-p');
+      expect(command.args.join(' ')).toContain('Add header');
+      expect(command.args).toContain('--max-turns');
+      expect(command.args).toContain('5');
+    });
+
+    test('should build correct command for local provider', () => {
+      const options: SwarmOptions = {
+        provider: 'local',
+        count: 1,
+        prompt: 'Format code',
+        cwd: testDir
+      };
+
+      runner = new SwarmRunner(options);
+      const command = (runner as any).buildCommand('test.js');
+
+      expect(command.cmd).toBe('dev');
+      expect(command.args).toContain('agent');
+      expect(command.args.join(' ')).toContain('Format code');
+    });
+  });
+
+  describe('parallel processing', () => {
+    test('should process multiple files in parallel', async () => {
+      vi.mocked(glob).mockImplementation((pattern, options, callback) => {
+        if (typeof callback === 'function') {
+          callback(null, ['file1.js', 'file2.js', 'file3.js']);
+        }
+        return undefined as any;
+      });
+
+      const options: SwarmOptions = {
+        provider: 'local',
+        count: 3,
+        prompt: 'Add copyright',
+        cwd: testDir
+      };
+
+      runner = new SwarmRunner(options);
+      
+      // Mock auth
+      vi.spyOn(runner, 'ensureProviderAuth').mockResolvedValue(true);
+
+      let processCount = 0;
+      vi.mocked(child_process.spawn).mockImplementation(() => {
+        processCount++;
+        const proc = new EventEmitter();
+        proc.stdout = new EventEmitter();
+        proc.stderr = new EventEmitter();
+        proc.kill = vi.fn();
+        
+        // Simulate successful completion
+        process.nextTick(() => proc.emit('close', 0));
+
+        return proc as any;
+      });
+
+      await runner.run();
+
+      // Should have spawned 3 processes
+      expect(processCount).toBe(3);
+    });
+
+    test('should handle process failures', async () => {
+      vi.mocked(glob).mockImplementation((pattern, options, callback) => {
+        if (typeof callback === 'function') {
+          callback(null, ['file1.js']);
+        }
+        return undefined as any;
+      });
+
+      const options: SwarmOptions = {
+        provider: 'local',
+        count: 1,
+        prompt: 'Test',
+        cwd: testDir
+      };
+
+      runner = new SwarmRunner(options);
+      
+      // Mock auth
+      vi.spyOn(runner, 'ensureProviderAuth').mockResolvedValue(true);
+
+      vi.mocked(child_process.spawn).mockImplementation(() => {
+        const proc = new EventEmitter();
+        proc.stdout = new EventEmitter();
+        proc.stderr = new EventEmitter();
+        proc.kill = vi.fn();
+        
+        // Simulate failure
+        process.nextTick(() => {
+          proc.stderr!.emit('data', 'Error occurred');
+          proc.emit('close', 1);
+        });
+
+        return proc as any;
+      });
+
+      // Should complete without throwing
+      await expect(runner.run()).resolves.not.toThrow();
+    });
+  });
+});