whale-code 6.5.10 → 6.6.0

package/dist/cli/services/__tests__/edge-cases-compaction.test.js

@@ -1,131 +0,0 @@
-/**
- * Edge-case tests for trimGeminiContext from api-client.ts.
- */
-
-import { describe, it, expect } from "vitest";
-import { trimGeminiContext } from "../../../shared/api-client.js";
-describe("trimGeminiContext — edge cases", () => {
-  it("returns same array reference when below threshold", () => {
-    const messages = [{
-      role: "user",
-      content: "Hello"
-    }, {
-      role: "assistant",
-      content: "Hi"
-    }];
-    const result = trimGeminiContext(messages, 100_000);
-    expect(result).toBe(messages);
-  });
-  it("returns same array reference when above threshold but too few tool results", () => {
-    const messages = [{
-      role: "user",
-      content: [{
-        type: "tool_result",
-        content: "result 1"
-      }, {
-        type: "tool_result",
-        content: "result 2"
-      }, {
-        type: "tool_result",
-        content: "result 3"
-      }]
-    }];
-    const result = trimGeminiContext(messages, 1_000_000);
-    expect(result).toBe(messages);
-  });
-  it("trims oldest tool results when above threshold with enough results", () => {
-    const messages = [];
-    for (let i = 0; i < 10; i++) {
-      messages.push({
-        role: "user",
-        content: [{
-          type: "tool_result",
-          content: `Result ${i}: ${"data".repeat(100)}`
-        }]
-      });
-      messages.push({
-        role: "assistant",
-        content: `ACK ${i}`
-      });
-    }
-    const result = trimGeminiContext(messages, 1_000_000, 950_000, 5);
-    for (let i = 0; i < 5; i++) {
-      const block = result[i * 2].content[0];
-      expect(block.content).toBe("[trimmed]");
-    }
-    for (let i = 5; i < 10; i++) {
-      const block = result[i * 2].content[0];
-      expect(block.content).toContain("Result");
-    }
-  });
-  it("passes through messages with non-array content safely", () => {
-    const messages = [{
-      role: "user",
-      content: "String content"
-    }, {
-      role: "user",
-      content: [{
-        type: "tool_result",
-        content: "result 1"
-      }, {
-        type: "tool_result",
-        content: "result 2"
-      }, {
-        type: "tool_result",
-        content: "result 3"
-      }, {
-        type: "tool_result",
-        content: "result 4"
-      }, {
-        type: "tool_result",
-        content: "result 5"
-      }, {
-        type: "tool_result",
-        content: "result 6"
-      }, {
-        type: "tool_result",
-        content: "result 7"
-      }]
-    }, {
-      role: "assistant",
-      content: "Response"
-    }];
-    const result = trimGeminiContext(messages, 1_000_000);
-    expect(result[0].content).toBe("String content");
-    expect(result[2].content).toBe("Response");
-  });
-  it("handles tool results with array content (nested blocks)", () => {
-    const messages = [];
-    for (let i = 0; i < 8; i++) {
-      messages.push({
-        role: "user",
-        content: [{
-          type: "tool_result",
-          content: [{
-            type: "text",
-            text: `Nested result ${i}`
-          }]
-        }]
-      });
-      messages.push({
-        role: "assistant",
-        content: `ACK ${i}`
-      });
-    }
-    const result = trimGeminiContext(messages, 1_000_000, 950_000, 5);
-    for (let i = 0; i < 3; i++) {
-      const block = result[i * 2].content[0];
-      expect(block.content).toEqual([{
-        type: "text",
-        text: "[trimmed]"
-      }]);
-    }
-    for (let i = 3; i < 8; i++) {
-      const block = result[i * 2].content[0];
-      expect(block.content).toEqual([{
-        type: "text",
-        text: `Nested result ${i}`
-      }]);
-    }
-  });
-});

package/dist/cli/services/__tests__/edge-cases-paths.test.js

@@ -1,86 +0,0 @@
-/**
- * Edge-case tests for paths.ts — ensureDataDir migration logic.
- */
-
-import { describe, it, expect, vi, beforeEach } from "vitest";
-describe("ensureDataDir — edge cases", () => {
-  vi.mock("fs", async () => {
-    return {
-      existsSync: vi.fn(),
-      mkdirSync: vi.fn(),
-      cpSync: vi.fn()
-    };
-  });
-  vi.mock("os", () => ({
-    homedir: () => "/home/testuser"
-  }));
-  let ensureDataDir;
-  let fs;
-  beforeEach(async () => {
-    vi.resetModules();
-    vi.clearAllMocks();
-    fs = await import("fs");
-    const pathsModule = await import("../paths.js");
-    ensureDataDir = pathsModule.ensureDataDir;
-  });
-  it("creates ~/.whale on fresh install (no legacy, no whale dir)", () => {
-    const existsSyncMock = vi.mocked(fs.existsSync);
-    const mkdirSyncMock = vi.mocked(fs.mkdirSync);
-    existsSyncMock.mockReturnValue(false);
-    ensureDataDir();
-    expect(mkdirSyncMock).toHaveBeenCalledWith(expect.stringContaining(".whale"), {
-      recursive: true
-    });
-  });
-  it("migrates ~/.swagmanager to ~/.whale when legacy exists", () => {
-    const existsSyncMock = vi.mocked(fs.existsSync);
-    const cpSyncMock = vi.mocked(fs.cpSync);
-    existsSyncMock.mockImplementation(path => {
-      if (String(path).includes(".whale")) return false;
-      if (String(path).includes(".swagmanager")) return true;
-      return false;
-    });
-    ensureDataDir();
-    expect(cpSyncMock).toHaveBeenCalledWith(expect.stringContaining(".swagmanager"), expect.stringContaining(".whale"), {
-      recursive: true
-    });
-  });
-  it("is a no-op when ~/.whale already exists", () => {
-    const existsSyncMock = vi.mocked(fs.existsSync);
-    const mkdirSyncMock = vi.mocked(fs.mkdirSync);
-    const cpSyncMock = vi.mocked(fs.cpSync);
-    existsSyncMock.mockImplementation(path => {
-      if (String(path).includes(".whale")) return true;
-      return false;
-    });
-    ensureDataDir();
-    expect(mkdirSyncMock).not.toHaveBeenCalled();
-    expect(cpSyncMock).not.toHaveBeenCalled();
-  });
-  it("falls back to mkdir when cpSync throws during migration", () => {
-    const existsSyncMock = vi.mocked(fs.existsSync);
-    const cpSyncMock = vi.mocked(fs.cpSync);
-    const mkdirSyncMock = vi.mocked(fs.mkdirSync);
-    existsSyncMock.mockImplementation(path => {
-      if (String(path).includes(".whale")) return false;
-      if (String(path).includes(".swagmanager")) return true;
-      return false;
-    });
-    cpSyncMock.mockImplementation(() => {
-      throw new Error("EACCES: permission denied");
-    });
-    ensureDataDir();
-    expect(mkdirSyncMock).toHaveBeenCalledWith(expect.stringContaining(".whale"), {
-      recursive: true
-    });
-  });
-  it("only runs migration once (migrationDone flag)", () => {
-    const existsSyncMock = vi.mocked(fs.existsSync);
-    const mkdirSyncMock = vi.mocked(fs.mkdirSync);
-    existsSyncMock.mockReturnValue(false);
-    ensureDataDir();
-    ensureDataDir();
-    ensureDataDir();
-    expect(mkdirSyncMock).toHaveBeenCalledTimes(1);
-  });
-});

package/dist/cli/services/__tests__/error-logger-messages.test.js

@@ -1,81 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-
-// ============================================================================
-// Mocks — must be declared before importing the module under test
-// ============================================================================
-
-const mockFetch = vi.fn().mockResolvedValue({
-  ok: true,
-  text: vi.fn().mockResolvedValue("")
-});
-vi.stubGlobal("fetch", mockFetch);
-vi.mock("module", () => ({
-  createRequire: () => () => ({
-    version: "1.0.0-test"
-  })
-}));
-import { initErrorLogger, setErrorLoggerUser, captureMessage } from "../error-logger.js";
-
-// ============================================================================
-// Helpers
-// ============================================================================
-
-function getPostedEvent(callIndex = 0) {
-  const call = mockFetch.mock.calls[callIndex];
-  const body = call[1]?.body;
-  return JSON.parse(body);
-}
-
-// ============================================================================
-// captureMessage (split from error-logger.test.ts)
-// ============================================================================
-
-describe("captureMessage", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockFetch.mockResolvedValue({
-      ok: true,
-      text: vi.fn().mockResolvedValue("")
-    });
-    process.env.CLICKHOUSE_HOST = "test.clickhouse.cloud";
-    process.env.CLICKHOUSE_USER = "default";
-    process.env.CLICKHOUSE_PASSWORD = "test-password";
-    initErrorLogger({
-      serviceName: "msg-test"
-    });
-    setErrorLoggerUser(undefined, undefined, undefined);
-  });
-  afterEach(() => {
-    delete process.env.CLICKHOUSE_HOST;
-    delete process.env.CLICKHOUSE_USER;
-    delete process.env.CLICKHOUSE_PASSWORD;
-  });
-  it("captures a message with default severity info", async () => {
-    captureMessage("hello world");
-    await vi.waitFor(() => {
-      const event = getPostedEvent();
-      expect(event.error_type).toBe("Message");
-      expect(event.error_message).toBe("hello world");
-      expect(event.severity).toBe("info");
-    });
-  });
-  it("captures a message with custom severity", async () => {
-    captureMessage("critical thing", "fatal");
-    await vi.waitFor(() => {
-      const event = getPostedEvent();
-      expect(event.severity).toBe("fatal");
-    });
-  });
-  it("captures a message with extra data", async () => {
-    captureMessage("extra test", "info", {
-      key: "value"
-    });
-    await vi.waitFor(() => {
-      const event = getPostedEvent();
-      const extra = JSON.parse(event.extra);
-      expect(extra).toEqual({
-        key: "value"
-      });
-    });
-  });
-});

package/dist/cli/services/__tests__/error-logger-transport.test.js

@@ -1,119 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-
-// ============================================================================
-// Mocks — must be declared before importing the module under test
-// ============================================================================
-
-const mockFetch = vi.fn().mockResolvedValue({
-  ok: true,
-  text: vi.fn().mockResolvedValue("")
-});
-vi.stubGlobal("fetch", mockFetch);
-vi.mock("module", () => ({
-  createRequire: () => () => ({
-    version: "1.0.0-test"
-  })
-}));
-import { initErrorLogger, setErrorLoggerUser, captureError } from "../error-logger.js";
-
-// ============================================================================
-// Helpers
-// ============================================================================
-
-function getPostedEvent(callIndex = 0) {
-  const call = mockFetch.mock.calls[callIndex];
-  const body = call[1]?.body;
-  return JSON.parse(body);
-}
-function getPostedUrl(callIndex = 0) {
-  return mockFetch.mock.calls[callIndex][0];
-}
-
-// ============================================================================
-// captureError — transport, auth, edge cases
-// ============================================================================
-
-describe("captureError — transport & edge cases", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockFetch.mockResolvedValue({
-      ok: true,
-      text: vi.fn().mockResolvedValue("")
-    });
-    initErrorLogger({
-      serviceName: "test-svc"
-    });
-    process.env.CLICKHOUSE_HOST = "test.clickhouse.cloud";
-    process.env.CLICKHOUSE_USER = "default";
-    process.env.CLICKHOUSE_PASSWORD = "test-password";
-    setErrorLoggerUser(undefined, undefined, undefined);
-  });
-  afterEach(() => {
-    delete process.env.CLICKHOUSE_HOST;
-    delete process.env.CLICKHOUSE_USER;
-    delete process.env.CLICKHOUSE_PASSWORD;
-  });
-  it("passes severity, tags, and extra", async () => {
-    captureError({
-      errorMessage: "custom",
-      severity: "warning",
-      tags: {
-        env: "test"
-      },
-      extra: {
-        detail: "info"
-      }
-    });
-    await vi.waitFor(() => {
-      const event = getPostedEvent();
-      expect(event.severity).toBe("warning");
-      const tags = JSON.parse(event.tags);
-      const extra = JSON.parse(event.extra);
-      expect(tags).toEqual({
-        env: "test"
-      });
-      expect(extra).toEqual({
-        detail: "info"
-      });
-    });
-  });
-  it("passes traceId and spanId", async () => {
-    captureError({
-      errorMessage: "traced",
-      traceId: "trace-abc",
-      spanId: "span-xyz"
-    });
-    await vi.waitFor(() => {
-      const event = getPostedEvent();
-      expect(event.trace_id).toBe("trace-abc");
-      expect(event.span_id).toBe("span-xyz");
-    });
-  });
-  it("does not throw on fetch failure", async () => {
-    mockFetch.mockRejectedValueOnce(new Error("network fail"));
-    expect(() => captureError({
-      errorMessage: "fail"
-    })).not.toThrow();
-  });
-  it("sends correct Authorization header", async () => {
-    captureError({
-      errorMessage: "auth test"
-    });
-    await vi.waitFor(() => {
-      expect(mockFetch).toHaveBeenCalledTimes(1);
-      const call = mockFetch.mock.calls[0];
-      const headers = call[1]?.headers;
-      const expectedCredentials = Buffer.from("default:test-password").toString("base64");
-      expect(headers.Authorization).toBe(`Basic ${expectedCredentials}`);
-      expect(headers["Content-Type"]).toBe("application/json");
-    });
-  });
-  it("does not call fetch when CLICKHOUSE_PASSWORD is missing", async () => {
-    delete process.env.CLICKHOUSE_PASSWORD;
-    captureError({
-      errorMessage: "no password"
-    });
-    await new Promise(r => setTimeout(r, 50));
-    expect(mockFetch).not.toHaveBeenCalled();
-  });
-});

package/dist/cli/services/__tests__/error-logger.test.js

@@ -1,264 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-
-// ============================================================================
-// Mocks — must be declared before importing the module under test
-// ============================================================================
-
-const mockFetch = vi.fn().mockResolvedValue({
-  ok: true,
-  text: vi.fn().mockResolvedValue("")
-});
-vi.stubGlobal("fetch", mockFetch);
-vi.mock("module", () => ({
-  createRequire: () => () => ({
-    version: "1.0.0-test"
-  })
-}));
-import { initErrorLogger, setErrorLoggerUser, addBreadcrumb, captureError } from "../error-logger.js";
-
-// ============================================================================
-// Helpers
-// ============================================================================
-
-/**
- * Extract the parsed event body from the most recent fetch() call.
- * The implementation calls fetch(url, { body: JSON.stringify(event) }).
- */
-function getPostedEvent(callIndex = 0) {
-  const call = mockFetch.mock.calls[callIndex];
-  const body = call[1]?.body;
-  return JSON.parse(body);
-}
-
-/**
- * Extract the URL from a fetch() call.
- */
-function getPostedUrl(callIndex = 0) {
-  return mockFetch.mock.calls[callIndex][0];
-}
-
-// ============================================================================
-// initErrorLogger
-// ============================================================================
-
-describe("initErrorLogger", () => {
-  it("accepts config with serviceName", () => {
-    expect(() => initErrorLogger({
-      serviceName: "test-service"
-    })).not.toThrow();
-  });
-  it("merges config overrides", () => {
-    initErrorLogger({
-      serviceName: "my-svc",
-      environment: "staging",
-      maxBreadcrumbs: 10
-    });
-    // Verify it doesn't throw — internal state tested by capture behavior
-  });
-  it("uses development env when NODE_ENV is development", () => {
-    const orig = process.env.NODE_ENV;
-    process.env.NODE_ENV = "development";
-    initErrorLogger({
-      serviceName: "dev-svc"
-    });
-    process.env.NODE_ENV = orig;
-  });
-});
-
-// ============================================================================
-// setErrorLoggerUser
-// ============================================================================
-
-describe("setErrorLoggerUser", () => {
-  it("sets user context without error", () => {
-    expect(() => setErrorLoggerUser("user-1", "test@example.com", "store-1")).not.toThrow();
-  });
-  it("handles undefined values", () => {
-    expect(() => setErrorLoggerUser(undefined, undefined, undefined)).not.toThrow();
-  });
-});
-
-// ============================================================================
-// addBreadcrumb
-// ============================================================================
-
-describe("addBreadcrumb", () => {
-  beforeEach(() => {
-    // Reset config with fresh breadcrumbs
-    initErrorLogger({
-      serviceName: "test",
-      maxBreadcrumbs: 5
-    });
-  });
-  it("adds a breadcrumb without error", () => {
-    expect(() => addBreadcrumb("navigation", "clicked button")).not.toThrow();
-  });
-  it("accepts custom level and data", () => {
-    expect(() => addBreadcrumb("http", "GET /api", "warning", {
-      status: "500"
-    })).not.toThrow();
-  });
-  it("defaults level to info", () => {
-    addBreadcrumb("test", "msg");
-    // No assertion needed — just coverage; value is verified in capture
-  });
-  it("trims breadcrumbs to maxBreadcrumbs", () => {
-    for (let i = 0; i < 10; i++) {
-      addBreadcrumb("test", `breadcrumb ${i}`);
-    }
-    // Internal state is capped at 5 — verified via capture
-  });
-});
-
-// ============================================================================
-// captureError (fire-and-forget)
-// ============================================================================
-
-describe("captureError", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockFetch.mockResolvedValue({
-      ok: true,
-      text: vi.fn().mockResolvedValue("")
-    });
-    initErrorLogger({
-      serviceName: "test-svc"
-    });
-    // Set ClickHouse env vars so _captureError proceeds
-    process.env.CLICKHOUSE_HOST = "test.clickhouse.cloud";
-    process.env.CLICKHOUSE_USER = "default";
-    process.env.CLICKHOUSE_PASSWORD = "test-password";
-    // Clear user context between tests
-    setErrorLoggerUser(undefined, undefined, undefined);
-  });
-  afterEach(() => {
-    delete process.env.CLICKHOUSE_HOST;
-    delete process.env.CLICKHOUSE_USER;
-    delete process.env.CLICKHOUSE_PASSWORD;
-  });
-  it("does not throw when called with an Error object", () => {
-    expect(() => captureError({
-      error: new Error("test error")
-    })).not.toThrow();
-  });
-  it("does not throw when called with errorType/errorMessage", () => {
-    expect(() => captureError({
-      errorType: "CustomError",
-      errorMessage: "oh no"
-    })).not.toThrow();
-  });
-  it("creates client and caches it — fetch called with correct ClickHouse URL", async () => {
-    captureError({
-      errorMessage: "test"
-    });
-    await vi.waitFor(() => {
-      expect(mockFetch).toHaveBeenCalledTimes(1);
-      const url = getPostedUrl();
-      expect(url).toContain("https://test.clickhouse.cloud:8443/");
-      expect(url).toContain(encodeURIComponent("INSERT INTO error_events FORMAT JSONEachRow"));
-    });
-  });
-  it("inserts event into error_events table", async () => {
-    captureError({
-      error: new Error("boom")
-    });
-    await vi.waitFor(() => {
-      expect(mockFetch).toHaveBeenCalledTimes(1);
-      const event = getPostedEvent();
-      expect(event.error_type).toBe("Error");
-      expect(event.error_message).toBe("boom");
-      expect(event.severity).toBe("error");
-      expect(event.service_name).toBe("test-svc");
-      expect(event.platform).toBe("typescript");
-    });
-  });
-  it("includes fingerprint as sha256 hex", async () => {
-    captureError({
-      errorType: "TestError",
-      errorMessage: "test msg"
-    });
-    await vi.waitFor(() => {
-      const event = getPostedEvent();
-      expect(event.fingerprint).toMatch(/^[a-f0-9]{64}$/);
-    });
-  });
-  it("includes device_info and runtime_info", async () => {
-    captureError({
-      errorMessage: "test"
-    });
-    await vi.waitFor(() => {
-      const event = getPostedEvent();
-      // The implementation JSON.stringifies these fields
-      const deviceInfo = JSON.parse(event.device_info);
-      const runtimeInfo = JSON.parse(event.runtime_info);
-      expect(deviceInfo).toHaveProperty("os");
-      expect(deviceInfo).toHaveProperty("arch");
-      expect(runtimeInfo).toHaveProperty("node_version");
-    });
-  });
-  it("reuses cached client on subsequent calls", async () => {
-    captureError({
-      errorMessage: "first"
-    });
-    await vi.waitFor(() => {
-      expect(mockFetch).toHaveBeenCalledTimes(1);
-    });
-    vi.clearAllMocks();
-    mockFetch.mockResolvedValue({
-      ok: true,
-      text: vi.fn().mockResolvedValue("")
-    });
-    captureError({
-      errorMessage: "second"
-    });
-    await vi.waitFor(() => {
-      expect(mockFetch).toHaveBeenCalledTimes(1);
-      const event = getPostedEvent();
-      expect(event.error_message).toBe("second");
-      // fetch is called without needing to re-read env — the env vars
-      // are read on each call (no cached client), but fetch still works
-      const url = getPostedUrl();
-      expect(url).toContain("test.clickhouse.cloud");
-    });
-  });
-  it("includes user context when set", async () => {
-    setErrorLoggerUser("usr-1", "user@test.com", "store-1");
-    captureError({
-      errorMessage: "with user"
-    });
-    await vi.waitFor(() => {
-      const event = getPostedEvent();
-      expect(event.user_id).toBe("usr-1");
-      expect(event.user_email).toBe("user@test.com");
-      expect(event.store_id).toBe("store-1");
-    });
-  });
-  it("includes breadcrumbs in the event", async () => {
-    addBreadcrumb("nav", "page load");
-    addBreadcrumb("click", "button pressed");
-    captureError({
-      errorMessage: "crumbs test"
-    });
-    await vi.waitFor(() => {
-      const event = getPostedEvent();
-      // breadcrumbs is JSON-stringified in the POST body
-      const crumbs = JSON.parse(event.breadcrumbs);
-      expect(crumbs).toBeInstanceOf(Array);
-      expect(crumbs.length).toBeGreaterThanOrEqual(2);
-    });
-  });
-  it("includes stack_frames from Error stack", async () => {
-    const err = new Error("stack test");
-    captureError({
-      error: err
-    });
-    await vi.waitFor(() => {
-      const event = getPostedEvent();
-      expect(event.stack_trace).toBeTruthy();
-      // stack_trace is sent as a plain string in the implementation
-      // (stack_frames is not included in the ClickHouse event — only stack_trace is)
-      expect(typeof event.stack_trace).toBe("string");
-      expect(event.stack_trace).toContain("stack test");
-    });
-  });
-});