@hanzo/dev 2.1.1 → 3.0.2

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

@@ -1,340 +0,0 @@
-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

@@ -1,301 +0,0 @@
-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();
-    });
-  });
-});