whale-code 6.5.6 → 6.5.7

package/dist/cli/services/__tests__/team-lead-stop.test.js

@@ -0,0 +1,199 @@
+/**
+ * Tests for team-lead.ts — stop method (split from team-lead-comms.test.ts)
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { EventEmitter } from "events";
+
+// ============================================================================
+// MOCKS
+// ============================================================================
+
+const mockCreateTeam = vi.fn();
+const mockLoadTeam = vi.fn();
+const mockSaveTeam = vi.fn();
+const mockAddTeammate = vi.fn();
+const mockAddTask = vi.fn();
+const mockGetTeamProgress = vi.fn();
+const mockSetTeamStatus = vi.fn();
+const mockSendMessage = vi.fn();
+const mockGetUnreadMessages = vi.fn();
+const mockMarkMessagesRead = vi.fn();
+const mockFailTask = vi.fn();
+const mockUpdateTeammate = vi.fn();
+vi.mock("../team-state.js", () => ({
+  createTeam: (...args) => mockCreateTeam(...args),
+  loadTeam: (...args) => mockLoadTeam(...args),
+  saveTeam: (...args) => mockSaveTeam(...args),
+  addTeammate: (...args) => mockAddTeammate(...args),
+  addTask: (...args) => mockAddTask(...args),
+  getTeamProgress: (...args) => mockGetTeamProgress(...args),
+  setTeamStatus: (...args) => mockSetTeamStatus(...args),
+  sendMessage: (...args) => mockSendMessage(...args),
+  getUnreadMessages: (...args) => mockGetUnreadMessages(...args),
+  markMessagesRead: (...args) => mockMarkMessagesRead(...args),
+  failTask: (...args) => mockFailTask(...args),
+  updateTeammate: (...args) => mockUpdateTeammate(...args)
+}));
+const mockSpawnTeammate = vi.fn();
+vi.mock("../teammate.js", () => ({
+  spawnTeammate: (...args) => mockSpawnTeammate(...args)
+}));
+vi.mock("../telemetry.js", () => ({
+  logSpan: vi.fn(),
+  generateTraceId: vi.fn(() => "trace-123"),
+  generateSpanId: vi.fn(() => "span-123"),
+  getConversationId: vi.fn(() => "conv-123"),
+  PKG_VERSION: "0.0.0-test"
+}));
+vi.mock("../config-store.js", () => ({
+  resolveConfig: vi.fn(() => ({
+    storeId: "store-1"
+  }))
+}));
+vi.mock("../agent-events.js", () => {
+  const emitter = {
+    emitTeamStart: vi.fn(),
+    emitTeamProgress: vi.fn(),
+    emitTeamTask: vi.fn(),
+    emitTeamDone: vi.fn()
+  };
+  return {
+    getGlobalEmitter: vi.fn(() => emitter)
+  };
+});
+vi.mock("../agent-loop.js", () => ({
+  getModelShortName: vi.fn(() => "sonnet")
+}));
+vi.mock("../agent-config.js", () => ({
+  loadCLIAgentConfig: vi.fn(() => Promise.resolve(null))
+}));
+vi.mock("../server-tools.js", () => ({
+  loadServerToolDefinitions: vi.fn(() => Promise.resolve([]))
+}));
+import { TeamLead } from "../team-lead.js";
+// ============================================================================
+// HELPERS
+// ============================================================================
+
+function makeTeamState(overrides = {}) {
+  return {
+    id: "team-123",
+    name: "Test Team",
+    leadId: "lead",
+    teammates: [],
+    tasks: [],
+    messages: [],
+    createdAt: "2026-01-01T00:00:00.000Z",
+    updatedAt: "2026-01-01T00:00:00.000Z",
+    status: "active",
+    ...overrides
+  };
+}
+function makeChildProcessMock() {
+  const child = new EventEmitter();
+  child.kill = vi.fn();
+  child.send = vi.fn();
+  child.pid = Math.floor(Math.random() * 10000);
+  return child;
+}
+
+// ============================================================================
+// TESTS
+// ============================================================================
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.useFakeTimers({
+    shouldAdvanceTime: false
+  });
+});
+afterEach(() => {
+  vi.useRealTimers();
+});
+describe("stop method", () => {
+  it("should set team status to failed when stopped", async () => {
+    const team = makeTeamState();
+    mockCreateTeam.mockReturnValue(team);
+    mockLoadTeam.mockReturnValue(team);
+    mockSaveTeam.mockImplementation(() => {});
+    mockAddTask.mockResolvedValue({
+      id: "t-1",
+      description: "Task"
+    });
+    mockAddTeammate.mockResolvedValue({
+      id: "tm-1"
+    });
+    mockSetTeamStatus.mockResolvedValue(true);
+    const lead = new TeamLead();
+    await lead.createTeam({
+      name: "Test",
+      teammateCount: 1,
+      tasks: [{
+        description: "Task"
+      }]
+    });
+    lead.stop();
+    expect(mockSetTeamStatus).toHaveBeenCalledWith("team-123", "failed");
+  });
+  it("should emit teammate_stopped for each worker", async () => {
+    const worker = makeChildProcessMock();
+    const team = makeTeamState({
+      teammates: [{
+        id: "tm-1",
+        name: "A",
+        model: "sonnet",
+        status: "idle",
+        tokensUsed: {
+          input: 0,
+          output: 0
+        },
+        startedAt: ""
+      }],
+      tasks: [{
+        id: "t-1",
+        description: "Task",
+        status: "completed",
+        result: "Done",
+        createdAt: "",
+        updatedAt: ""
+      }]
+    });
+    mockCreateTeam.mockReturnValue(team);
+    mockLoadTeam.mockReturnValue(team);
+    mockSaveTeam.mockImplementation(() => {});
+    mockAddTask.mockResolvedValue({
+      id: "t-1",
+      description: "Task"
+    });
+    mockAddTeammate.mockResolvedValue({
+      id: "tm-1"
+    });
+    mockSpawnTeammate.mockResolvedValue(worker);
+    mockSetTeamStatus.mockResolvedValue(true);
+    mockGetTeamProgress.mockReturnValue({
+      total: 1,
+      completed: 1,
+      blocked: 0,
+      percentComplete: 100,
+      inProgress: 0,
+      pending: 0
+    });
+    const lead = new TeamLead();
+    await lead.createTeam({
+      name: "Test",
+      teammateCount: 1,
+      tasks: [{
+        description: "Task"
+      }]
+    });
+    const events = [];
+    lead.on("teammate_stopped", e => events.push(e));
+    const resultPromise = lead.runTeam();
+    await vi.advanceTimersByTimeAsync(10);
+    lead.stop();
+    expect(worker.kill).toHaveBeenCalled();
+    worker.emit("exit", 0);
+    await vi.advanceTimersByTimeAsync(100);
+  });
+});

package/dist/cli/services/__tests__/team-state-comms.test.js

@@ -0,0 +1,240 @@
+/**
+ * Tests for team-state.ts — sendMessage, getUnreadMessages, markMessagesRead, getTeamProgress, setTeamStatus
+ */
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// Mock the fs module before importing the module under test
+vi.mock("fs", () => ({
+  existsSync: vi.fn(),
+  readFileSync: vi.fn(),
+  writeFileSync: vi.fn(),
+  mkdirSync: vi.fn(),
+  unlinkSync: vi.fn(),
+  readdirSync: vi.fn()
+}));
+vi.mock("os", () => ({
+  homedir: vi.fn(() => "/mock-home")
+}));
+vi.mock("path", async () => {
+  const actual = await vi.importActual("path");
+  return {
+    ...actual,
+    join: (...args) => args.join("/")
+  };
+});
+import { sendMessage, getUnreadMessages, markMessagesRead, getTeamProgress, setTeamStatus } from "../team-state.js";
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from "fs";
+const mockExistsSync = vi.mocked(existsSync);
+const mockReadFileSync = vi.mocked(readFileSync);
+const mockWriteFileSync = vi.mocked(writeFileSync);
+
+// ============================================================================
+// HELPERS
+// ============================================================================
+
+function makeTeam(overrides = {}) {
+  return {
+    id: "team-123",
+    name: "Test Team",
+    leadId: "lead",
+    teammates: [],
+    tasks: [],
+    messages: [],
+    createdAt: "2026-01-01T00:00:00.000Z",
+    updatedAt: "2026-01-01T00:00:00.000Z",
+    status: "active",
+    ...overrides
+  };
+}
+function makeTask(overrides = {}) {
+  return {
+    id: "task-1",
+    description: "Test task",
+    status: "pending",
+    createdAt: "2026-01-01T00:00:00.000Z",
+    updatedAt: "2026-01-01T00:00:00.000Z",
+    ...overrides
+  };
+}
+function setupLockAndTeam(team) {
+  mockExistsSync.mockImplementation(p => {
+    const path = String(p);
+    if (path.endsWith(".lock")) return false;
+    if (path.endsWith(".json")) return true;
+    return true;
+  });
+  mockReadFileSync.mockReturnValue(JSON.stringify(team));
+  mockWriteFileSync.mockImplementation(() => {});
+  vi.mocked(unlinkSync).mockImplementation(() => {});
+}
+
+// ============================================================================
+// TESTS
+// ============================================================================
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+describe("sendMessage", () => {
+  it("should create a message with correct properties", async () => {
+    const team = makeTeam();
+    setupLockAndTeam(team);
+    const result = await sendMessage("team-123", "tm-1", "tm-2", "Hello!");
+    expect(result).not.toBeNull();
+    expect(result.from).toBe("tm-1");
+    expect(result.to).toBe("tm-2");
+    expect(result.content).toBe("Hello!");
+    expect(result.read).toBe(false);
+    expect(result.id).toMatch(/^msg-\d+-[a-z0-9]+$/);
+  });
+  it("should return null if team does not exist", async () => {
+    mockExistsSync.mockImplementation(p => {
+      const path = String(p);
+      if (path.endsWith(".lock")) return false;
+      return false;
+    });
+    mockWriteFileSync.mockImplementation(() => {});
+    const result = await sendMessage("no-team", "a", "b", "Hi");
+    expect(result).toBeNull();
+  });
+});
+describe("getUnreadMessages", () => {
+  it("should return unread messages for the recipient", async () => {
+    const team = makeTeam({
+      messages: [{
+        id: "msg-1",
+        from: "tm-1",
+        to: "tm-2",
+        content: "Hello",
+        timestamp: "",
+        read: false
+      }, {
+        id: "msg-2",
+        from: "tm-1",
+        to: "tm-3",
+        content: "Nope",
+        timestamp: "",
+        read: false
+      }, {
+        id: "msg-3",
+        from: "tm-1",
+        to: "tm-2",
+        content: "Read",
+        timestamp: "",
+        read: true
+      }]
+    });
+    mockExistsSync.mockReturnValue(true);
+    mockReadFileSync.mockReturnValue(JSON.stringify(team));
+    const msgs = await getUnreadMessages("team-123", "tm-2");
+    expect(msgs.length).toBe(1);
+    expect(msgs[0].content).toBe("Hello");
+  });
+  it("should include broadcast messages (to='all')", async () => {
+    const team = makeTeam({
+      messages: [{
+        id: "msg-1",
+        from: "tm-1",
+        to: "all",
+        content: "Broadcast",
+        timestamp: "",
+        read: false
+      }]
+    });
+    mockExistsSync.mockReturnValue(true);
+    mockReadFileSync.mockReturnValue(JSON.stringify(team));
+    const msgs = await getUnreadMessages("team-123", "tm-2");
+    expect(msgs.length).toBe(1);
+    expect(msgs[0].content).toBe("Broadcast");
+  });
+  it("should return empty array if team not found", async () => {
+    mockExistsSync.mockReturnValue(false);
+    const msgs = await getUnreadMessages("no-team", "tm-1");
+    expect(msgs).toEqual([]);
+  });
+});
+describe("markMessagesRead", () => {
+  it("should mark specified messages as read", async () => {
+    const team = makeTeam({
+      messages: [{
+        id: "msg-1",
+        from: "a",
+        to: "b",
+        content: "Hi",
+        timestamp: "",
+        read: false
+      }, {
+        id: "msg-2",
+        from: "a",
+        to: "b",
+        content: "There",
+        timestamp: "",
+        read: false
+      }]
+    });
+    setupLockAndTeam(team);
+    const result = await markMessagesRead("team-123", ["msg-1"]);
+    expect(result).toBe(true);
+  });
+});
+describe("getTeamProgress", () => {
+  it("should count tasks by status", () => {
+    const team = makeTeam({
+      tasks: [makeTask({
+        status: "pending"
+      }), makeTask({
+        status: "in_progress"
+      }), makeTask({
+        status: "completed"
+      }), makeTask({
+        status: "blocked"
+      })]
+    });
+    const progress = getTeamProgress(team);
+    expect(progress.total).toBe(4);
+    expect(progress.completed).toBe(1);
+    expect(progress.inProgress).toBe(1);
+    expect(progress.pending).toBe(1);
+    expect(progress.blocked).toBe(1);
+    expect(progress.percentComplete).toBe(25);
+  });
+  it("should return 0% when no tasks exist", () => {
+    const team = makeTeam({
+      tasks: []
+    });
+    const progress = getTeamProgress(team);
+    expect(progress.percentComplete).toBe(0);
+  });
+  it("should return 100% when all tasks completed", () => {
+    const team = makeTeam({
+      tasks: [makeTask({
+        status: "completed"
+      }), makeTask({
+        status: "completed"
+      })]
+    });
+    const progress = getTeamProgress(team);
+    expect(progress.percentComplete).toBe(100);
+  });
+});
+describe("setTeamStatus", () => {
+  it("should set team status", async () => {
+    const team = makeTeam({
+      status: "active"
+    });
+    setupLockAndTeam(team);
+    const result = await setTeamStatus("team-123", "completed");
+    expect(result).toBe(true);
+  });
+  it("should return false if team not found", async () => {
+    mockExistsSync.mockImplementation(p => {
+      const path = String(p);
+      if (path.endsWith(".lock")) return false;
+      return false;
+    });
+    mockWriteFileSync.mockImplementation(() => {});
+    const result = await setTeamStatus("no-team", "completed");
+    expect(result).toBe(false);
+  });
+});

package/dist/cli/services/__tests__/team-state-core.test.js

@@ -0,0 +1,230 @@
+/**
+ * Tests for team-state.ts — createTeam, loadTeam, saveTeam, listTeams, addTeammate, updateTeammate
+ */
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// Mock the fs module before importing the module under test
+vi.mock("fs", () => ({
+  existsSync: vi.fn(),
+  readFileSync: vi.fn(),
+  writeFileSync: vi.fn(),
+  mkdirSync: vi.fn(),
+  unlinkSync: vi.fn(),
+  readdirSync: vi.fn()
+}));
+vi.mock("os", () => ({
+  homedir: vi.fn(() => "/mock-home")
+}));
+vi.mock("path", async () => {
+  const actual = await vi.importActual("path");
+  return {
+    ...actual,
+    join: (...args) => args.join("/")
+  };
+});
+import { createTeam, loadTeam, saveTeam, listTeams, addTeammate, updateTeammate } from "../team-state.js";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync, readdirSync } from "fs";
+const mockExistsSync = vi.mocked(existsSync);
+const mockReadFileSync = vi.mocked(readFileSync);
+const mockWriteFileSync = vi.mocked(writeFileSync);
+const mockMkdirSync = vi.mocked(mkdirSync);
+const mockReaddirSync = vi.mocked(readdirSync);
+
+// ============================================================================
+// HELPERS
+// ============================================================================
+
+function makeTeam(overrides = {}) {
+  return {
+    id: "team-123",
+    name: "Test Team",
+    leadId: "lead",
+    teammates: [],
+    tasks: [],
+    messages: [],
+    createdAt: "2026-01-01T00:00:00.000Z",
+    updatedAt: "2026-01-01T00:00:00.000Z",
+    status: "active",
+    ...overrides
+  };
+}
+function setupLockAndTeam(team) {
+  mockExistsSync.mockImplementation(p => {
+    const path = String(p);
+    if (path.endsWith(".lock")) return false;
+    if (path.endsWith(".json")) return true;
+    return true;
+  });
+  mockReadFileSync.mockReturnValue(JSON.stringify(team));
+  mockWriteFileSync.mockImplementation(() => {});
+  vi.mocked(unlinkSync).mockImplementation(() => {});
+}
+
+// ============================================================================
+// TESTS
+// ============================================================================
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+describe("createTeam", () => {
+  it("should create a team with correct default properties", () => {
+    mockExistsSync.mockReturnValue(false);
+    mockWriteFileSync.mockImplementation(() => {});
+    mockMkdirSync.mockImplementation(() => undefined);
+    const team = createTeam("My Team", "lead-1");
+    expect(team.name).toBe("My Team");
+    expect(team.leadId).toBe("lead-1");
+    expect(team.teammates).toEqual([]);
+    expect(team.tasks).toEqual([]);
+    expect(team.messages).toEqual([]);
+    expect(team.status).toBe("active");
+    expect(team.id).toMatch(/^team-\d+-[a-z0-9]+$/);
+  });
+  it("should ensure directory exists when creating a team", () => {
+    mockExistsSync.mockReturnValue(false);
+    mockWriteFileSync.mockImplementation(() => {});
+    mockMkdirSync.mockImplementation(() => undefined);
+    createTeam("Team", "lead");
+    expect(mockMkdirSync).toHaveBeenCalled();
+  });
+  it("should save the team state to disk", () => {
+    mockExistsSync.mockReturnValue(false);
+    mockWriteFileSync.mockImplementation(() => {});
+    mockMkdirSync.mockImplementation(() => undefined);
+    const team = createTeam("My Team", "lead");
+    expect(mockWriteFileSync).toHaveBeenCalled();
+    const writtenData = JSON.parse(mockWriteFileSync.mock.calls[0][1]);
+    expect(writtenData.name).toBe("My Team");
+  });
+});
+describe("loadTeam", () => {
+  it("should return null if team file does not exist", () => {
+    mockExistsSync.mockReturnValue(false);
+    const result = loadTeam("nonexistent");
+    expect(result).toBeNull();
+  });
+  it("should load and parse team from disk", () => {
+    const team = makeTeam();
+    mockExistsSync.mockReturnValue(true);
+    mockReadFileSync.mockReturnValue(JSON.stringify(team));
+    const result = loadTeam("team-123");
+    expect(result).toEqual(team);
+  });
+  it("should return null if JSON is invalid", () => {
+    mockExistsSync.mockReturnValue(true);
+    mockReadFileSync.mockReturnValue("not json");
+    const result = loadTeam("team-123");
+    expect(result).toBeNull();
+  });
+});
+describe("saveTeam", () => {
+  it("should write team to disk and update updatedAt", () => {
+    mockExistsSync.mockReturnValue(true);
+    mockWriteFileSync.mockImplementation(() => {});
+    const team = makeTeam({
+      updatedAt: "old-date"
+    });
+    saveTeam(team);
+    expect(mockWriteFileSync).toHaveBeenCalled();
+    const written = JSON.parse(mockWriteFileSync.mock.calls[0][1]);
+    expect(written.updatedAt).not.toBe("old-date");
+  });
+});
+describe("listTeams", () => {
+  it("should return empty array when no teams exist", () => {
+    mockExistsSync.mockReturnValue(true);
+    mockReaddirSync.mockReturnValue([]);
+    const result = listTeams();
+    expect(result).toEqual([]);
+  });
+  it("should filter out lock files and parse json files", () => {
+    mockExistsSync.mockReturnValue(true);
+    const team = makeTeam();
+    mockReaddirSync.mockReturnValue(["team-1.json", "team-1.lock", "team-2.json"]);
+    mockReadFileSync.mockReturnValue(JSON.stringify(team));
+    const result = listTeams();
+    expect(result.length).toBe(2);
+  });
+  it("should skip invalid JSON files gracefully", () => {
+    mockExistsSync.mockReturnValue(true);
+    mockReaddirSync.mockReturnValue(["team-1.json", "bad.json"]);
+    mockReadFileSync.mockReturnValueOnce(JSON.stringify(makeTeam())).mockReturnValueOnce("invalid json");
+    const result = listTeams();
+    expect(result.length).toBe(1);
+  });
+});
+describe("addTeammate", () => {
+  it("should add teammate to team and return teammate info", async () => {
+    const team = makeTeam();
+    setupLockAndTeam(team);
+    const result = await addTeammate("team-123", {
+      id: "tm-1",
+      name: "Alice",
+      model: "sonnet",
+      status: "idle"
+    });
+    expect(result).not.toBeNull();
+    expect(result.id).toBe("tm-1");
+    expect(result.name).toBe("Alice");
+    expect(result.tokensUsed).toEqual({
+      input: 0,
+      output: 0
+    });
+  });
+  it("should return null if team does not exist", async () => {
+    mockExistsSync.mockImplementation(p => {
+      const path = String(p);
+      if (path.endsWith(".lock")) return false;
+      return false;
+    });
+    mockWriteFileSync.mockImplementation(() => {});
+    mockReadFileSync.mockReturnValue("{}");
+    mockExistsSync.mockImplementation(p => {
+      const path = String(p);
+      if (path.endsWith(".lock")) return false;
+      if (path.endsWith(".json")) return false;
+      return true;
+    });
+    const result = await addTeammate("no-team", {
+      id: "tm-1",
+      name: "Alice",
+      model: "sonnet",
+      status: "idle"
+    });
+    expect(result).toBeNull();
+  });
+});
+describe("updateTeammate", () => {
+  it("should update teammate properties", async () => {
+    const team = makeTeam({
+      teammates: [{
+        id: "tm-1",
+        name: "Alice",
+        model: "sonnet",
+        status: "idle",
+        tokensUsed: {
+          input: 0,
+          output: 0
+        },
+        startedAt: "2026-01-01T00:00:00.000Z"
+      }]
+    });
+    setupLockAndTeam(team);
+    const result = await updateTeammate("team-123", "tm-1", {
+      status: "working"
+    });
+    expect(result).toBe(true);
+  });
+  it("should return false if teammate not found", async () => {
+    const team = makeTeam({
+      teammates: []
+    });
+    setupLockAndTeam(team);
+    const result = await updateTeammate("team-123", "missing-tm", {
+      status: "working"
+    });
+    expect(result).toBe(false);
+  });
+});