@hanzo/dev 1.2.0 → 2.0.0

package/tests/mcp-client.test.ts

@@ -0,0 +1,238 @@
+import { describe, test, expect, beforeEach, afterEach, jest } from '@jest/globals';
+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');
+
+describe('MCPClient', () => {
+  let client: MCPClient;
+  let mockProcess: any;
+
+  beforeEach(() => {
+    client = new MCPClient();
+    
+    // Mock spawn to return a fake process
+    mockProcess = new EventEmitter();
+    mockProcess.stdin = { write: jest.fn() };
+    mockProcess.stdout = new EventEmitter();
+    mockProcess.stderr = new EventEmitter();
+    mockProcess.kill = jest.fn();
+
+    (child_process.spawn as jest.Mock).mockReturnValue(mockProcess);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('stdio transport', () => {
+    test('should connect to MCP server via stdio', async () => {
+      const config: MCPServerConfig = {
+        name: 'test-server',
+        transport: 'stdio',
+        command: 'test-mcp-server',
+        args: ['--test']
+      };
+
+      // Start connection in background
+      const connectPromise = client.connect(config);
+
+      // Simulate server sending initialization response
+      setTimeout(() => {
+        mockProcess.stdout.emit('data', JSON.stringify({
+          jsonrpc: '2.0',
+          id: 1,
+          result: {
+            protocolVersion: '1.0',
+            serverInfo: { name: 'test-server', version: '1.0.0' }
+          }
+        }) + '\n');
+
+        // Simulate tools list response
+        mockProcess.stdout.emit('data', JSON.stringify({
+          jsonrpc: '2.0',
+          id: 2,
+          result: {
+            tools: [
+              {
+                name: 'test_tool',
+                description: 'A test tool',
+                parameters: {
+                  type: 'object',
+                  properties: {
+                    input: { type: 'string' }
+                  }
+                }
+              }
+            ]
+          }
+        }) + '\n');
+      }, 10);
+
+      const session = await connectPromise;
+      expect(session).toBeDefined();
+      expect(session.tools).toHaveLength(1);
+      expect(session.tools[0].name).toBe('test_tool');
+    });
+
+    test('should handle server errors', async () => {
+      const config: MCPServerConfig = {
+        name: 'error-server',
+        transport: 'stdio',
+        command: 'failing-server'
+      };
+
+      const connectPromise = client.connect(config);
+
+      // Simulate process error
+      setTimeout(() => {
+        mockProcess.emit('error', new Error('Failed to start'));
+      }, 10);
+
+      await expect(connectPromise).rejects.toThrow('Failed to start');
+    });
+  });
+
+  describe('tool calling', () => {
+    test('should call tool on MCP server', async () => {
+      const session: MCPSession = {
+        serverName: 'test-server',
+        tools: [{
+          name: 'echo',
+          description: 'Echo input',
+          parameters: {
+            type: 'object',
+            properties: {
+              message: { type: 'string' }
+            }
+          }
+        }],
+        prompts: [],
+        resources: []
+      };
+
+      // Mock session in client
+      (client as any).sessions.set('test-server', session);
+      (client as any).processes.set('test-server', mockProcess);
+
+      // Start tool call
+      const callPromise = client.callTool('test-server', 'echo', { message: 'Hello' });
+
+      // Simulate server response
+      setTimeout(() => {
+        // Find the request that was sent
+        const writeCall = mockProcess.stdin.write.mock.calls[0];
+        const request = JSON.parse(writeCall[0]);
+        
+        // Send response with same ID
+        mockProcess.stdout.emit('data', JSON.stringify({
+          jsonrpc: '2.0',
+          id: request.id,
+          result: {
+            output: 'Echo: Hello'
+          }
+        }) + '\n');
+      }, 10);
+
+      const result = await callPromise;
+      expect(result.output).toBe('Echo: Hello');
+    });
+  });
+
+  describe('session management', () => {
+    test('should list connected sessions', async () => {
+      // Mock two sessions
+      (client as any).sessions.set('server1', {
+        serverName: 'server1',
+        tools: [],
+        prompts: [],
+        resources: []
+      });
+      (client as any).sessions.set('server2', {
+        serverName: 'server2',
+        tools: [],
+        prompts: [],
+        resources: []
+      });
+
+      const sessions = client.listSessions();
+      expect(sessions).toHaveLength(2);
+      expect(sessions.map(s => s.serverName)).toContain('server1');
+      expect(sessions.map(s => s.serverName)).toContain('server2');
+    });
+
+    test('should disconnect from server', async () => {
+      const serverName = 'test-server';
+      
+      // Mock session and process
+      (client as any).sessions.set(serverName, {
+        serverName,
+        tools: [],
+        prompts: [],
+        resources: []
+      });
+      (client as any).processes.set(serverName, mockProcess);
+
+      await client.disconnect(serverName);
+
+      expect(mockProcess.kill).toHaveBeenCalled();
+      expect(client.listSessions()).toHaveLength(0);
+    });
+  });
+
+  describe('error handling', () => {
+    test('should handle JSON-RPC errors', async () => {
+      const session: MCPSession = {
+        serverName: 'test-server',
+        tools: [{
+          name: 'failing_tool',
+          description: 'A tool that fails',
+          parameters: { type: 'object' }
+        }],
+        prompts: [],
+        resources: []
+      };
+
+      (client as any).sessions.set('test-server', session);
+      (client as any).processes.set('test-server', mockProcess);
+
+      const callPromise = client.callTool('test-server', 'failing_tool', {});
+
+      setTimeout(() => {
+        const writeCall = mockProcess.stdin.write.mock.calls[0];
+        const request = JSON.parse(writeCall[0]);
+        
+        // Send error response
+        mockProcess.stdout.emit('data', JSON.stringify({
+          jsonrpc: '2.0',
+          id: request.id,
+          error: {
+            code: -32601,
+            message: 'Method not found'
+          }
+        }) + '\n');
+      }, 10);
+
+      await expect(callPromise).rejects.toThrow('Method not found');
+    });
+
+    test('should handle malformed responses', async () => {
+      const config: MCPServerConfig = {
+        name: 'malformed-server',
+        transport: 'stdio',
+        command: 'test-server'
+      };
+
+      const connectPromise = client.connect(config);
+
+      setTimeout(() => {
+        // Send malformed JSON
+        mockProcess.stdout.emit('data', 'not valid json\n');
+      }, 10);
+
+      await expect(connectPromise).rejects.toThrow();
+    });
+  });
+});

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/setup.ts

@@ -0,0 +1,25 @@
+import { jest } from '@jest/globals';
+
+// Set up test environment
+process.env.NODE_ENV = 'test';
+
+// Mock console methods to reduce noise in tests
+global.console = {
+  ...console,
+  log: jest.fn(),
+  debug: jest.fn(),
+  info: jest.fn(),
+  warn: jest.fn(),
+  error: jest.fn(),
+};
+
+// Mock fetch globally
+global.fetch = jest.fn();
+
+// Set test timeout
+jest.setTimeout(30000);
+
+// Clean up after each test
+afterEach(() => {
+  jest.clearAllMocks();
+});