@johpaz/hive-core 1.0.7 → 1.0.10

package/src/agents/team-coordinator.ts

@@ -0,0 +1,480 @@
+import { logger } from "../utils/logger.ts";
+import { eventBus } from "../events/event-bus.ts";
+import type { AgentRegistry, AgentDefinition, Task, TaskResult } from "./registry.ts";
+import type { InterAgentBus } from "./inter-agent-bus.ts";
+
+export type CoordinationMode = "normal" | "delegate" | "collaborative" | "hierarchical";
+
+export interface TeamConfig {
+  name: string;
+  leadId: string;
+  memberIds: string[];
+  coordinationMode: CoordinationMode;
+  sharedContext: boolean;
+  maxParallelTasks?: number;
+  timeout?: number;
+}
+
+export interface TeamState {
+  name: string;
+  status: "idle" | "working" | "waiting" | "error";
+  currentTaskId?: string;
+  activeMembers: string[];
+  completedSteps: number;
+  totalSteps: number;
+  startTime?: number;
+  sharedState: Record<string, unknown>;
+}
+
+export interface Plan {
+  id: string;
+  taskId: string;
+  steps: PlanStep[];
+  createdAt: number;
+  approved: boolean;
+}
+
+export interface PlanStep {
+  id: string;
+  assignedTo: string;
+  capability: string;
+  description: string;
+  dependencies: string[];
+  status: "pending" | "running" | "completed" | "failed";
+  result?: unknown;
+}
+
+export interface TeamStats {
+  totalTeams: number;
+  activeTeams: number;
+  byMode: Record<CoordinationMode, number>;
+  tasksCompleted: number;
+  averageDuration: number;
+}
+
+export class TeamCoordinator {
+  private teams: Map<string, TeamConfig> = new Map();
+  private teamStates: Map<string, TeamState> = new Map();
+  private plans: Map<string, Plan> = new Map();
+  private tasksCompleted = 0;
+  private totalDuration = 0;
+  private log = logger.child("team-coordinator");
+
+  constructor(
+    private registry: AgentRegistry,
+    private bus: InterAgentBus
+  ) {}
+
+  createTeam(config: TeamConfig): void {
+    if (this.teams.has(config.name)) {
+      this.log.warn(`Team ${config.name} already exists, updating`);
+    }
+
+    this.teams.set(config.name, config);
+    this.teamStates.set(config.name, {
+      name: config.name,
+      status: "idle",
+      activeMembers: [],
+      completedSteps: 0,
+      totalSteps: 0,
+      sharedState: {},
+    });
+
+    this.log.info(`Team created: ${config.name}`, {
+      lead: config.leadId,
+      members: config.memberIds,
+      mode: config.coordinationMode,
+    });
+  }
+
+  removeTeam(name: string): void {
+    const state = this.teamStates.get(name);
+    if (state?.status === "working") {
+      this.log.warn(`Cannot remove team ${name} while working`);
+      return;
+    }
+
+    this.teams.delete(name);
+    this.teamStates.delete(name);
+    this.log.info(`Team removed: ${name}`);
+  }
+
+  getTeam(name: string): TeamConfig | undefined {
+    return this.teams.get(name);
+  }
+
+  getTeamState(name: string): TeamState | undefined {
+    return this.teamStates.get(name);
+  }
+
+  async coordinateTask(
+    teamName: string,
+    task: Task,
+    executor: (agent: AgentDefinition, task: Task) => Promise<unknown>
+  ): Promise<TaskResult> {
+    const team = this.teams.get(teamName);
+    if (!team) {
+      throw new Error(`Team not found: ${teamName}`);
+    }
+
+    const state = this.teamStates.get(teamName)!;
+    state.status = "working";
+    state.currentTaskId = task.id;
+    state.startTime = Date.now();
+
+    const startTime = Date.now();
+
+    this.log.info(`Coordinating task ${task.id} with team ${teamName}`, {
+      mode: team.coordinationMode,
+    });
+
+    try {
+      let result: TaskResult;
+
+      switch (team.coordinationMode) {
+        case "delegate":
+          result = await this.delegateExecute(team, task, executor);
+          break;
+        case "collaborative":
+          result = await this.collaborativeExecute(team, task, executor);
+          break;
+        case "hierarchical":
+          result = await this.hierarchicalExecute(team, task, executor);
+          break;
+        default:
+          result = await this.normalExecute(team, task, executor);
+      }
+
+      const duration = Date.now() - startTime;
+      this.tasksCompleted++;
+      this.totalDuration += duration;
+
+      state.status = "idle";
+      state.currentTaskId = undefined;
+      state.completedSteps = state.totalSteps;
+
+      return {
+        ...result,
+        duration,
+      };
+    } catch (error) {
+      state.status = "error";
+      this.log.error(`Team ${teamName} failed on task ${task.id}`, {
+        error: (error as Error).message,
+      });
+
+      return {
+        taskId: task.id,
+        agentId: team.leadId,
+        status: "failed",
+        output: { error: (error as Error).message },
+        duration: Date.now() - startTime,
+      };
+    }
+  }
+
+  private async normalExecute(
+    team: TeamConfig,
+    task: Task,
+    executor: (agent: AgentDefinition, task: Task) => Promise<unknown>
+  ): Promise<TaskResult> {
+    const lead = this.registry.get(team.leadId);
+    if (!lead) throw new Error(`Lead agent not found: ${team.leadId}`);
+
+    this.registry.incrementLoad(lead.id);
+
+    try {
+      const output = await executor(lead, task);
+
+      return {
+        taskId: task.id,
+        agentId: lead.id,
+        status: "success",
+        output,
+        duration: 0,
+      };
+    } finally {
+      this.registry.decrementLoad(lead.id);
+    }
+  }
+
+  private async delegateExecute(
+    team: TeamConfig,
+    task: Task,
+    executor: (agent: AgentDefinition, task: Task) => Promise<unknown>
+  ): Promise<TaskResult> {
+    const lead = this.registry.get(team.leadId);
+    if (!lead) throw new Error(`Lead agent not found: ${team.leadId}`);
+
+    const plan = await this.createPlan(lead, task);
+    const approved = await this.approvePlan(team.name, plan);
+
+    if (!approved) {
+      throw new Error("Plan not approved");
+    }
+
+    return this.executePlan(team, plan, executor);
+  }
+
+  private async collaborativeExecute(
+    team: TeamConfig,
+    task: Task,
+    executor: (agent: AgentDefinition, task: Task) => Promise<unknown>
+  ): Promise<TaskResult> {
+    const members = [team.leadId, ...team.memberIds]
+      .map((id) => this.registry.get(id))
+      .filter((a): a is AgentDefinition => !!a);
+
+    const results: { agentId: string; result: unknown }[] = [];
+
+    for (const member of members) {
+      this.registry.incrementLoad(member.id);
+    }
+
+    try {
+      const maxParallel = team.maxParallelTasks ?? members.length;
+      
+      for (let i = 0; i < members.length; i += maxParallel) {
+        const batch = members.slice(i, i + maxParallel);
+        
+        const batchResults = await Promise.all(
+          batch.map(async (member) => {
+            const result = await executor(member, task);
+            return { agentId: member.id, result };
+          })
+        );
+
+        results.push(...batchResults);
+
+        if (team.sharedContext) {
+          this.updateSharedState(team.name, batchResults);
+        }
+      }
+
+      return {
+        taskId: task.id,
+        agentId: team.leadId,
+        status: "success",
+        output: {
+          collaborative: true,
+          contributions: results,
+        },
+        duration: 0,
+      };
+    } finally {
+      for (const member of members) {
+        this.registry.decrementLoad(member.id);
+      }
+    }
+  }
+
+  private async hierarchicalExecute(
+    team: TeamConfig,
+    task: Task,
+    executor: (agent: AgentDefinition, task: Task) => Promise<unknown>
+  ): Promise<TaskResult> {
+    const lead = this.registry.get(team.leadId);
+    if (!lead) throw new Error(`Lead agent not found: ${team.leadId}`);
+
+    const decomposition = await this.hierarchicalDecompose(lead, task);
+
+    const results: TaskResult[] = [];
+
+    for (const subtask of decomposition.subtasks) {
+      const agent = this.registry.findBestAgentForTask(subtask);
+      if (!agent) continue;
+
+      this.registry.incrementLoad(agent.id);
+      try {
+        const output = await executor(agent, subtask);
+        results.push({
+          taskId: subtask.id,
+          agentId: agent.id,
+          status: "success",
+          output,
+          duration: 0,
+        });
+      } finally {
+        this.registry.decrementLoad(agent.id);
+      }
+    }
+
+    const synthesized = await this.synthesize(lead, results, executor);
+
+    return {
+      taskId: task.id,
+      agentId: lead.id,
+      status: results.every((r) => r.status === "success") ? "success" : "partial",
+      output: synthesized,
+      duration: 0,
+      subtasks: results,
+    };
+  }
+
+  private async createPlan(lead: AgentDefinition, task: Task): Promise<Plan> {
+    const steps: PlanStep[] = task.requiredCapabilities.map((cap, i) => ({
+      id: `${task.id}-step-${i}`,
+      assignedTo: lead.id,
+      capability: cap,
+      description: `Execute ${cap} for task ${task.id}`,
+      dependencies: i > 0 ? [`${task.id}-step-${i - 1}`] : [],
+      status: "pending" as const,
+    }));
+
+    const plan: Plan = {
+      id: crypto.randomUUID(),
+      taskId: task.id,
+      steps,
+      createdAt: Date.now(),
+      approved: false,
+    };
+
+    this.plans.set(plan.id, plan);
+    return plan;
+  }
+
+  private async approvePlan(teamName: string, plan: Plan): Promise<boolean> {
+    plan.approved = true;
+    this.log.info(`Plan ${plan.id} approved for team ${teamName}`);
+    return true;
+  }
+
+  private async executePlan(
+    team: TeamConfig,
+    plan: Plan,
+    executor: (agent: AgentDefinition, task: Task) => Promise<unknown>
+  ): Promise<TaskResult> {
+    const state = this.teamStates.get(team.name)!;
+    state.totalSteps = plan.steps.length;
+    state.completedSteps = 0;
+
+    const results: { stepId: string; result: unknown }[] = [];
+
+    for (const step of plan.steps) {
+      const agent = this.registry.get(step.assignedTo);
+      if (!agent) continue;
+
+      step.status = "running";
+
+      try {
+        const result = await executor(agent, {
+          id: step.id,
+          description: step.description,
+          requiredCapabilities: [step.capability],
+          priority: "normal",
+        });
+
+        step.status = "completed";
+        step.result = result;
+        results.push({ stepId: step.id, result });
+        state.completedSteps++;
+
+        if (team.sharedContext) {
+          this.updateSharedState(team.name, [{ agentId: agent.id, result }]);
+        }
+      } catch (error) {
+        step.status = "failed";
+        this.log.error(`Step ${step.id} failed`, { error: (error as Error).message });
+      }
+    }
+
+    return {
+      taskId: plan.taskId,
+      agentId: team.leadId,
+      status: plan.steps.every((s) => s.status === "completed") ? "success" : "partial",
+      output: { plan: plan.id, results },
+      duration: 0,
+    };
+  }
+
+  private async hierarchicalDecompose(
+    lead: AgentDefinition,
+    task: Task
+  ): Promise<{ subtasks: Task[] }> {
+    const subtasks: Task[] = [];
+
+    for (let i = 0; i < task.requiredCapabilities.length; i++) {
+      const capability = task.requiredCapabilities[i]!;
+      subtasks.push({
+        id: `${task.id}-h${i}`,
+        description: `Hierarchical subtask for ${capability}`,
+        requiredCapabilities: [capability],
+        priority: task.priority,
+        parentTaskId: task.id,
+      });
+    }
+
+    return { subtasks };
+  }
+
+  private async synthesize(
+    lead: AgentDefinition,
+    results: TaskResult[],
+    executor: (agent: AgentDefinition, task: Task) => Promise<unknown>
+  ): Promise<unknown> {
+    if (results.length === 0) return null;
+    if (results.length === 1) return results[0]!.output;
+
+    return {
+      synthesized: true,
+      byAgent: results.map((r) => ({ agentId: r.agentId, output: r.output })),
+    };
+  }
+
+  private updateSharedState(
+    teamName: string,
+    results: { agentId: string; result: unknown }[]
+  ): void {
+    const state = this.teamStates.get(teamName);
+    if (!state) return;
+
+    for (const { agentId, result } of results) {
+      state.sharedState[agentId] = result;
+    }
+  }
+
+  getStats(): TeamStats {
+    const byMode: Record<CoordinationMode, number> = {
+      normal: 0,
+      delegate: 0,
+      collaborative: 0,
+      hierarchical: 0,
+    };
+
+    let activeTeams = 0;
+
+    for (const [name, config] of this.teams) {
+      byMode[config.coordinationMode]++;
+      const state = this.teamStates.get(name);
+      if (state?.status === "working") activeTeams++;
+    }
+
+    return {
+      totalTeams: this.teams.size,
+      activeTeams,
+      byMode,
+      tasksCompleted: this.tasksCompleted,
+      averageDuration: this.tasksCompleted > 0 
+        ? this.totalDuration / this.tasksCompleted 
+        : 0,
+    };
+  }
+
+  listTeams(): TeamConfig[] {
+    return Array.from(this.teams.values());
+  }
+
+  clear(): void {
+    this.teams.clear();
+    this.teamStates.clear();
+    this.plans.clear();
+    this.tasksCompleted = 0;
+    this.totalDuration = 0;
+    this.log.info("All teams cleared");
+  }
+}
+
+export const teamCoordinator = (
+  registry: AgentRegistry,
+  bus: InterAgentBus
+) => new TeamCoordinator(registry, bus);

package/src/canvas/canvas-manager.test.ts

@@ -0,0 +1,159 @@
+import { describe, it, expect, beforeEach, vi } from "bun:test";
+import { CanvasManager, WebSocketState, type WebSocketLike } from "./canvas-manager.ts";
+
+describe("CanvasManager", () => {
+  let manager: CanvasManager;
+
+  const createMockWebSocket = (): WebSocketLike & { messages: string[] } => {
+    const messages: string[] = [];
+    const handlers: Map<string, (data: unknown) => void> = new Map();
+
+    return {
+      readyState: WebSocketState.OPEN,
+      send: (data: string) => {
+        messages.push(data);
+      },
+      on: (event: string, callback: (data: unknown) => void) => {
+        handlers.set(event, callback);
+      },
+      messages,
+    } as WebSocketLike & { messages: string[] };
+  };
+
+  beforeEach(() => {
+    manager = new CanvasManager();
+  });
+
+  describe("registerSession", () => {
+    it("should register a session", () => {
+      const ws = createMockWebSocket();
+      manager.registerSession("session-1", ws);
+
+      expect(manager.isSessionConnected("session-1")).toBe(true);
+    });
+
+    it("should track session stats", () => {
+      const ws = createMockWebSocket();
+      manager.registerSession("session-1", ws);
+
+      const stats = manager.getStats();
+      expect(stats.totalSessions).toBe(1);
+      expect(stats.activeSessions).toBe(1);
+    });
+  });
+
+  describe("render", () => {
+    it("should send render message to session", async () => {
+      const ws = createMockWebSocket();
+      manager.registerSession("session-1", ws);
+
+      const component = {
+        id: "btn-1",
+        type: "button" as const,
+        props: { label: "Click me" },
+      };
+
+      await manager.render("session-1", component);
+
+      expect(ws.messages.length).toBe(1);
+      const msg = JSON.parse(ws.messages[0]!);
+      expect(msg.type).toBe("canvas:render");
+      expect(msg.payload.component.id).toBe("btn-1");
+    });
+
+    it("should throw for disconnected session", async () => {
+      await expect(manager.render("unknown", { id: "x", type: "button", props: {} })).rejects.toThrow(
+        "Session not connected"
+      );
+    });
+  });
+
+  describe("update", () => {
+    it("should send update message to session", async () => {
+      const ws = createMockWebSocket();
+      manager.registerSession("session-1", ws);
+
+      const component = {
+        id: "btn-1",
+        type: "button" as const,
+        props: { label: "Updated" },
+      };
+
+      await manager.update("session-1", component);
+
+      expect(ws.messages.length).toBe(1);
+      const msg = JSON.parse(ws.messages[0]!);
+      expect(msg.type).toBe("canvas:update");
+    });
+  });
+
+  describe("clear", () => {
+    it("should send clear message to session", async () => {
+      const ws = createMockWebSocket();
+      manager.registerSession("session-1", ws);
+
+      await manager.clear("session-1");
+
+      expect(ws.messages.length).toBe(1);
+      const msg = JSON.parse(ws.messages[0]!);
+      expect(msg.type).toBe("canvas:clear");
+    });
+  });
+
+  describe("waitForInteraction", () => {
+    it("should resolve when interaction is received", async () => {
+      const ws = createMockWebSocket();
+      manager.registerSession("session-1", ws);
+
+      const component = { id: "form-1", type: "form" as const, props: {} };
+      await manager.render("session-1", component);
+
+      const interactionPromise = manager.waitForInteraction("session-1", "form-1", 5000);
+
+      manager.handleInteraction("session-1", "form-1", { name: "John" });
+
+      const result = await interactionPromise;
+      expect(result).toEqual({ name: "John" });
+    });
+  });
+
+  describe("getStats", () => {
+    it("should return correct stats", () => {
+      const ws1 = createMockWebSocket();
+      const ws2 = createMockWebSocket();
+
+      manager.registerSession("session-1", ws1);
+      manager.registerSession("session-2", ws2);
+
+      const stats = manager.getStats();
+      expect(stats.totalSessions).toBe(2);
+      expect(stats.activeSessions).toBe(2);
+    });
+  });
+
+  describe("getConnectedSessions", () => {
+    it("should list connected sessions", () => {
+      const ws1 = createMockWebSocket();
+      const ws2 = createMockWebSocket();
+
+      manager.registerSession("session-1", ws1);
+      manager.registerSession("session-2", ws2);
+
+      const sessions = manager.getConnectedSessions();
+      expect(sessions).toContain("session-1");
+      expect(sessions).toContain("session-2");
+    });
+  });
+
+  describe("clearAll", () => {
+    it("should clear all sessions and pending interactions", () => {
+      const ws = createMockWebSocket();
+      manager.registerSession("session-1", ws);
+
+      manager.clearAll();
+
+      const stats = manager.getStats();
+      expect(stats.totalSessions).toBe(0);
+    });
+  });
+});