@ebowwa/coder 0.7.63 → 0.7.65

package/packages/src/teammates/integration.test.ts

@@ -0,0 +1,272 @@
+/**
+ * Integration test for teammate coordination
+ * Tests: long horizon, cohesion, assignment completion
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { TeammateManager } from "./index.js";
+import { TeammateModeRunner, setTeammateRunner } from "./runner.js";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+
+const TEAMS_DIR = path.join(os.homedir(), ".claude", "teams");
+const TEST_TEAM = `integration-test-${Date.now()}`;
+
+function cleanupTestTeam() {
+  const teamPath = path.join(TEAMS_DIR, TEST_TEAM);
+  if (fs.existsSync(teamPath)) {
+    fs.rmSync(teamPath, { recursive: true, force: true });
+  }
+}
+
+describe("Teammate Integration Tests", () => {
+  let manager: TeammateManager;
+
+  beforeEach(() => {
+    cleanupTestTeam();
+    manager = new TeammateManager();
+  });
+
+  afterEach(() => {
+    cleanupTestTeam();
+    setTeammateRunner(null);
+  });
+
+  describe("Long Horizon - Extended Operation", () => {
+    it("should maintain state over multiple operations", async () => {
+      // Create team
+      const team = manager.createTeam({
+        name: TEST_TEAM,
+        description: "Long horizon test team",
+        teammates: [],
+        taskListId: `${TEST_TEAM}-tasks`,
+        coordination: {
+          dependencyOrder: [],
+          communicationProtocol: "broadcast",
+          taskAssignmentStrategy: "manual",
+        },
+      });
+
+      // Create teammate
+      const runner = new TeammateModeRunner({
+        teamName: TEST_TEAM,
+        agentName: "long-horizon-agent",
+        agentColor: "green",
+        workingDirectory: process.cwd(),
+        pollInterval: 100,
+      });
+
+      await runner.start();
+      setTeammateRunner(runner);
+
+      // Simulate long horizon: multiple status updates
+      expect(runner.getStatus()).toBe("in_progress");
+
+      runner.reportActivity();
+      expect(runner.getStatus()).toBe("in_progress");
+
+      // Complete a task
+      runner.reportTaskComplete("task-1", "First task");
+      expect(runner.getStatus()).toBe("completed");
+
+      // Request new task (resets to idle)
+      runner.requestTask();
+      expect(runner.getStatus()).toBe("idle");
+
+      // Report activity again (should flip to in_progress)
+      runner.reportActivity();
+      expect(runner.getStatus()).toBe("in_progress");
+
+      // Fail a task
+      runner.reportTaskFailed("task-2", "Second task", "Test failure");
+      expect(runner.getStatus()).toBe("failed");
+
+      await runner.stop();
+      expect(runner.getStatus()).toBe("idle");
+    });
+
+    it("should persist team state across operations", async () => {
+      const runner = new TeammateModeRunner({
+        teamName: TEST_TEAM,
+        agentName: "persist-agent",
+        workingDirectory: process.cwd(),
+        pollInterval: 100,
+      });
+
+      await runner.start();
+
+      // Verify teammate was added to team
+      const teammate = runner.getTeammate();
+      expect(teammate).not.toBe(null);
+      expect(teammate?.name).toBe("persist-agent");
+
+      // Stop and restart
+      await runner.stop();
+
+      // Create new runner with same team
+      const runner2 = new TeammateModeRunner({
+        teamName: TEST_TEAM,
+        agentName: "persist-agent-2",
+        workingDirectory: process.cwd(),
+        pollInterval: 100,
+      });
+
+      await runner2.start();
+
+      // Team should have both teammates now
+      const members = runner2.getTeamMembers();
+      expect(members.length).toBe(2);
+
+      await runner2.stop();
+    });
+  });
+
+  describe("Cohesion - Multi-Agent Coordination", () => {
+    it("should support multiple teammates in same team", async () => {
+      // Create first teammate
+      const runner1 = new TeammateModeRunner({
+        teamName: TEST_TEAM,
+        agentName: "coordinator",
+        agentColor: "blue",
+        workingDirectory: process.cwd(),
+        pollInterval: 100,
+      });
+
+      await runner1.start();
+
+      // Wait for persistence to complete
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      // Create second teammate (will load team from disk)
+      const runner2 = new TeammateModeRunner({
+        teamName: TEST_TEAM,
+        agentName: "worker",
+        agentColor: "orange",
+        workingDirectory: process.cwd(),
+        pollInterval: 100,
+      });
+
+      await runner2.start();
+
+      // Wait for persistence
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      // Both should see each other
+      const members1 = runner1.getTeamMembers();
+      const members2 = runner2.getTeamMembers();
+
+      // runner1 sees itself (in memory) + runner2 (loaded from disk)
+      expect(members1.length).toBeGreaterThanOrEqual(1);
+      // runner2 sees itself (in memory) + runner1 (loaded from disk)
+      expect(members2.length).toBeGreaterThanOrEqual(1);
+
+      // Verify coordinator and worker are both in the team
+      const allNames = new Set([...members1, ...members2].map(m => m.name));
+      expect(allNames.has("coordinator")).toBe(true);
+      expect(allNames.has("worker")).toBe(true);
+
+      await runner1.stop();
+      await runner2.stop();
+    });
+
+    it("should support broadcast messages", async () => {
+      const runner1 = new TeammateModeRunner({
+        teamName: TEST_TEAM,
+        agentName: "broadcaster",
+        workingDirectory: process.cwd(),
+        pollInterval: 100,
+      });
+
+      await runner1.start();
+
+      // Broadcast should not throw
+      runner1.broadcast("Attention all teammates!");
+
+      await runner1.stop();
+    });
+  });
+
+  describe("Assignment Completion", () => {
+    it("should track task completion workflow", async () => {
+      const runner = new TeammateModeRunner({
+        teamName: TEST_TEAM,
+        agentName: "task-worker",
+        workingDirectory: process.cwd(),
+        pollInterval: 100,
+      });
+
+      await runner.start();
+
+      // Initial status
+      expect(runner.getStatus()).toBe("in_progress");
+
+      // Complete task
+      runner.reportTaskComplete("assignment-1", "Complete integration tests");
+      expect(runner.getStatus()).toBe("completed");
+
+      // Request new assignment
+      runner.requestTask();
+      expect(runner.getStatus()).toBe("idle");
+
+      await runner.stop();
+    });
+
+    it("should track task failure and recovery", async () => {
+      const runner = new TeammateModeRunner({
+        teamName: TEST_TEAM,
+        agentName: "failing-worker",
+        workingDirectory: process.cwd(),
+        pollInterval: 100,
+      });
+
+      await runner.start();
+
+      // Fail task
+      runner.reportTaskFailed("assignment-2", "Risky task", "Dependencies not met");
+      expect(runner.getStatus()).toBe("failed");
+
+      // Recover by requesting new task
+      runner.requestTask();
+      expect(runner.getStatus()).toBe("idle");
+
+      await runner.stop();
+    });
+  });
+
+  describe("Inbox Management", () => {
+    it("should track inbox stats", async () => {
+      const runner = new TeammateModeRunner({
+        teamName: TEST_TEAM,
+        agentName: "inbox-worker",
+        workingDirectory: process.cwd(),
+        pollInterval: 100,
+      });
+
+      await runner.start();
+
+      const stats = runner.getInboxStats();
+      expect(stats).toHaveProperty("pending");
+      expect(stats).toHaveProperty("processed");
+
+      await runner.stop();
+    });
+
+    it("should check for pending messages", async () => {
+      const runner = new TeammateModeRunner({
+        teamName: TEST_TEAM,
+        agentName: "message-checker",
+        workingDirectory: process.cwd(),
+        pollInterval: 100,
+      });
+
+      await runner.start();
+
+      expect(runner.hasPendingMessages()).toBe(false);
+      expect(runner.getPendingMessages()).toEqual([]);
+      expect(runner.peekPendingMessages()).toEqual([]);
+
+      await runner.stop();
+    });
+  });
+});

package/packages/src/teammates/runner.test.ts

@@ -0,0 +1,235 @@
+/**
+ * Tests for TeammateModeRunner
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "bun:test";
+import { TeammateModeRunner, getTeammateRunner, setTeammateRunner, isTeammateModeActive } from "./runner.js";
+import type { TeammateModeConfig } from "./runner.js";
+
+// Mock TeammateManager
+vi.mock("./index.js", () => ({
+  TeammateManager: vi.fn().mockImplementation(() => ({
+    getTeam: vi.fn(() => null),
+    createTeam: vi.fn((config) => ({ ...config, teammates: [] })),
+    getTeammate: vi.fn(() => null),
+    addTeammate: vi.fn(),
+    updateTeammateStatus: vi.fn(),
+    persistAllTeams: vi.fn(),
+    getMessages: vi.fn(() => []),
+    sendDirect: vi.fn(),
+    broadcast: vi.fn(),
+    injectUserMessageToTeammate: vi.fn(),
+    getInboxStats: vi.fn(() => ({ pending: 0, processed: 0 })),
+    waitForTeammatesToBecomeIdle: vi.fn(() => ({ success: true, timedOut: false, statuses: {} })),
+  })),
+  generateTeammateId: vi.fn(() => "test-teammate-id"),
+}));
+
+describe("TeammateModeRunner", () => {
+  let runner: TeammateModeRunner;
+  let config: TeammateModeConfig;
+
+  beforeEach(() => {
+    config = {
+      teamName: "test-team",
+      workingDirectory: "/tmp/test",
+      pollInterval: 100, // Fast polling for tests
+    };
+    runner = new TeammateModeRunner(config);
+    vi.useFakeTimers();
+  });
+
+  afterEach(async () => {
+    if (runner.isActive()) {
+      await runner.stop();
+    }
+    vi.useRealTimers();
+    vi.clearAllMocks();
+  });
+
+  describe("constructor", () => {
+    it("should initialize with correct default state", () => {
+      expect(runner.isActive()).toBe(false);
+      expect(runner.getStatus()).toBe("pending");
+      expect(runner.getTeammate()).toBe(null);
+      expect(runner.getTeam()).toBe(null);
+    });
+  });
+
+  describe("start", () => {
+    it("should start teammate mode successfully", async () => {
+      const teammate = await runner.start();
+
+      expect(runner.isActive()).toBe(true);
+      expect(runner.getStatus()).toBe("in_progress");
+      expect(teammate.teamName).toBe("test-team");
+      // Status comes from local state, not the returned teammate object
+      expect(runner.getStatus()).toBe("in_progress");
+    });
+
+    it("should throw if already active", async () => {
+      await runner.start();
+
+      await expect(runner.start()).rejects.toThrow("Teammate mode already active");
+    });
+
+    it("should use provided agent config", async () => {
+      const customConfig: TeammateModeConfig = {
+        ...config,
+        // Don't provide agentId - that requires an existing teammate
+        agentName: "Custom Agent",
+        agentColor: "red",
+        prompt: "Test prompt",
+      };
+      const customRunner = new TeammateModeRunner(customConfig);
+
+      const teammate = await customRunner.start();
+
+      expect(teammate.name).toBe("Custom Agent");
+      expect(teammate.color).toBe("red");
+      expect(teammate.prompt).toBe("Test prompt");
+
+      await customRunner.stop();
+    });
+  });
+
+  describe("stop", () => {
+    it("should stop teammate mode", async () => {
+      await runner.start();
+      await runner.stop();
+
+      expect(runner.isActive()).toBe(false);
+      expect(runner.getStatus()).toBe("idle");
+    });
+
+    it("should be idempotent", async () => {
+      await runner.start();
+      await runner.stop();
+      await runner.stop(); // Should not throw
+
+      expect(runner.isActive()).toBe(false);
+    });
+  });
+
+  describe("message polling", () => {
+    it("should have pending messages methods", async () => {
+      await runner.start();
+
+      expect(runner.hasPendingMessages()).toBe(false);
+      expect(runner.getPendingMessages()).toEqual([]);
+      expect(runner.peekPendingMessages()).toEqual([]);
+    });
+  });
+
+  describe("idle detection", () => {
+    it("should start with non-idle status", async () => {
+      await runner.start();
+
+      expect(runner.getStatus()).toBe("in_progress");
+    });
+
+    it("should report activity", async () => {
+      await runner.start();
+
+      runner.reportActivity();
+
+      expect(runner.getStatus()).toBe("in_progress");
+    });
+  });
+
+  describe("messaging", () => {
+    it("should throw when sending without active teammate", async () => {
+      expect(() => runner.sendDirectMessage("target", "hello")).toThrow("Teammate mode not active");
+      expect(() => runner.broadcast("hello")).toThrow("Teammate mode not active");
+      expect(() => runner.injectUserMessage("hello")).toThrow("Teammate mode not active");
+    });
+  });
+
+  describe("status & info", () => {
+    it("should return teammate after start", async () => {
+      await runner.start();
+
+      const teammate = runner.getTeammate();
+      expect(teammate).not.toBe(null);
+      expect(teammate?.teamName).toBe("test-team");
+    });
+
+    it("should return team after start", async () => {
+      await runner.start();
+
+      const team = runner.getTeam();
+      expect(team).not.toBe(null);
+      expect(team?.name).toBe("test-team");
+    });
+
+    it("should return inbox stats", async () => {
+      await runner.start();
+
+      const stats = runner.getInboxStats();
+      expect(stats).toEqual({ pending: 0, processed: 0 });
+    });
+
+    it("should return team members", async () => {
+      await runner.start();
+
+      const members = runner.getTeamMembers();
+      expect(Array.isArray(members)).toBe(true);
+    });
+  });
+
+  describe("task integration", () => {
+    it("should report task complete", async () => {
+      await runner.start();
+      expect(runner.getStatus()).toBe("in_progress");
+
+      // reportTaskComplete calls updateStatus("completed")
+      runner.reportTaskComplete("task-123", "Test Task");
+
+      // Verify status changed to completed
+      const status = runner.getStatus();
+      expect(status).toBe("completed");
+    });
+
+    it("should report task failed", async () => {
+      await runner.start();
+      expect(runner.getStatus()).toBe("in_progress");
+
+      runner.reportTaskFailed("task-123", "Test Task", "Something went wrong");
+
+      const status = runner.getStatus();
+      expect(status).toBe("failed");
+    });
+
+    it("should request task", async () => {
+      await runner.start();
+
+      runner.requestTask();
+
+      expect(runner.getStatus()).toBe("idle");
+    });
+  });
+});
+
+describe("Global runner functions", () => {
+  afterEach(() => {
+    setTeammateRunner(null);
+  });
+
+  it("should return null when no global runner set", () => {
+    expect(getTeammateRunner()).toBe(null);
+    expect(isTeammateModeActive()).toBe(false);
+  });
+
+  it("should set and get global runner", () => {
+    const config: TeammateModeConfig = {
+      teamName: "global-test",
+      workingDirectory: "/tmp/test",
+    };
+    const runner = new TeammateModeRunner(config);
+
+    setTeammateRunner(runner);
+
+    expect(getTeammateRunner()).toBe(runner);
+    expect(isTeammateModeActive()).toBe(false); // Not started yet
+  });
+});