whale-code 6.5.10 → 6.6.0

package/dist/cli/services/model-router.test.js

@@ -1,245 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { classifyAndRoute, isAutoModel, resolveAutoModel } from "./model-router.js";
-
-// ============================================================================
-// Mock fetch — callServerProxy uses global fetch internally
-// ============================================================================
-
-let originalFetch;
-beforeEach(() => {
-  originalFetch = globalThis.fetch;
-});
-afterEach(() => {
-  globalThis.fetch = originalFetch;
-});
-
-/**
- * Build a mock SSE stream that returns a single text response.
- */
-function mockSSEResponse(text) {
-  const encoder = new TextEncoder();
-  const lines = [`data: ${JSON.stringify({
-    type: "message_start",
-    message: {
-      usage: {
-        input_tokens: 50
-      }
-    }
-  })}`, `data: ${JSON.stringify({
-    type: "content_block_start",
-    index: 0,
-    content_block: {
-      type: "text",
-      text: ""
-    }
-  })}`, `data: ${JSON.stringify({
-    type: "content_block_delta",
-    index: 0,
-    delta: {
-      type: "text_delta",
-      text
-    }
-  })}`, `data: ${JSON.stringify({
-    type: "content_block_stop",
-    index: 0
-  })}`, `data: ${JSON.stringify({
-    type: "message_delta",
-    delta: {
-      stop_reason: "end_turn"
-    },
-    usage: {
-      output_tokens: 20
-    }
-  })}`, "data: [DONE]"];
-  return new ReadableStream({
-    start(controller) {
-      for (const line of lines) {
-        controller.enqueue(encoder.encode(line + "\n\n"));
-      }
-      controller.close();
-    }
-  });
-}
-function mockFetch(classifierResponse) {
-  globalThis.fetch = vi.fn(async () => {
-    return new Response(mockSSEResponse(classifierResponse), {
-      status: 200
-    });
-  });
-}
-
-// ============================================================================
-// isAutoModel
-// ============================================================================
-
-describe("isAutoModel", () => {
-  it('returns true for "auto"', () => {
-    expect(isAutoModel("auto")).toBe(true);
-  });
-  it('returns false for "opus"', () => {
-    expect(isAutoModel("opus")).toBe(false);
-  });
-  it('returns false for "sonnet"', () => {
-    expect(isAutoModel("sonnet")).toBe(false);
-  });
-  it('returns false for "haiku"', () => {
-    expect(isAutoModel("haiku")).toBe(false);
-  });
-  it("returns false for empty string", () => {
-    expect(isAutoModel("")).toBe(false);
-  });
-  it('returns false for "Auto" (case sensitive)', () => {
-    expect(isAutoModel("Auto")).toBe(false);
-  });
-});
-
-// ============================================================================
-// classifyAndRoute
-// ============================================================================
-
-describe("classifyAndRoute", () => {
-  const serverUrl = "https://whale-agent.fly.dev";
-  const authToken = "test-token";
-  it("routes simple message to haiku", async () => {
-    mockFetch(JSON.stringify({
-      model: "haiku",
-      reasoning: "Simple status check",
-      confidence: 0.9
-    }));
-    const result = await classifyAndRoute("what time is it?", serverUrl, authToken);
-    expect(result.model).toBe("haiku");
-    expect(result.confidence).toBe(0.9);
-    expect(result.reasoning).toBe("Simple status check");
-  });
-  it("routes complex message to opus", async () => {
-    mockFetch(JSON.stringify({
-      model: "opus",
-      reasoning: "Complex multi-file architecture refactor",
-      confidence: 0.95
-    }));
-    const result = await classifyAndRoute("Refactor the entire authentication system to use OAuth2 with PKCE flow, update all 12 affected files, and add comprehensive test coverage", serverUrl, authToken);
-    expect(result.model).toBe("opus");
-    expect(result.confidence).toBe(0.95);
-  });
-  it("routes medium message to sonnet", async () => {
-    mockFetch(JSON.stringify({
-      model: "sonnet",
-      reasoning: "Multi-step debugging task",
-      confidence: 0.85
-    }));
-    const result = await classifyAndRoute("Fix the bug in the login form validation and update the tests", serverUrl, authToken);
-    expect(result.model).toBe("sonnet");
-    expect(result.confidence).toBe(0.85);
-  });
-  it("defaults to sonnet on malformed classifier response", async () => {
-    mockFetch("This is not valid JSON at all");
-    const result = await classifyAndRoute("hello", serverUrl, authToken);
-    expect(result.model).toBe("sonnet");
-    expect(result.confidence).toBe(0.5);
-    expect(result.reasoning).toBe("default fallback");
-  });
-  it("defaults to sonnet when confidence is below 0.3", async () => {
-    mockFetch(JSON.stringify({
-      model: "haiku",
-      reasoning: "Uncertain",
-      confidence: 0.2
-    }));
-    const result = await classifyAndRoute("do something", serverUrl, authToken);
-    expect(result.model).toBe("sonnet");
-    expect(result.confidence).toBe(0.2);
-  });
-  it("defaults to sonnet on invalid model name in response", async () => {
-    mockFetch(JSON.stringify({
-      model: "gpt-5",
-      reasoning: "Wrong model name",
-      confidence: 0.9
-    }));
-    const result = await classifyAndRoute("hello", serverUrl, authToken);
-    expect(result.model).toBe("sonnet");
-  });
-  it("defaults to sonnet on network error", async () => {
-    globalThis.fetch = vi.fn(async () => {
-      throw new Error("Network failure");
-    });
-    const result = await classifyAndRoute("hello", serverUrl, authToken);
-    expect(result.model).toBe("sonnet");
-    expect(result.reasoning).toBe("default fallback");
-  }, 30_000);
-  it("defaults to sonnet on HTTP error response", async () => {
-    globalThis.fetch = vi.fn(async () => {
-      return new Response("Bad Request", {
-        status: 400
-      });
-    });
-    const result = await classifyAndRoute("hello", serverUrl, authToken);
-    expect(result.model).toBe("sonnet");
-  });
-  it("handles JSON embedded in markdown code fences", async () => {
-    mockFetch('```json\n{"model": "opus", "reasoning": "Complex task", "confidence": 0.88}\n```');
-    const result = await classifyAndRoute("rewrite the entire codebase", serverUrl, authToken);
-    expect(result.model).toBe("opus");
-    expect(result.confidence).toBe(0.88);
-  });
-  it("handles missing reasoning field gracefully", async () => {
-    mockFetch(JSON.stringify({
-      model: "haiku",
-      confidence: 0.7
-    }));
-    const result = await classifyAndRoute("ls", serverUrl, authToken);
-    expect(result.model).toBe("haiku");
-    expect(result.reasoning).toBe("");
-  });
-  it("handles missing confidence field gracefully (falls back to sonnet)", async () => {
-    mockFetch(JSON.stringify({
-      model: "haiku",
-      reasoning: "Simple task"
-    }));
-
-    // confidence defaults to 0, which is < 0.3, so falls back to sonnet
-    const result = await classifyAndRoute("ls", serverUrl, authToken);
-    expect(result.model).toBe("sonnet");
-  });
-});
-
-// ============================================================================
-// resolveAutoModel
-// ============================================================================
-
-describe("resolveAutoModel", () => {
-  const serverUrl = "https://whale-agent.fly.dev";
-  const authToken = "test-token";
-  it("returns haiku model ID for simple requests", async () => {
-    mockFetch(JSON.stringify({
-      model: "haiku",
-      reasoning: "Simple",
-      confidence: 0.9
-    }));
-    const modelId = await resolveAutoModel("what is 2+2?", serverUrl, authToken);
-    expect(modelId).toBe("claude-haiku-4-5-20251001");
-  });
-  it("returns sonnet model ID for medium requests", async () => {
-    mockFetch(JSON.stringify({
-      model: "sonnet",
-      reasoning: "Medium complexity",
-      confidence: 0.8
-    }));
-    const modelId = await resolveAutoModel("fix the bug in auth", serverUrl, authToken);
-    expect(modelId).toBe("claude-sonnet-4-6");
-  });
-  it("returns opus model ID for complex requests", async () => {
-    mockFetch(JSON.stringify({
-      model: "opus",
-      reasoning: "Complex architecture",
-      confidence: 0.95
-    }));
-    const modelId = await resolveAutoModel("redesign the entire system", serverUrl, authToken);
-    expect(modelId).toBe("claude-opus-4-6");
-  });
-  it("returns sonnet model ID on classifier failure", async () => {
-    globalThis.fetch = vi.fn(async () => {
-      throw new Error("Connection refused");
-    });
-    const modelId = await resolveAutoModel("hello", serverUrl, authToken);
-    expect(modelId).toBe("claude-sonnet-4-6");
-  });
-});

package/dist/cli/services/rewind-rewindTo.test.js

@@ -1,202 +0,0 @@
-/**
- * Tests for RewindManager — rewindTo and revertFilesFrom
- */
-
-import { describe, it, expect, beforeEach, vi, afterEach } from "vitest";
-import { RewindManager } from "./rewind.js";
-import { existsSync, readFileSync, writeFileSync, unlinkSync } from "fs";
-
-// Mock fs operations
-vi.mock("fs", () => ({
-  existsSync: vi.fn(),
-  readFileSync: vi.fn(),
-  writeFileSync: vi.fn(),
-  unlinkSync: vi.fn()
-}));
-const mockExistsSync = existsSync;
-const mockReadFileSync = readFileSync;
-const mockWriteFileSync = writeFileSync;
-const mockUnlinkSync = unlinkSync;
-describe("RewindManager", () => {
-  let manager;
-  beforeEach(() => {
-    manager = new RewindManager();
-    vi.clearAllMocks();
-  });
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-  describe("rewindTo", () => {
-    it("should return error for invalid index", () => {
-      const result = manager.rewindTo(5);
-      expect(result.errors).toHaveLength(1);
-      expect(result.errors[0]).toContain("Invalid checkpoint index");
-    });
-    it("should truncate checkpoints and return correct messageCount", () => {
-      manager.addCheckpoint(0, 2, "Turn 1", []);
-      manager.addCheckpoint(1, 5, "Turn 2", []);
-      manager.addCheckpoint(2, 8, "Turn 3", []);
-      const result = manager.rewindTo(0);
-      expect(result.messageCount).toBe(2);
-      expect(manager.getCheckpoints()).toHaveLength(1);
-    });
-    it("should restore edited files from backup", () => {
-      mockExistsSync.mockReturnValue(true);
-      mockReadFileSync.mockReturnValue(Buffer.from("original content"));
-      manager.addCheckpoint(0, 2, "Turn 1", []);
-      manager.addCheckpoint(1, 5, "Turn 2", [{
-        filePath: "/src/foo.ts",
-        backupPath: "/backup/123-foo.ts",
-        operation: "edit",
-        isNewFile: false
-      }]);
-      const result = manager.rewindTo(0);
-      expect(result.filesReverted).toContain("/src/foo.ts");
-      expect(mockReadFileSync).toHaveBeenCalledWith("/backup/123-foo.ts");
-      expect(mockWriteFileSync).toHaveBeenCalledWith("/src/foo.ts", Buffer.from("original content"));
-    });
-    it("should delete files that were created during reverted turns", () => {
-      mockExistsSync.mockReturnValue(true);
-      manager.addCheckpoint(0, 2, "Turn 1", []);
-      manager.addCheckpoint(1, 5, "Turn 2", [{
-        filePath: "/src/new-file.ts",
-        backupPath: "",
-        operation: "write",
-        isNewFile: true
-      }]);
-      const result = manager.rewindTo(0);
-      expect(result.filesDeleted).toContain("/src/new-file.ts");
-      expect(mockUnlinkSync).toHaveBeenCalledWith("/src/new-file.ts");
-    });
-    it("should handle multiple checkpoints with file changes", () => {
-      mockExistsSync.mockReturnValue(true);
-      mockReadFileSync.mockReturnValue(Buffer.from("original"));
-      manager.addCheckpoint(0, 2, "Turn 1", []);
-      manager.addCheckpoint(1, 5, "Turn 2", [{
-        filePath: "/src/a.ts",
-        backupPath: "/backup/a.ts",
-        operation: "edit",
-        isNewFile: false
-      }]);
-      manager.addCheckpoint(2, 8, "Turn 3", [{
-        filePath: "/src/b.ts",
-        backupPath: "",
-        operation: "write",
-        isNewFile: true
-      }, {
-        filePath: "/src/c.ts",
-        backupPath: "/backup/c.ts",
-        operation: "multi_edit",
-        isNewFile: false
-      }]);
-      const result = manager.rewindTo(0);
-      expect(result.filesReverted).toHaveLength(2); // a.ts and c.ts
-      expect(result.filesDeleted).toHaveLength(1); // b.ts
-      expect(manager.getCheckpoints()).toHaveLength(1);
-    });
-    it("should report error when backup file is missing", () => {
-      mockExistsSync.mockImplementation(path => {
-        // File exists but backup does not
-        return path === "/src/foo.ts";
-      });
-      manager.addCheckpoint(0, 2, "Turn 1", []);
-      manager.addCheckpoint(1, 5, "Turn 2", [{
-        filePath: "/src/foo.ts",
-        backupPath: "/backup/missing.ts",
-        operation: "edit",
-        isNewFile: false
-      }]);
-      const result = manager.rewindTo(0);
-      expect(result.errors).toHaveLength(1);
-      expect(result.errors[0]).toContain("No backup found");
-    });
-    it("should handle fs errors gracefully", () => {
-      mockExistsSync.mockReturnValue(true);
-      mockReadFileSync.mockImplementation(() => {
-        throw new Error("Permission denied");
-      });
-      manager.addCheckpoint(0, 2, "Turn 1", []);
-      manager.addCheckpoint(1, 5, "Turn 2", [{
-        filePath: "/src/foo.ts",
-        backupPath: "/backup/foo.ts",
-        operation: "edit",
-        isNewFile: false
-      }]);
-      const result = manager.rewindTo(0);
-      expect(result.errors).toHaveLength(1);
-      expect(result.errors[0]).toContain("Permission denied");
-    });
-    it("should clear pending file changes on rewind", () => {
-      manager.addCheckpoint(0, 2, "Turn 1", []);
-      manager.trackFileChange({
-        filePath: "/src/test.ts",
-        backupPath: "/backup/test.ts",
-        operation: "edit",
-        isNewFile: false
-      });
-      manager.rewindTo(0);
-      expect(manager.getCurrentFileChanges()).toHaveLength(0);
-    });
-    it("should deduplicate reverted file paths", () => {
-      mockExistsSync.mockReturnValue(true);
-      mockReadFileSync.mockReturnValue(Buffer.from("original"));
-      manager.addCheckpoint(0, 2, "Turn 1", []);
-      manager.addCheckpoint(1, 5, "Turn 2", [{
-        filePath: "/src/foo.ts",
-        backupPath: "/backup/1-foo.ts",
-        operation: "edit",
-        isNewFile: false
-      }]);
-      manager.addCheckpoint(2, 8, "Turn 3", [{
-        filePath: "/src/foo.ts",
-        backupPath: "/backup/2-foo.ts",
-        operation: "edit",
-        isNewFile: false
-      }]);
-      const result = manager.rewindTo(0);
-      expect(result.filesReverted).toHaveLength(1); // deduplicated
-    });
-    it("should process checkpoints in reverse chronological order", () => {
-      const callOrder = [];
-      mockExistsSync.mockReturnValue(true);
-      mockReadFileSync.mockImplementation(path => {
-        callOrder.push(path);
-        return Buffer.from("content");
-      });
-      manager.addCheckpoint(0, 2, "Turn 1", []);
-      manager.addCheckpoint(1, 5, "Turn 2", [{
-        filePath: "/src/a.ts",
-        backupPath: "/backup/turn2.ts",
-        operation: "edit",
-        isNewFile: false
-      }]);
-      manager.addCheckpoint(2, 8, "Turn 3", [{
-        filePath: "/src/b.ts",
-        backupPath: "/backup/turn3.ts",
-        operation: "edit",
-        isNewFile: false
-      }]);
-      manager.rewindTo(0);
-      // Turn 3 should be processed before Turn 2 (reverse chronological)
-      expect(callOrder[0]).toBe("/backup/turn3.ts");
-      expect(callOrder[1]).toBe("/backup/turn2.ts");
-    });
-  });
-  describe("revertFilesFrom", () => {
-    it("should revert files without truncating checkpoints", () => {
-      mockExistsSync.mockReturnValue(true);
-      mockReadFileSync.mockReturnValue(Buffer.from("original"));
-      manager.addCheckpoint(0, 2, "Turn 1", []);
-      manager.addCheckpoint(1, 5, "Turn 2", [{
-        filePath: "/src/foo.ts",
-        backupPath: "/backup/foo.ts",
-        operation: "edit",
-        isNewFile: false
-      }]);
-      const result = manager.revertFilesFrom(0);
-      expect(result.filesReverted).toContain("/src/foo.ts");
-      // Checkpoints should NOT be truncated
-      expect(manager.getCheckpoints()).toHaveLength(2);
-    });
-  });
-});

package/dist/cli/services/rewind.test.js

@@ -1,175 +0,0 @@
-/**
- * Tests for RewindManager — checkpoint tracking and file change tracking
- */
-
-import { describe, it, expect, beforeEach, vi, afterEach } from "vitest";
-import { RewindManager } from "./rewind.js";
-import { existsSync, readFileSync, writeFileSync, unlinkSync } from "fs";
-
-// Mock fs operations
-vi.mock("fs", () => ({
-  existsSync: vi.fn(),
-  readFileSync: vi.fn(),
-  writeFileSync: vi.fn(),
-  unlinkSync: vi.fn()
-}));
-const mockExistsSync = existsSync;
-const mockReadFileSync = readFileSync;
-const mockWriteFileSync = writeFileSync;
-const mockUnlinkSync = unlinkSync;
-describe("RewindManager", () => {
-  let manager;
-  beforeEach(() => {
-    manager = new RewindManager();
-    vi.clearAllMocks();
-  });
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  // ── Checkpoint tracking ──
-
-  describe("addCheckpoint", () => {
-    it("should add a checkpoint with the correct data", () => {
-      manager.addCheckpoint(0, 2, "Let me read the file", []);
-      const cps = manager.getCheckpoints();
-      expect(cps).toHaveLength(1);
-      expect(cps[0].turnIndex).toBe(0);
-      expect(cps[0].messageCount).toBe(2);
-      expect(cps[0].summary).toBe("Let me read the file");
-      expect(cps[0].fileChanges).toEqual([]);
-      expect(cps[0].timestamp).toBeGreaterThan(0);
-    });
-    it("should truncate summary to 80 chars", () => {
-      const longSummary = "a".repeat(120);
-      manager.addCheckpoint(0, 2, longSummary, []);
-      expect(manager.getCheckpoints()[0].summary).toHaveLength(80);
-    });
-    it("should accumulate multiple checkpoints", () => {
-      manager.addCheckpoint(0, 2, "Turn 1", []);
-      manager.addCheckpoint(1, 5, "Turn 2", []);
-      manager.addCheckpoint(2, 8, "Turn 3", []);
-      expect(manager.getCheckpoints()).toHaveLength(3);
-      expect(manager.getCheckpointCount()).toBe(3);
-    });
-    it("should include file changes in checkpoint", () => {
-      const changes = [{
-        filePath: "/src/foo.ts",
-        backupPath: "/backup/123-foo.ts",
-        operation: "edit",
-        isNewFile: false
-      }, {
-        filePath: "/src/bar.ts",
-        backupPath: "",
-        operation: "write",
-        isNewFile: true
-      }];
-      manager.addCheckpoint(0, 3, "Modified files", changes);
-      expect(manager.getCheckpoints()[0].fileChanges).toHaveLength(2);
-      expect(manager.getCheckpoints()[0].fileChanges[1].isNewFile).toBe(true);
-    });
-  });
-  describe("getCheckpoints", () => {
-    it("should return a copy (not the internal array)", () => {
-      manager.addCheckpoint(0, 2, "Turn 1", []);
-      const cps = manager.getCheckpoints();
-      cps.push({});
-      expect(manager.getCheckpoints()).toHaveLength(1);
-    });
-  });
-
-  // ── File change tracking ──
-
-  describe("trackFileChange / getCurrentFileChanges / commitTurn", () => {
-    it("should track pending file changes", () => {
-      const change = {
-        filePath: "/src/test.ts",
-        backupPath: "/backup/123-test.ts",
-        operation: "edit",
-        isNewFile: false
-      };
-      manager.trackFileChange(change);
-      expect(manager.getCurrentFileChanges()).toHaveLength(1);
-      expect(manager.getCurrentFileChanges()[0].filePath).toBe("/src/test.ts");
-    });
-    it("should clear pending changes on commitTurn", () => {
-      manager.trackFileChange({
-        filePath: "/src/test.ts",
-        backupPath: "/backup/123-test.ts",
-        operation: "edit",
-        isNewFile: false
-      });
-      expect(manager.getCurrentFileChanges()).toHaveLength(1);
-      manager.commitTurn();
-      expect(manager.getCurrentFileChanges()).toHaveLength(0);
-    });
-    it("should return a copy of current file changes", () => {
-      manager.trackFileChange({
-        filePath: "/src/test.ts",
-        backupPath: "/backup/123-test.ts",
-        operation: "edit",
-        isNewFile: false
-      });
-      const changes = manager.getCurrentFileChanges();
-      changes.push({});
-      expect(manager.getCurrentFileChanges()).toHaveLength(1);
-    });
-  });
-
-  // ── Utility methods ──
-
-  describe("hasFileChanges", () => {
-    it("should return false when no file changes exist", () => {
-      manager.addCheckpoint(0, 2, "Turn 1", []);
-      expect(manager.hasFileChanges()).toBe(false);
-    });
-    it("should return true when file changes exist", () => {
-      manager.addCheckpoint(0, 2, "Turn 1", [{
-        filePath: "/src/foo.ts",
-        backupPath: "/backup/foo.ts",
-        operation: "edit",
-        isNewFile: false
-      }]);
-      expect(manager.hasFileChanges()).toBe(true);
-    });
-  });
-  describe("getFileChangeCountAfter", () => {
-    it("should count file changes after the given checkpoint", () => {
-      manager.addCheckpoint(0, 2, "Turn 1", []);
-      manager.addCheckpoint(1, 5, "Turn 2", [{
-        filePath: "/src/a.ts",
-        backupPath: "/backup/a.ts",
-        operation: "edit",
-        isNewFile: false
-      }]);
-      manager.addCheckpoint(2, 8, "Turn 3", [{
-        filePath: "/src/b.ts",
-        backupPath: "",
-        operation: "write",
-        isNewFile: true
-      }, {
-        filePath: "/src/c.ts",
-        backupPath: "/backup/c.ts",
-        operation: "edit",
-        isNewFile: false
-      }]);
-      expect(manager.getFileChangeCountAfter(0)).toBe(3); // Turn 2 (1) + Turn 3 (2)
-      expect(manager.getFileChangeCountAfter(1)).toBe(2); // Turn 3 (2)
-      expect(manager.getFileChangeCountAfter(2)).toBe(0); // Nothing after Turn 3
-    });
-  });
-  describe("reset", () => {
-    it("should clear all state", () => {
-      manager.addCheckpoint(0, 2, "Turn 1", []);
-      manager.trackFileChange({
-        filePath: "/src/test.ts",
-        backupPath: "/backup/test.ts",
-        operation: "edit",
-        isNewFile: false
-      });
-      manager.reset();
-      expect(manager.getCheckpoints()).toHaveLength(0);
-      expect(manager.getCurrentFileChanges()).toHaveLength(0);
-    });
-  });
-});