whale-code 6.5.10 → 6.6.0

package/dist/cli/services/__tests__/subagent-worker-errors.test.js

@@ -1,255 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-
-// ============================================================================
-// Mocks — must be declared before imports
-// ============================================================================
-
-const mockPostMessage = vi.fn();
-const mockExit = vi.fn();
-let mockParentPort = {
-  postMessage: mockPostMessage
-};
-let mockWorkerData = {
-  options: {
-    prompt: "test prompt",
-    subagent_type: "explore"
-  },
-  index: 0
-};
-vi.mock("worker_threads", () => ({
-  get parentPort() {
-    return mockParentPort;
-  },
-  get workerData() {
-    return mockWorkerData;
-  }
-}));
-const mockRunSubagent = vi.fn();
-vi.mock("../subagent.js", () => ({
-  runSubagent: (...args) => mockRunSubagent(...args)
-}));
-
-// Import types only (the module executes main() on import)
-
-// ============================================================================
-// Helpers
-// ============================================================================
-
-/** Dynamically import the worker module to trigger main() execution */
-async function runWorker() {
-  // Reset the module registry so it re-executes
-  vi.resetModules();
-
-  // Re-apply mocks after module reset
-  vi.doMock("worker_threads", () => ({
-    get parentPort() {
-      return mockParentPort;
-    },
-    get workerData() {
-      return mockWorkerData;
-    }
-  }));
-  vi.doMock("../subagent.js", () => ({
-    runSubagent: (...args) => mockRunSubagent(...args)
-  }));
-  await import("../subagent-worker.js");
-  // Allow async main() to settle
-  await vi.waitFor(() => {
-    const resultMessages = mockPostMessage.mock.calls.filter(c => c[0]?.type === "result");
-    if (resultMessages.length === 0 && mockParentPort !== null) {
-      throw new Error("Waiting for result message");
-    }
-  }, {
-    timeout: 2000
-  });
-}
-function makeSubagentResult(overrides = {}) {
-  return {
-    success: true,
-    output: "Task completed",
-    agentId: "agent-abc123",
-    tokensUsed: {
-      input: 100,
-      output: 200
-    },
-    toolsUsed: ["read_file", "write_file"],
-    ...overrides
-  };
-}
-
-// ============================================================================
-// Setup / Teardown
-// ============================================================================
-
-beforeEach(() => {
-  mockPostMessage.mockReset();
-  mockRunSubagent.mockReset();
-  mockExit.mockReset();
-  mockParentPort = {
-    postMessage: mockPostMessage
-  };
-  mockWorkerData = {
-    options: {
-      prompt: "test prompt",
-      subagent_type: "explore"
-    },
-    index: 0
-  };
-});
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-
-// ============================================================================
-// Error handling
-// ============================================================================
-
-describe("error handling", () => {
-  it("posts a result with success=false when runSubagent throws", async () => {
-    mockRunSubagent.mockRejectedValue(new Error("API rate limited"));
-    await runWorker();
-    const resultCalls = mockPostMessage.mock.calls.filter(c => c[0]?.type === "result");
-    expect(resultCalls).toHaveLength(1);
-    expect(resultCalls[0][0].success).toBe(false);
-    expect(resultCalls[0][0].error).toBe("API rate limited");
-  });
-  it("includes the correct index in error results", async () => {
-    mockWorkerData = {
-      options: {
-        prompt: "fail",
-        subagent_type: "explore"
-      },
-      index: 7
-    };
-    mockRunSubagent.mockRejectedValue(new Error("timeout"));
-    await runWorker();
-    const resultCalls = mockPostMessage.mock.calls.filter(c => c[0]?.type === "result");
-    expect(resultCalls[0][0].index).toBe(7);
-  });
-  it("converts non-Error throws to string", async () => {
-    mockRunSubagent.mockRejectedValue("plain string error");
-    await runWorker();
-    const resultCalls = mockPostMessage.mock.calls.filter(c => c[0]?.type === "result");
-    expect(resultCalls[0][0].success).toBe(false);
-    expect(resultCalls[0][0].error).toBe("plain string error");
-  });
-  it("does not include result property in error responses", async () => {
-    mockRunSubagent.mockRejectedValue(new Error("fail"));
-    await runWorker();
-    const resultCalls = mockPostMessage.mock.calls.filter(c => c[0]?.type === "result");
-    expect(resultCalls[0][0].result).toBeUndefined();
-  });
-  it("still posts starting progress before an error", async () => {
-    mockRunSubagent.mockRejectedValue(new Error("crash"));
-    await runWorker();
-    const progressCalls = mockPostMessage.mock.calls.filter(c => c[0]?.type === "progress");
-    expect(progressCalls.length).toBeGreaterThanOrEqual(1);
-    expect(progressCalls[0][0].message).toContain("Starting");
-  });
-});
-
-// ============================================================================
-// No parentPort (not run as worker thread)
-// ============================================================================
-
-describe("when parentPort is null", () => {
-  // process.exit() in the source never returns, so we simulate that by throwing.
-  // Since main() is invoked at module scope without await, the thrown error becomes
-  // an unhandled rejection. We install a temporary handler to suppress it.
-  class ExitError extends Error {
-    constructor(code) {
-      super(`process.exit(${code})`);
-      this.code = code;
-    }
-  }
-  it("logs error and exits with code 1", async () => {
-    mockParentPort = null;
-    const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-    vi.spyOn(process, "exit").mockImplementation(code => {
-      throw new ExitError(code);
-    });
-
-    // Catch the unhandled rejection from main()
-    const caughtErrors = [];
-    const handler = err => {
-      caughtErrors.push(err);
-    };
-    process.on("unhandledRejection", handler);
-    vi.resetModules();
-    vi.doMock("worker_threads", () => ({
-      get parentPort() {
-        return null;
-      },
-      get workerData() {
-        return mockWorkerData;
-      }
-    }));
-    vi.doMock("../subagent.js", () => ({
-      runSubagent: mockRunSubagent
-    }));
-    await import("../subagent-worker.js");
-    // Give async main() a tick to execute
-    await new Promise(r => setTimeout(r, 50));
-    expect(consoleSpy).toHaveBeenCalledWith("subagent-worker must be run as a worker thread");
-    expect(caughtErrors.some(e => e instanceof ExitError && e.code === 1)).toBe(true);
-    process.removeListener("unhandledRejection", handler);
-    consoleSpy.mockRestore();
-    vi.restoreAllMocks();
-  });
-  it("does not call runSubagent when parentPort is null", async () => {
-    mockParentPort = null;
-    vi.spyOn(console, "error").mockImplementation(() => {});
-    vi.spyOn(process, "exit").mockImplementation(code => {
-      throw new ExitError(code);
-    });
-    const handler = () => {};
-    process.on("unhandledRejection", handler);
-    vi.resetModules();
-    vi.doMock("worker_threads", () => ({
-      get parentPort() {
-        return null;
-      },
-      get workerData() {
-        return mockWorkerData;
-      }
-    }));
-    vi.doMock("../subagent.js", () => ({
-      runSubagent: mockRunSubagent
-    }));
-    await import("../subagent-worker.js");
-    await new Promise(r => setTimeout(r, 50));
-    expect(mockRunSubagent).not.toHaveBeenCalled();
-    process.removeListener("unhandledRejection", handler);
-    vi.restoreAllMocks();
-  });
-});
-
-// ============================================================================
-// Message structure — progress messages
-// ============================================================================
-
-describe("message structure — progress messages", () => {
-  it("progress messages have type, index, and message fields", async () => {
-    mockRunSubagent.mockResolvedValue(makeSubagentResult());
-    await runWorker();
-    const progressCalls = mockPostMessage.mock.calls.filter(c => c[0]?.type === "progress");
-    for (const call of progressCalls) {
-      const msg = call[0];
-      expect(msg).toHaveProperty("type", "progress");
-      expect(msg).toHaveProperty("index");
-      expect(msg).toHaveProperty("message");
-      expect(typeof msg.index).toBe("number");
-      expect(typeof msg.message).toBe("string");
-    }
-  });
-  it("result messages have type, success, and index fields", async () => {
-    mockRunSubagent.mockResolvedValue(makeSubagentResult());
-    await runWorker();
-    const resultCalls = mockPostMessage.mock.calls.filter(c => c[0]?.type === "result");
-    expect(resultCalls).toHaveLength(1);
-    const msg = resultCalls[0][0];
-    expect(msg).toHaveProperty("type", "result");
-    expect(msg).toHaveProperty("success", true);
-    expect(msg).toHaveProperty("index", 0);
-  });
-});

package/dist/cli/services/__tests__/subagent-worker.test.js

@@ -1,242 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-
-// ============================================================================
-// Mocks — must be declared before imports
-// ============================================================================
-
-const mockPostMessage = vi.fn();
-const mockExit = vi.fn();
-let mockParentPort = {
-  postMessage: mockPostMessage
-};
-let mockWorkerData = {
-  options: {
-    prompt: "test prompt",
-    subagent_type: "explore"
-  },
-  index: 0
-};
-vi.mock("worker_threads", () => ({
-  get parentPort() {
-    return mockParentPort;
-  },
-  get workerData() {
-    return mockWorkerData;
-  }
-}));
-const mockRunSubagent = vi.fn();
-vi.mock("../subagent.js", () => ({
-  runSubagent: (...args) => mockRunSubagent(...args)
-}));
-
-// Import types only (the module executes main() on import)
-
-// ============================================================================
-// Helpers
-// ============================================================================
-
-/** Dynamically import the worker module to trigger main() execution */
-async function runWorker() {
-  // Reset the module registry so it re-executes
-  vi.resetModules();
-
-  // Re-apply mocks after module reset
-  vi.doMock("worker_threads", () => ({
-    get parentPort() {
-      return mockParentPort;
-    },
-    get workerData() {
-      return mockWorkerData;
-    }
-  }));
-  vi.doMock("../subagent.js", () => ({
-    runSubagent: (...args) => mockRunSubagent(...args)
-  }));
-  await import("../subagent-worker.js");
-  // Allow async main() to settle
-  await vi.waitFor(() => {
-    const resultMessages = mockPostMessage.mock.calls.filter(c => c[0]?.type === "result");
-    if (resultMessages.length === 0 && mockParentPort !== null) {
-      throw new Error("Waiting for result message");
-    }
-  }, {
-    timeout: 2000
-  });
-}
-function makeSubagentResult(overrides = {}) {
-  return {
-    success: true,
-    output: "Task completed",
-    agentId: "agent-abc123",
-    tokensUsed: {
-      input: 100,
-      output: 200
-    },
-    toolsUsed: ["read_file", "write_file"],
-    ...overrides
-  };
-}
-
-// ============================================================================
-// Setup / Teardown
-// ============================================================================
-
-beforeEach(() => {
-  mockPostMessage.mockReset();
-  mockRunSubagent.mockReset();
-  mockExit.mockReset();
-  mockParentPort = {
-    postMessage: mockPostMessage
-  };
-  mockWorkerData = {
-    options: {
-      prompt: "test prompt",
-      subagent_type: "explore"
-    },
-    index: 0
-  };
-});
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-
-// ============================================================================
-// Worker types
-// ============================================================================
-
-describe("WorkerData interface", () => {
-  it("accepts valid worker data shape", () => {
-    const data = {
-      options: {
-        prompt: "test",
-        subagent_type: "explore"
-      },
-      index: 0
-    };
-    expect(data.options.prompt).toBe("test");
-    expect(data.index).toBe(0);
-  });
-  it("accepts all subagent types", () => {
-    const types = ["explore", "plan", "general-purpose", "research"];
-    for (const type of types) {
-      const data = {
-        options: {
-          prompt: "test",
-          subagent_type: type
-        },
-        index: 0
-      };
-      expect(data.options.subagent_type).toBe(type);
-    }
-  });
-});
-describe("WorkerResult interface", () => {
-  it("accepts a success result shape", () => {
-    const result = {
-      success: true,
-      index: 0,
-      result: {
-        success: true,
-        output: "done",
-        agentId: "id-1",
-        tokensUsed: {
-          input: 10,
-          output: 20
-        },
-        toolsUsed: []
-      }
-    };
-    expect(result.success).toBe(true);
-    expect(result.result?.output).toBe("done");
-  });
-  it("accepts an error result shape", () => {
-    const result = {
-      success: false,
-      index: 1,
-      error: "Something went wrong"
-    };
-    expect(result.success).toBe(false);
-    expect(result.error).toBe("Something went wrong");
-  });
-});
-
-// ============================================================================
-// Successful execution
-// ============================================================================
-
-describe("successful worker execution", () => {
-  it("calls runSubagent with the provided options", async () => {
-    const subResult = makeSubagentResult();
-    mockRunSubagent.mockResolvedValue(subResult);
-    await runWorker();
-    expect(mockRunSubagent).toHaveBeenCalledWith({
-      prompt: "test prompt",
-      subagent_type: "explore"
-    });
-  });
-  it("posts a progress message before starting", async () => {
-    mockRunSubagent.mockResolvedValue(makeSubagentResult());
-    await runWorker();
-    const progressCalls = mockPostMessage.mock.calls.filter(c => c[0]?.type === "progress");
-    expect(progressCalls.length).toBeGreaterThanOrEqual(1);
-    expect(progressCalls[0][0].message).toContain("Starting");
-    expect(progressCalls[0][0].message).toContain("explore");
-  });
-  it("posts a progress message after completion", async () => {
-    mockRunSubagent.mockResolvedValue(makeSubagentResult());
-    await runWorker();
-    const progressCalls = mockPostMessage.mock.calls.filter(c => c[0]?.type === "progress");
-    expect(progressCalls.length).toBeGreaterThanOrEqual(2);
-    const completionMsg = progressCalls.find(c => c[0].message.includes("Completed"));
-    expect(completionMsg).toBeDefined();
-    expect(completionMsg[0].message).toContain("explore");
-  });
-  it("posts a result message with success=true", async () => {
-    const subResult = makeSubagentResult();
-    mockRunSubagent.mockResolvedValue(subResult);
-    await runWorker();
-    const resultCalls = mockPostMessage.mock.calls.filter(c => c[0]?.type === "result");
-    expect(resultCalls).toHaveLength(1);
-    expect(resultCalls[0][0].success).toBe(true);
-    expect(resultCalls[0][0].result).toEqual(subResult);
-  });
-  it("includes the task index in result messages", async () => {
-    mockWorkerData = {
-      options: {
-        prompt: "task 3",
-        subagent_type: "plan"
-      },
-      index: 3
-    };
-    mockRunSubagent.mockResolvedValue(makeSubagentResult());
-    await runWorker();
-    const resultCalls = mockPostMessage.mock.calls.filter(c => c[0]?.type === "result");
-    expect(resultCalls[0][0].index).toBe(3);
-  });
-  it("includes the task index in progress messages", async () => {
-    mockWorkerData = {
-      options: {
-        prompt: "task 5",
-        subagent_type: "research"
-      },
-      index: 5
-    };
-    mockRunSubagent.mockResolvedValue(makeSubagentResult());
-    await runWorker();
-    const progressCalls = mockPostMessage.mock.calls.filter(c => c[0]?.type === "progress");
-    expect(progressCalls[0][0].index).toBe(5);
-  });
-  it("handles different subagent types in progress messages", async () => {
-    mockWorkerData = {
-      options: {
-        prompt: "plan the refactor",
-        subagent_type: "plan"
-      },
-      index: 1
-    };
-    mockRunSubagent.mockResolvedValue(makeSubagentResult());
-    await runWorker();
-    const progressCalls = mockPostMessage.mock.calls.filter(c => c[0]?.type === "progress");
-    expect(progressCalls[0][0].message).toContain("plan");
-  });
-});

package/dist/cli/services/__tests__/system-prompt.test.js

@@ -1,210 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-// ============================================================================
-// Mocks
-// ============================================================================
-
-vi.mock("fs", () => ({
-  readdirSync: vi.fn(() => [{
-    name: "src",
-    isDirectory: () => true,
-    isFile: () => false
-  }, {
-    name: "node_modules",
-    isDirectory: () => true,
-    isFile: () => false
-  }, {
-    name: ".git",
-    isDirectory: () => true,
-    isFile: () => false
-  }, {
-    name: "package.json",
-    isDirectory: () => false,
-    isFile: () => true
-  }, {
-    name: "README.md",
-    isDirectory: () => false,
-    isFile: () => true
-  }])
-}));
-vi.mock("../config-store.js", () => ({
-  loadConfig: vi.fn(() => ({}))
-}));
-vi.mock("../memory-manager.js", () => ({
-  loadMemory: vi.fn(() => "")
-}));
-vi.mock("../claude-md-loader.js", () => ({
-  loadClaudeMd: vi.fn(() => null)
-}));
-vi.mock("../git-context.js", () => ({
-  gatherGitContext: vi.fn(async () => "Branch: main\nStatus: clean")
-}));
-vi.mock("../permission-modes.js", () => ({
-  getPermissionMode: vi.fn(() => "default")
-}));
-import { buildSystemPrompt } from "../system-prompt.js";
-import { loadConfig } from "../config-store.js";
-import { loadMemory } from "../memory-manager.js";
-import { loadClaudeMd } from "../claude-md-loader.js";
-import { gatherGitContext } from "../git-context.js";
-import { getPermissionMode } from "../permission-modes.js";
-
-// ============================================================================
-// Setup
-// ============================================================================
-
-beforeEach(() => {
-  vi.mocked(loadConfig).mockReturnValue({});
-  vi.mocked(loadMemory).mockReturnValue("");
-  vi.mocked(loadClaudeMd).mockReturnValue(null);
-  vi.mocked(gatherGitContext).mockResolvedValue("Branch: main\nStatus: clean");
-  vi.mocked(getPermissionMode).mockReturnValue("default");
-});
-
-// ============================================================================
-// buildSystemPrompt
-// ============================================================================
-
-describe("buildSystemPrompt", () => {
-  it("includes identity section", async () => {
-    const prompt = await buildSystemPrompt(false);
-    expect(prompt).toContain("whale code");
-    expect(prompt).toContain("interactive CLI agent");
-  });
-  it("includes environment section with platform and date", async () => {
-    const prompt = await buildSystemPrompt(false);
-    expect(prompt).toContain("# Environment");
-    expect(prompt).toContain(`Platform: ${process.platform}`);
-    expect(prompt).toContain("Date:");
-  });
-  it("includes directory listing", async () => {
-    const prompt = await buildSystemPrompt(false);
-    expect(prompt).toContain("src/");
-    expect(prompt).toContain("package.json");
-  });
-  it("excludes hidden directories from listing", async () => {
-    const prompt = await buildSystemPrompt(false);
-    expect(prompt).not.toContain(".git/");
-  });
-  it("includes git context", async () => {
-    const prompt = await buildSystemPrompt(false);
-    expect(prompt).toContain("Branch: main");
-    expect(prompt).toContain("Status: clean");
-  });
-  it("includes doing tasks section", async () => {
-    const prompt = await buildSystemPrompt(false);
-    expect(prompt).toContain("# Doing tasks");
-    expect(prompt).toContain("ALWAYS read relevant code");
-  });
-  it("includes coding workflow section", async () => {
-    const prompt = await buildSystemPrompt(false);
-    expect(prompt).toContain("# Mandatory coding workflow");
-    expect(prompt).toContain("Read");
-    expect(prompt).toContain("Verify");
-  });
-  it("includes tool use section", async () => {
-    const prompt = await buildSystemPrompt(false);
-    expect(prompt).toContain("# Using tools");
-    expect(prompt).toContain("read_file");
-  });
-  it("includes server tools section when hasServerTools is true", async () => {
-    const prompt = await buildSystemPrompt(true);
-    expect(prompt).toContain("## Server tools");
-    expect(prompt).toContain("analytics");
-  });
-  it("excludes server tools section when hasServerTools is false", async () => {
-    const prompt = await buildSystemPrompt(false);
-    expect(prompt).not.toContain("## Server tools");
-  });
-  it("includes active store in server tools section", async () => {
-    vi.mocked(loadConfig).mockReturnValue({
-      store_name: "My Test Store",
-      store_id: "s123"
-    });
-    const prompt = await buildSystemPrompt(true);
-    expect(prompt).toContain("My Test Store");
-  });
-  it("includes store in environment section", async () => {
-    vi.mocked(loadConfig).mockReturnValue({
-      store_name: "Demo Store"
-    });
-    const prompt = await buildSystemPrompt(false);
-    expect(prompt).toContain("Active store: Demo Store");
-  });
-  it("includes tone and style section", async () => {
-    const prompt = await buildSystemPrompt(false);
-    expect(prompt).toContain("# Tone and style");
-    expect(prompt).toContain("NEVER use emojis");
-  });
-
-  // Permission modes
-  it("includes plan mode section when permission mode is plan", async () => {
-    vi.mocked(getPermissionMode).mockReturnValue("plan");
-    const prompt = await buildSystemPrompt(false);
-    expect(prompt).toContain("# Mode: Plan");
-    expect(prompt).toContain("read-only");
-  });
-  it("includes yolo mode section when permission mode is yolo", async () => {
-    vi.mocked(getPermissionMode).mockReturnValue("yolo");
-    const prompt = await buildSystemPrompt(false);
-    expect(prompt).toContain("# Mode: Yolo");
-    expect(prompt).toContain("without confirmation");
-  });
-  it("omits mode section for default permission mode", async () => {
-    vi.mocked(getPermissionMode).mockReturnValue("default");
-    const prompt = await buildSystemPrompt(false);
-    expect(prompt).not.toContain("# Mode:");
-  });
-
-  // Effort levels
-  it("includes low effort section", async () => {
-    const prompt = await buildSystemPrompt(false, "low");
-    expect(prompt).toContain("# Effort: Low");
-    expect(prompt).toContain("concise and direct");
-  });
-  it("includes high effort section", async () => {
-    const prompt = await buildSystemPrompt(false, "high");
-    expect(prompt).toContain("# Effort: High");
-    expect(prompt).toContain("thorough and exhaustive");
-  });
-  it("omits effort section for medium effort", async () => {
-    const prompt = await buildSystemPrompt(false, "medium");
-    expect(prompt).not.toContain("# Effort:");
-  });
-
-  // Memory
-  it("includes memory section when memory exists", async () => {
-    vi.mocked(loadMemory).mockReturnValue("- Project uses TypeScript\n- Tests use vitest");
-    const prompt = await buildSystemPrompt(false);
-    expect(prompt).toContain("# Memory (persistent across sessions)");
-    expect(prompt).toContain("Project uses TypeScript");
-  });
-  it("omits memory section when memory is empty", async () => {
-    vi.mocked(loadMemory).mockReturnValue("");
-    const prompt = await buildSystemPrompt(false);
-    expect(prompt).not.toContain("# Memory");
-  });
-
-  // CLAUDE.md
-  it("includes CLAUDE.md section when found", async () => {
-    vi.mocked(loadClaudeMd).mockReturnValue({
-      content: "Always run tests before committing",
-      path: "/project/CLAUDE.md"
-    });
-    const prompt = await buildSystemPrompt(false);
-    expect(prompt).toContain("# Project Instructions");
-    expect(prompt).toContain("Always run tests before committing");
-    expect(prompt).toContain("/project/CLAUDE.md");
-  });
-  it("omits CLAUDE.md section when not found", async () => {
-    vi.mocked(loadClaudeMd).mockReturnValue(null);
-    const prompt = await buildSystemPrompt(false);
-    expect(prompt).not.toContain("# Project Instructions");
-  });
-  it("handles git context failure gracefully", async () => {
-    vi.mocked(gatherGitContext).mockResolvedValue("");
-    const prompt = await buildSystemPrompt(false);
-    expect(prompt).toContain("# Environment");
-    // Should not crash
-  });
-});