@johpaz/hive-core 1.0.7 → 1.0.10

package/src/agents/team-coordinator.test.ts

@@ -0,0 +1,401 @@
+import { describe, it, expect, beforeEach, vi } from "bun:test";
+import { TeamCoordinator, type TeamConfig, type CoordinationMode } from "./team-coordinator";
+import { AgentRegistry, type AgentDefinition, type Task } from "./registry";
+import { InterAgentBus } from "./inter-agent-bus";
+import { eventBus } from "../events/event-bus";
+
+describe("TeamCoordinator", () => {
+  let registry: AgentRegistry;
+  let bus: InterAgentBus;
+  let coordinator: TeamCoordinator;
+
+  const createAgent = (id: string, capabilities: string[]): AgentDefinition => ({
+    id,
+    name: `Agent ${id}`,
+    description: `Test agent ${id}`,
+    capabilities,
+    modelConfig: { provider: "openai", model: "gpt-4" },
+    systemPrompt: "You are helpful",
+    maxConcurrentTasks: 3,
+    currentLoad: 0,
+  });
+
+  const createTask = (id: string, capabilities: string[]): Task => ({
+    id,
+    description: `Task ${id}`,
+    requiredCapabilities: capabilities,
+    priority: "normal",
+  });
+
+  const createTeamConfig = (
+    name: string,
+    leadId: string,
+    memberIds: string[],
+    mode: CoordinationMode = "normal"
+  ): TeamConfig => ({
+    name,
+    leadId,
+    memberIds,
+    coordinationMode: mode,
+    sharedContext: false,
+  });
+
+  beforeEach(() => {
+    registry = new AgentRegistry();
+    bus = new InterAgentBus();
+    coordinator = new TeamCoordinator(registry, bus);
+    eventBus.removeAllListeners();
+  });
+
+  describe("createTeam", () => {
+    it("should create a team", () => {
+      registry.register(createAgent("lead-1", ["code"]));
+      
+      coordinator.createTeam(createTeamConfig("team-1", "lead-1", ["agent-2", "agent-3"]));
+
+      const team = coordinator.getTeam("team-1");
+      expect(team).toBeDefined();
+      expect(team?.leadId).toBe("lead-1");
+      expect(team?.memberIds).toEqual(["agent-2", "agent-3"]);
+    });
+
+    it("should update existing team", () => {
+      registry.register(createAgent("lead-1", ["code"]));
+      
+      coordinator.createTeam(createTeamConfig("team-1", "lead-1", ["agent-2"]));
+      coordinator.createTeam(createTeamConfig("team-1", "lead-1", ["agent-3", "agent-4"]));
+
+      const team = coordinator.getTeam("team-1");
+      expect(team?.memberIds).toEqual(["agent-3", "agent-4"]);
+    });
+
+    it("should initialize team state", () => {
+      registry.register(createAgent("lead-1", ["code"]));
+      
+      coordinator.createTeam(createTeamConfig("team-1", "lead-1", []));
+
+      const state = coordinator.getTeamState("team-1");
+      expect(state?.status).toBe("idle");
+      expect(state?.activeMembers).toEqual([]);
+    });
+  });
+
+  describe("removeTeam", () => {
+    it("should remove idle team", () => {
+      registry.register(createAgent("lead-1", ["code"]));
+      
+      coordinator.createTeam(createTeamConfig("team-1", "lead-1", []));
+      coordinator.removeTeam("team-1");
+
+      expect(coordinator.getTeam("team-1")).toBeUndefined();
+    });
+
+    it("should not remove working team", async () => {
+      registry.register(createAgent("lead-1", ["code"]));
+      
+      coordinator.createTeam(createTeamConfig("team-1", "lead-1", []));
+
+      const executor = vi.fn().mockImplementation(async () => {
+        coordinator.removeTeam("team-1");
+        return {};
+      });
+
+      const task = createTask("task-1", ["code"]);
+      
+      const removePromise = new Promise<void>((resolve) => {
+        setTimeout(() => {
+          coordinator.removeTeam("team-1");
+          resolve();
+        }, 10);
+      });
+
+      await coordinator.coordinateTask("team-1", task, async () => {
+        await removePromise;
+        return {};
+      });
+
+      expect(coordinator.getTeam("team-1")).toBeDefined();
+    });
+  });
+
+  describe("coordinateTask", () => {
+    it("should throw for non-existent team", async () => {
+      const task = createTask("task-1", ["code"]);
+      
+      await expect(coordinator.coordinateTask("unknown", task, vi.fn()))
+        .rejects.toThrow("Team not found");
+    });
+
+    it("should update team state during execution", async () => {
+      registry.register(createAgent("lead-1", ["code"]));
+      
+      coordinator.createTeam(createTeamConfig("team-1", "lead-1", []));
+
+      const task = createTask("task-1", ["code"]);
+      
+      await coordinator.coordinateTask("team-1", task, async () => ({}));
+
+      const state = coordinator.getTeamState("team-1");
+      expect(state?.status).toBe("idle");
+      expect(state?.currentTaskId).toBeUndefined();
+    });
+  });
+
+  describe("coordination modes", () => {
+    describe("normal mode", () => {
+      it("should execute task with lead agent", async () => {
+        registry.register(createAgent("lead-1", ["code"]));
+        
+        coordinator.createTeam(createTeamConfig("team-1", "lead-1", [], "normal"));
+
+        const executor = vi.fn().mockResolvedValue({ result: "done" });
+        const task = createTask("task-1", ["code"]);
+
+        const result = await coordinator.coordinateTask("team-1", task, executor);
+
+        expect(result.status).toBe("success");
+        expect(result.agentId).toBe("lead-1");
+        expect(executor).toHaveBeenCalled();
+      });
+
+      it("should throw if lead agent not found", async () => {
+        coordinator.createTeam(createTeamConfig("team-1", "missing-lead", [], "normal"));
+
+        const task = createTask("task-1", ["code"]);
+
+        const result = await coordinator.coordinateTask("team-1", task, vi.fn());
+        expect(result.status).toBe("failed");
+      });
+    });
+
+    describe("delegate mode", () => {
+      it("should create and execute plan", async () => {
+        registry.register(createAgent("lead-1", ["code", "test"]));
+        
+        coordinator.createTeam(createTeamConfig("team-1", "lead-1", [], "delegate"));
+
+        const executor = vi.fn().mockResolvedValue({ done: true });
+        const task = createTask("task-1", ["code", "test"]);
+
+        const result = await coordinator.coordinateTask("team-1", task, executor);
+
+        expect(result.status).toBe("success");
+        expect(executor).toHaveBeenCalledTimes(2);
+      });
+
+      it("should track step progress", async () => {
+        registry.register(createAgent("lead-1", ["code", "test"]));
+        
+        coordinator.createTeam(createTeamConfig("team-1", "lead-1", [], "delegate"));
+
+        const executor = vi.fn().mockResolvedValue({});
+        const task = createTask("task-1", ["code", "test"]);
+
+        await coordinator.coordinateTask("team-1", task, executor);
+
+        const state = coordinator.getTeamState("team-1");
+        expect(state?.completedSteps).toBe(2);
+        expect(state?.totalSteps).toBe(2);
+      });
+    });
+
+    describe("collaborative mode", () => {
+      it("should execute with all members", async () => {
+        registry.register(createAgent("lead-1", ["code"]));
+        registry.register(createAgent("member-1", ["code"]));
+        registry.register(createAgent("member-2", ["code"]));
+        
+        coordinator.createTeam(createTeamConfig("team-1", "lead-1", ["member-1", "member-2"], "collaborative"));
+
+        const executor = vi.fn().mockResolvedValue({ contribution: "done" });
+        const task = createTask("task-1", ["code"]);
+
+        const result = await coordinator.coordinateTask("team-1", task, executor);
+
+        expect(result.status).toBe("success");
+        expect(executor).toHaveBeenCalledTimes(3);
+        expect(result.output).toHaveProperty("collaborative", true);
+        expect(result.output).toHaveProperty("contributions");
+      });
+
+      it("should support shared context", async () => {
+        registry.register(createAgent("lead-1", ["code"]));
+        registry.register(createAgent("member-1", ["code"]));
+        
+        coordinator.createTeam({
+          name: "team-1",
+          leadId: "lead-1",
+          memberIds: ["member-1"],
+          coordinationMode: "collaborative",
+          sharedContext: true,
+        });
+
+        const task = createTask("task-1", ["code"]);
+
+        await coordinator.coordinateTask("team-1", task, async () => ({ value: 42 }));
+
+        const state = coordinator.getTeamState("team-1");
+        expect(state?.sharedState).toHaveProperty("lead-1");
+        expect(state?.sharedState).toHaveProperty("member-1");
+      });
+
+      it("should respect max parallel tasks", async () => {
+        registry.register(createAgent("lead-1", ["code"]));
+        registry.register(createAgent("member-1", ["code"]));
+        registry.register(createAgent("member-2", ["code"]));
+        
+        coordinator.createTeam({
+          name: "team-1",
+          leadId: "lead-1",
+          memberIds: ["member-1", "member-2"],
+          coordinationMode: "collaborative",
+          sharedContext: false,
+          maxParallelTasks: 1,
+        });
+
+        const executionOrder: string[] = [];
+        const executor = vi.fn().mockImplementation(async (agent) => {
+          executionOrder.push(agent.id);
+          return {};
+        });
+
+        const task = createTask("task-1", ["code"]);
+        await coordinator.coordinateTask("team-1", task, executor);
+
+        expect(executionOrder.length).toBe(3);
+      });
+    });
+
+    describe("hierarchical mode", () => {
+      it("should decompose and synthesize", async () => {
+        registry.register(createAgent("lead-1", ["code"]));
+        registry.register(createAgent("worker-1", ["test"]));
+        registry.register(createAgent("worker-2", ["deploy"]));
+        
+        coordinator.createTeam(createTeamConfig("team-1", "lead-1", ["worker-1", "worker-2"], "hierarchical"));
+
+        const executor = vi.fn().mockResolvedValue({ done: true });
+        const task = createTask("task-1", ["code", "test", "deploy"]);
+
+        const result = await coordinator.coordinateTask("team-1", task, executor);
+
+        expect(result.status).toBe("success");
+        expect(result.output).toHaveProperty("synthesized");
+        expect(result.subtasks).toBeDefined();
+      });
+
+      it("should route subtasks to best agents", async () => {
+        registry.register(createAgent("lead-1", ["code"]));
+        registry.register(createAgent("worker-1", ["test"]));
+        
+        coordinator.createTeam(createTeamConfig("team-1", "lead-1", ["worker-1"], "hierarchical"));
+
+        const task = createTask("task-1", ["test"]);
+
+        await coordinator.coordinateTask("team-1", task, async (agent) => ({ agentId: agent.id }));
+
+        expect(registry.get("worker-1")?.currentLoad).toBe(0);
+      });
+    });
+  });
+
+  describe("load management", () => {
+    it("should manage agent load during execution", async () => {
+      registry.register(createAgent("lead-1", ["code"]));
+      
+      coordinator.createTeam(createTeamConfig("team-1", "lead-1", []));
+
+      let loadDuringExecution = -1;
+      
+      await coordinator.coordinateTask("team-1", createTask("task-1", ["code"]), async (agent) => {
+        loadDuringExecution = registry.get(agent.id)?.currentLoad ?? -1;
+        return {};
+      });
+
+      expect(loadDuringExecution).toBe(1);
+      expect(registry.get("lead-1")?.currentLoad).toBe(0);
+    });
+
+    it("should decrement load after error", async () => {
+      registry.register(createAgent("lead-1", ["code"]));
+      
+      coordinator.createTeam(createTeamConfig("team-1", "lead-1", []));
+
+      await coordinator.coordinateTask("team-1", createTask("task-1", ["code"]), async () => {
+        throw new Error("Failed");
+      });
+
+      expect(registry.get("lead-1")?.currentLoad).toBe(0);
+    });
+  });
+
+  describe("getStats", () => {
+    it("should return correct stats", async () => {
+      registry.register(createAgent("lead-1", ["code"]));
+      registry.register(createAgent("lead-2", ["test"]));
+      
+      coordinator.createTeam(createTeamConfig("team-1", "lead-1", [], "normal"));
+      coordinator.createTeam(createTeamConfig("team-2", "lead-2", [], "collaborative"));
+
+      await coordinator.coordinateTask("team-1", createTask("task-1", ["code"]), vi.fn());
+
+      const stats = coordinator.getStats();
+
+      expect(stats.totalTeams).toBe(2);
+      expect(stats.byMode.normal).toBe(1);
+      expect(stats.byMode.collaborative).toBe(1);
+      expect(stats.tasksCompleted).toBe(1);
+    });
+
+    it("should track active teams", async () => {
+      registry.register(createAgent("lead-1", ["code"]));
+      
+      coordinator.createTeam(createTeamConfig("team-1", "lead-1", []));
+
+      let statsPromise: Promise<void>;
+      
+      const coordPromise = coordinator.coordinateTask("team-1", createTask("task-1", ["code"]), async () => {
+        await new Promise(r => setTimeout(r, 50));
+        return {};
+      });
+
+      await new Promise(r => setTimeout(r, 10));
+      const stats = coordinator.getStats();
+
+      await coordPromise;
+
+      expect(stats.activeTeams).toBeGreaterThanOrEqual(0);
+    });
+  });
+
+  describe("listTeams", () => {
+    it("should list all teams", () => {
+      registry.register(createAgent("lead-1", ["code"]));
+      registry.register(createAgent("lead-2", ["test"]));
+      
+      coordinator.createTeam(createTeamConfig("team-1", "lead-1", []));
+      coordinator.createTeam(createTeamConfig("team-2", "lead-2", []));
+
+      const teams = coordinator.listTeams();
+
+      expect(teams.length).toBe(2);
+      expect(teams.map(t => t.name)).toContain("team-1");
+      expect(teams.map(t => t.name)).toContain("team-2");
+    });
+  });
+
+  describe("clear", () => {
+    it("should clear all teams", async () => {
+      registry.register(createAgent("lead-1", ["code"]));
+      
+      coordinator.createTeam(createTeamConfig("team-1", "lead-1", []));
+
+      await coordinator.coordinateTask("team-1", createTask("task-1", ["code"]), vi.fn());
+
+      coordinator.clear();
+
+      expect(coordinator.listTeams().length).toBe(0);
+      expect(coordinator.getStats().tasksCompleted).toBe(0);
+    });
+  });
+});