@vacbo/opencode-anthropic-fix 0.1.7 → 0.1.9

package/src/__tests__/sanitization-regex.test.ts

@@ -10,116 +10,116 @@ import { describe, it, expect } from "vitest";
 import { sanitizeSystemText } from "../system-prompt/sanitize.js";
 
 describe("sanitizeSystemText word boundaries", () => {
-  it("replaces the PascalCase word 'OpenCode' with 'Claude Code'", () => {
-    const result = sanitizeSystemText("Run OpenCode first", true);
-    expect(result).not.toContain("OpenCode");
-    expect(result).toContain("Claude Code");
-  });
-
-  it("replaces the lowercase word 'opencode' with 'Claude'", () => {
-    // Per sanitize.ts, /\bopencode\b/gi → "Claude" (not "Claude Code")
-    const result = sanitizeSystemText("use opencode here", true);
-    expect(result).not.toContain("opencode");
-    expect(result).toContain("Claude");
-  });
-
-  it("does NOT replace 'myopencode' (word boundary on left)", () => {
-    const result = sanitizeSystemText("the myopencode binary", true);
-    expect(result).toContain("myopencode");
-  });
-
-  it("does NOT replace 'opencoder' (word boundary on right)", () => {
-    const result = sanitizeSystemText("known as opencoder", true);
-    expect(result).toContain("opencoder");
-  });
-
-  it("does NOT replace 'preopencode' (word boundary on both sides)", () => {
-    const result = sanitizeSystemText("run preopencode first", true);
-    expect(result).toContain("preopencode");
-  });
-
-  it("handles mixed content correctly", () => {
-    const result = sanitizeSystemText("use opencode inside myopencode directory", true);
-    // Standalone "opencode" becomes "Claude"
-    expect(result).toContain("Claude");
-    // "myopencode" is preserved because of word boundary
-    expect(result).toContain("myopencode");
-  });
-
-  it("preserves text when enabled=false", () => {
-    const result = sanitizeSystemText("use opencode here", false);
-    expect(result).toContain("opencode");
-  });
-
-  it("replaces 'Sisyphus' with 'Claude Code Agent'", () => {
-    const result = sanitizeSystemText("from the Sisyphus agent", true);
-    expect(result).not.toContain("Sisyphus");
-    expect(result).toContain("Claude Code Agent");
-  });
-
-  it("replaces 'morph_edit' with 'edit' at word boundaries", () => {
-    const result = sanitizeSystemText("call morph_edit tool", true);
-    expect(result).not.toContain("morph_edit");
-    expect(result).toContain("edit");
-  });
-
-  // ---------------------------------------------------------------------
-  // Regressions for the hyphen/slash word boundary fix.
-  // The previous regex used \b which treats `-` and `/` as word boundaries,
-  // so `opencode-anthropic-fix` and `/Users/.../opencode/dist` were getting
-  // rewritten in place. The new regex uses negative lookarounds for
-  // [\w\-/] on both sides so these forms survive verbatim.
-  // ---------------------------------------------------------------------
-
-  it("does NOT rewrite 'opencode-anthropic-fix' (hyphen on the right)", () => {
-    const result = sanitizeSystemText("Loaded opencode-anthropic-fix from disk", true);
-    expect(result).toContain("opencode-anthropic-fix");
-    expect(result).not.toContain("Claude-anthropic-fix");
-  });
-
-  it("does NOT rewrite 'pre-opencode' (hyphen on the left)", () => {
-    const result = sanitizeSystemText("the pre-opencode hook fired", true);
-    expect(result).toContain("pre-opencode");
-  });
-
-  it("does NOT corrupt path-like strings containing /opencode/", () => {
-    const input = "Working dir: /Users/rmk/projects/opencode-auth/src";
-    const result = sanitizeSystemText(input, true);
-    expect(result).toBe(input);
-  });
-
-  it("does NOT corrupt deep paths with multiple opencode segments", () => {
-    const input = "/home/user/.config/opencode/plugin/opencode-anthropic-auth-plugin.js";
-    const result = sanitizeSystemText(input, true);
-    expect(result).toBe(input);
-  });
-
-  it("does NOT rewrite the PascalCase form inside hyphenated identifiers", () => {
-    const result = sanitizeSystemText("the OpenCode-Plugin loader", true);
-    expect(result).toContain("OpenCode-Plugin");
-    expect(result).not.toContain("Claude Code-Plugin");
-  });
-
-  it("still rewrites a standalone PascalCase 'OpenCode' next to a hyphenated form", () => {
-    const result = sanitizeSystemText("OpenCode loaded opencode-anthropic-fix", true);
-    expect(result).toContain("Claude Code loaded");
-    expect(result).toContain("opencode-anthropic-fix");
-  });
-
-  it("defaults to enabled=false (no second arg means no rewriting)", () => {
-    const result = sanitizeSystemText("use OpenCode and opencode and Sisyphus and morph_edit");
-    expect(result).toBe("use OpenCode and opencode and Sisyphus and morph_edit");
-  });
-
-  it("explicit enabled=false preserves text verbatim", () => {
-    const input = "Path: /Users/rmk/projects/opencode-anthropic-fix";
-    const result = sanitizeSystemText(input, false);
-    expect(result).toBe(input);
-  });
-
-  it("explicit enabled=true rewrites the standalone forms", () => {
-    const result = sanitizeSystemText("use opencode for tasks", true);
-    expect(result).toContain("Claude");
-    expect(result).not.toContain("opencode");
-  });
+    it("replaces the PascalCase word 'OpenCode' with 'Claude Code'", () => {
+        const result = sanitizeSystemText("Run OpenCode first", true);
+        expect(result).not.toContain("OpenCode");
+        expect(result).toContain("Claude Code");
+    });
+
+    it("replaces the lowercase word 'opencode' with 'Claude'", () => {
+        // Per sanitize.ts, /\bopencode\b/gi → "Claude" (not "Claude Code")
+        const result = sanitizeSystemText("use opencode here", true);
+        expect(result).not.toContain("opencode");
+        expect(result).toContain("Claude");
+    });
+
+    it("does NOT replace 'myopencode' (word boundary on left)", () => {
+        const result = sanitizeSystemText("the myopencode binary", true);
+        expect(result).toContain("myopencode");
+    });
+
+    it("does NOT replace 'opencoder' (word boundary on right)", () => {
+        const result = sanitizeSystemText("known as opencoder", true);
+        expect(result).toContain("opencoder");
+    });
+
+    it("does NOT replace 'preopencode' (word boundary on both sides)", () => {
+        const result = sanitizeSystemText("run preopencode first", true);
+        expect(result).toContain("preopencode");
+    });
+
+    it("handles mixed content correctly", () => {
+        const result = sanitizeSystemText("use opencode inside myopencode directory", true);
+        // Standalone "opencode" becomes "Claude"
+        expect(result).toContain("Claude");
+        // "myopencode" is preserved because of word boundary
+        expect(result).toContain("myopencode");
+    });
+
+    it("preserves text when enabled=false", () => {
+        const result = sanitizeSystemText("use opencode here", false);
+        expect(result).toContain("opencode");
+    });
+
+    it("replaces 'Sisyphus' with 'Claude Code Agent'", () => {
+        const result = sanitizeSystemText("from the Sisyphus agent", true);
+        expect(result).not.toContain("Sisyphus");
+        expect(result).toContain("Claude Code Agent");
+    });
+
+    it("replaces 'morph_edit' with 'edit' at word boundaries", () => {
+        const result = sanitizeSystemText("call morph_edit tool", true);
+        expect(result).not.toContain("morph_edit");
+        expect(result).toContain("edit");
+    });
+
+    // ---------------------------------------------------------------------
+    // Regressions for the hyphen/slash word boundary fix.
+    // The previous regex used \b which treats `-` and `/` as word boundaries,
+    // so `opencode-anthropic-fix` and `/Users/.../opencode/dist` were getting
+    // rewritten in place. The new regex uses negative lookarounds for
+    // [\w\-/] on both sides so these forms survive verbatim.
+    // ---------------------------------------------------------------------
+
+    it("does NOT rewrite 'opencode-anthropic-fix' (hyphen on the right)", () => {
+        const result = sanitizeSystemText("Loaded opencode-anthropic-fix from disk", true);
+        expect(result).toContain("opencode-anthropic-fix");
+        expect(result).not.toContain("Claude-anthropic-fix");
+    });
+
+    it("does NOT rewrite 'pre-opencode' (hyphen on the left)", () => {
+        const result = sanitizeSystemText("the pre-opencode hook fired", true);
+        expect(result).toContain("pre-opencode");
+    });
+
+    it("does NOT corrupt path-like strings containing /opencode/", () => {
+        const input = "Working dir: /Users/rmk/projects/opencode-auth/src";
+        const result = sanitizeSystemText(input, true);
+        expect(result).toBe(input);
+    });
+
+    it("does NOT corrupt deep paths with multiple opencode segments", () => {
+        const input = "/home/user/.config/opencode/plugin/opencode-anthropic-auth-plugin.js";
+        const result = sanitizeSystemText(input, true);
+        expect(result).toBe(input);
+    });
+
+    it("does NOT rewrite the PascalCase form inside hyphenated identifiers", () => {
+        const result = sanitizeSystemText("the OpenCode-Plugin loader", true);
+        expect(result).toContain("OpenCode-Plugin");
+        expect(result).not.toContain("Claude Code-Plugin");
+    });
+
+    it("still rewrites a standalone PascalCase 'OpenCode' next to a hyphenated form", () => {
+        const result = sanitizeSystemText("OpenCode loaded opencode-anthropic-fix", true);
+        expect(result).toContain("Claude Code loaded");
+        expect(result).toContain("opencode-anthropic-fix");
+    });
+
+    it("defaults to enabled=false (no second arg means no rewriting)", () => {
+        const result = sanitizeSystemText("use OpenCode and opencode and Sisyphus and morph_edit");
+        expect(result).toBe("use OpenCode and opencode and Sisyphus and morph_edit");
+    });
+
+    it("explicit enabled=false preserves text verbatim", () => {
+        const input = "Path: /Users/rmk/projects/opencode-anthropic-fix";
+        const result = sanitizeSystemText(input, false);
+        expect(result).toBe(input);
+    });
+
+    it("explicit enabled=true rewrites the standalone forms", () => {
+        const result = sanitizeSystemText("use opencode for tasks", true);
+        expect(result).toContain("Claude");
+        expect(result).not.toContain("opencode");
+    });
 });

package/src/__tests__/state-bounds.test.ts

@@ -11,100 +11,100 @@ import { capFileAccountMap, FILE_ACCOUNT_MAP_MAX_SIZE } from "../commands/router
 import { pruneExpiredPendingOAuth, PENDING_OAUTH_TTL_MS, type PendingOAuthEntry } from "../commands/oauth-flow.js";
 
 function makePendingEntry(createdAt: number): PendingOAuthEntry {
-  return {
-    mode: "login",
-    verifier: "test-verifier",
-    createdAt,
-  };
+    return {
+        mode: "login",
+        verifier: "test-verifier",
+        createdAt,
+    };
 }
 
 describe("capFileAccountMap FIFO eviction", () => {
-  it("exports FILE_ACCOUNT_MAP_MAX_SIZE = 1000", () => {
-    expect(FILE_ACCOUNT_MAP_MAX_SIZE).toBe(1000);
-  });
-
-  it("caps the map at FILE_ACCOUNT_MAP_MAX_SIZE entries", () => {
-    const map = new Map<string, number>();
-    for (let i = 0; i < FILE_ACCOUNT_MAP_MAX_SIZE + 100; i++) {
-      capFileAccountMap(map, `file_${i}`, i % 5);
-    }
-    expect(map.size).toBeLessThanOrEqual(FILE_ACCOUNT_MAP_MAX_SIZE);
-  });
-
-  it("evicts oldest entries first (FIFO)", () => {
-    const map = new Map<string, number>();
-    for (let i = 0; i < FILE_ACCOUNT_MAP_MAX_SIZE; i++) {
-      capFileAccountMap(map, `file_${i}`, 0);
-    }
-    capFileAccountMap(map, "file_overflow", 1);
-    expect(map.has("file_0")).toBe(false);
-    expect(map.has("file_overflow")).toBe(true);
-    expect(map.size).toBe(FILE_ACCOUNT_MAP_MAX_SIZE);
-  });
-
-  it("updates value of existing key when below cap", () => {
-    const map = new Map<string, number>();
-    capFileAccountMap(map, "file_a", 1);
-    capFileAccountMap(map, "file_a", 2);
-    expect(map.get("file_a")).toBe(2);
-    expect(map.size).toBe(1);
-  });
-
-  it("handles rapid insertion under cap without eviction", () => {
-    const map = new Map<string, number>();
-    for (let i = 0; i < 500; i++) {
-      capFileAccountMap(map, `file_${i}`, 0);
-    }
-    expect(map.size).toBe(500);
-    expect(map.has("file_0")).toBe(true);
-    expect(map.has("file_499")).toBe(true);
-  });
+    it("exports FILE_ACCOUNT_MAP_MAX_SIZE = 1000", () => {
+        expect(FILE_ACCOUNT_MAP_MAX_SIZE).toBe(1000);
+    });
+
+    it("caps the map at FILE_ACCOUNT_MAP_MAX_SIZE entries", () => {
+        const map = new Map<string, number>();
+        for (let i = 0; i < FILE_ACCOUNT_MAP_MAX_SIZE + 100; i++) {
+            capFileAccountMap(map, `file_${i}`, i % 5);
+        }
+        expect(map.size).toBeLessThanOrEqual(FILE_ACCOUNT_MAP_MAX_SIZE);
+    });
+
+    it("evicts oldest entries first (FIFO)", () => {
+        const map = new Map<string, number>();
+        for (let i = 0; i < FILE_ACCOUNT_MAP_MAX_SIZE; i++) {
+            capFileAccountMap(map, `file_${i}`, 0);
+        }
+        capFileAccountMap(map, "file_overflow", 1);
+        expect(map.has("file_0")).toBe(false);
+        expect(map.has("file_overflow")).toBe(true);
+        expect(map.size).toBe(FILE_ACCOUNT_MAP_MAX_SIZE);
+    });
+
+    it("updates value of existing key when below cap", () => {
+        const map = new Map<string, number>();
+        capFileAccountMap(map, "file_a", 1);
+        capFileAccountMap(map, "file_a", 2);
+        expect(map.get("file_a")).toBe(2);
+        expect(map.size).toBe(1);
+    });
+
+    it("handles rapid insertion under cap without eviction", () => {
+        const map = new Map<string, number>();
+        for (let i = 0; i < 500; i++) {
+            capFileAccountMap(map, `file_${i}`, 0);
+        }
+        expect(map.size).toBe(500);
+        expect(map.has("file_0")).toBe(true);
+        expect(map.has("file_499")).toBe(true);
+    });
 });
 
 describe("pruneExpiredPendingOAuth TTL cleanup", () => {
-  it("exports PENDING_OAUTH_TTL_MS = 10 minutes", () => {
-    expect(PENDING_OAUTH_TTL_MS).toBe(10 * 60 * 1000);
-  });
-
-  it("removes entries older than TTL", () => {
-    const map = new Map<string, PendingOAuthEntry>();
-    const now = Date.now();
-    map.set("expired", makePendingEntry(now - PENDING_OAUTH_TTL_MS - 1000));
-    map.set("fresh", makePendingEntry(now));
-
-    pruneExpiredPendingOAuth(map);
-
-    expect(map.has("expired")).toBe(false);
-    expect(map.has("fresh")).toBe(true);
-  });
-
-  it("does not remove entries just inside the TTL boundary", () => {
-    const map = new Map<string, PendingOAuthEntry>();
-    const now = Date.now();
-    map.set("boundary", makePendingEntry(now - PENDING_OAUTH_TTL_MS + 1000));
-
-    pruneExpiredPendingOAuth(map);
-
-    expect(map.has("boundary")).toBe(true);
-  });
-
-  it("handles empty map without error", () => {
-    const map = new Map<string, PendingOAuthEntry>();
-    expect(() => pruneExpiredPendingOAuth(map)).not.toThrow();
-  });
-
-  it("removes only expired entries, leaves fresh ones", () => {
-    const map = new Map<string, PendingOAuthEntry>();
-    const now = Date.now();
-    map.set("old1", makePendingEntry(now - PENDING_OAUTH_TTL_MS - 5000));
-    map.set("old2", makePendingEntry(now - PENDING_OAUTH_TTL_MS - 2000));
-    map.set("new1", makePendingEntry(now - 1000));
-    map.set("new2", makePendingEntry(now));
-
-    pruneExpiredPendingOAuth(map);
-
-    expect(map.size).toBe(2);
-    expect(map.has("new1")).toBe(true);
-    expect(map.has("new2")).toBe(true);
-  });
+    it("exports PENDING_OAUTH_TTL_MS = 10 minutes", () => {
+        expect(PENDING_OAUTH_TTL_MS).toBe(10 * 60 * 1000);
+    });
+
+    it("removes entries older than TTL", () => {
+        const map = new Map<string, PendingOAuthEntry>();
+        const now = Date.now();
+        map.set("expired", makePendingEntry(now - PENDING_OAUTH_TTL_MS - 1000));
+        map.set("fresh", makePendingEntry(now));
+
+        pruneExpiredPendingOAuth(map);
+
+        expect(map.has("expired")).toBe(false);
+        expect(map.has("fresh")).toBe(true);
+    });
+
+    it("does not remove entries just inside the TTL boundary", () => {
+        const map = new Map<string, PendingOAuthEntry>();
+        const now = Date.now();
+        map.set("boundary", makePendingEntry(now - PENDING_OAUTH_TTL_MS + 1000));
+
+        pruneExpiredPendingOAuth(map);
+
+        expect(map.has("boundary")).toBe(true);
+    });
+
+    it("handles empty map without error", () => {
+        const map = new Map<string, PendingOAuthEntry>();
+        expect(() => pruneExpiredPendingOAuth(map)).not.toThrow();
+    });
+
+    it("removes only expired entries, leaves fresh ones", () => {
+        const map = new Map<string, PendingOAuthEntry>();
+        const now = Date.now();
+        map.set("old1", makePendingEntry(now - PENDING_OAUTH_TTL_MS - 5000));
+        map.set("old2", makePendingEntry(now - PENDING_OAUTH_TTL_MS - 2000));
+        map.set("new1", makePendingEntry(now - 1000));
+        map.set("new2", makePendingEntry(now));
+
+        pruneExpiredPendingOAuth(map);
+
+        expect(map.size).toBe(2);
+        expect(map.has("new1")).toBe(true);
+        expect(map.has("new2")).toBe(true);
+    });
 });