@gotgenes/pi-permission-system 18.1.1 → 18.2.0

package/test/tool-access-extractor-registry.test.ts

@@ -1,77 +0,0 @@
-import { describe, expect, test } from "vitest";
-
-import {
-  type ToolAccessExtractor,
-  ToolAccessExtractorRegistry,
-} from "#src/tool-access-extractor-registry";
-
-const noopExtractor: ToolAccessExtractor = () => "/tmp/x";
-
-describe("ToolAccessExtractorRegistry", () => {
-  describe("register", () => {
-    test("stores an extractor so get() returns it", () => {
-      const registry = new ToolAccessExtractorRegistry();
-      registry.register("my-tool", noopExtractor);
-      expect(registry.get("my-tool")).toBe(noopExtractor);
-    });
-
-    test("returns a disposer that removes the extractor", () => {
-      const registry = new ToolAccessExtractorRegistry();
-      const dispose = registry.register("my-tool", noopExtractor);
-      dispose();
-      expect(registry.get("my-tool")).toBeUndefined();
-    });
-
-    test("throws when an extractor is already registered for the same tool name", () => {
-      const registry = new ToolAccessExtractorRegistry();
-      registry.register("my-tool", noopExtractor);
-      expect(() => registry.register("my-tool", () => undefined)).toThrow(
-        "my-tool",
-      );
-    });
-
-    test("allows registering different tool names independently", () => {
-      const registry = new ToolAccessExtractorRegistry();
-      const extractorA: ToolAccessExtractor = () => "/a";
-      const extractorB: ToolAccessExtractor = () => "/b";
-      registry.register("tool-a", extractorA);
-      registry.register("tool-b", extractorB);
-      expect(registry.get("tool-a")).toBe(extractorA);
-      expect(registry.get("tool-b")).toBe(extractorB);
-    });
-  });
-
-  describe("disposer identity guard", () => {
-    test("stale disposer does not evict a later registration", () => {
-      const registry = new ToolAccessExtractorRegistry();
-      const first: ToolAccessExtractor = () => "/first";
-      const second: ToolAccessExtractor = () => "/second";
-
-      const disposeFirst = registry.register("my-tool", first);
-      disposeFirst(); // removes first
-
-      registry.register("my-tool", second); // second registration is now valid
-      disposeFirst(); // calling stale disposer again — must not remove second
-
-      expect(registry.get("my-tool")).toBe(second);
-    });
-  });
-
-  describe("get", () => {
-    test("returns undefined for an unregistered tool name", () => {
-      const registry = new ToolAccessExtractorRegistry();
-      expect(registry.get("unknown")).toBeUndefined();
-    });
-
-    test("the registered extractor is callable and returns its path", () => {
-      const registry = new ToolAccessExtractorRegistry();
-      const extractor: ToolAccessExtractor = (input) =>
-        typeof input.target === "string" ? input.target : undefined;
-      registry.register("ffgrep", extractor);
-      expect(registry.get("ffgrep")?.({ target: "/etc/hosts" })).toBe(
-        "/etc/hosts",
-      );
-      expect(registry.get("ffgrep")?.({ other: true })).toBeUndefined();
-    });
-  });
-});

package/test/tool-input-formatter-registry.test.ts

@@ -1,75 +0,0 @@
-import { describe, expect, test } from "vitest";
-
-import {
-  type ToolInputFormatter,
-  ToolInputFormatterRegistry,
-} from "#src/tool-input-formatter-registry";
-
-const noopFormatter: ToolInputFormatter = () => "preview";
-
-describe("ToolInputFormatterRegistry", () => {
-  describe("register", () => {
-    test("stores a formatter so get() returns it", () => {
-      const registry = new ToolInputFormatterRegistry();
-      registry.register("my-tool", noopFormatter);
-      expect(registry.get("my-tool")).toBe(noopFormatter);
-    });
-
-    test("returns a disposer that removes the formatter", () => {
-      const registry = new ToolInputFormatterRegistry();
-      const dispose = registry.register("my-tool", noopFormatter);
-      dispose();
-      expect(registry.get("my-tool")).toBeUndefined();
-    });
-
-    test("throws when a formatter is already registered for the same tool name", () => {
-      const registry = new ToolInputFormatterRegistry();
-      registry.register("my-tool", noopFormatter);
-      expect(() => registry.register("my-tool", () => undefined)).toThrow(
-        "my-tool",
-      );
-    });
-
-    test("allows registering different tool names independently", () => {
-      const registry = new ToolInputFormatterRegistry();
-      const formatterA: ToolInputFormatter = () => "a";
-      const formatterB: ToolInputFormatter = () => "b";
-      registry.register("tool-a", formatterA);
-      registry.register("tool-b", formatterB);
-      expect(registry.get("tool-a")).toBe(formatterA);
-      expect(registry.get("tool-b")).toBe(formatterB);
-    });
-  });
-
-  describe("disposer identity guard", () => {
-    test("stale disposer does not evict a later registration", () => {
-      const registry = new ToolInputFormatterRegistry();
-      const first: ToolInputFormatter = () => "first";
-      const second: ToolInputFormatter = () => "second";
-
-      const disposeFirst = registry.register("my-tool", first);
-      disposeFirst(); // removes first
-
-      registry.register("my-tool", second); // second registration is now valid
-      disposeFirst(); // calling stale disposer again — must not remove second
-
-      expect(registry.get("my-tool")).toBe(second);
-    });
-  });
-
-  describe("get", () => {
-    test("returns undefined for an unregistered tool name", () => {
-      const registry = new ToolInputFormatterRegistry();
-      expect(registry.get("unknown")).toBeUndefined();
-    });
-
-    test("the registered formatter is callable and returns its result", () => {
-      const registry = new ToolInputFormatterRegistry();
-      const fmt: ToolInputFormatter = (input) =>
-        typeof input.cmd === "string" ? `runs ${input.cmd}` : undefined;
-      registry.register("run", fmt);
-      expect(registry.get("run")?.({ cmd: "ls" })).toBe("runs ls");
-      expect(registry.get("run")?.({ other: true })).toBeUndefined();
-    });
-  });
-});

package/test/tool-input-path.test.ts

@@ -1,84 +0,0 @@
-import { describe, expect, test } from "vitest";
-import type { ToolAccessExtractorLookup } from "#src/tool-access-extractor-registry";
-import { getPathBearingToolPath, getToolInputPath } from "#src/tool-input-path";
-
-describe("getPathBearingToolPath", () => {
-  test("returns path for a path-bearing tool", () => {
-    expect(getPathBearingToolPath("read", { path: "/src/foo.ts" })).toBe(
-      "/src/foo.ts",
-    );
-  });
-
-  test("returns null for a non-path-bearing tool", () => {
-    expect(getPathBearingToolPath("bash", { path: "/src/foo.ts" })).toBeNull();
-    expect(getPathBearingToolPath("mcp", { path: "/src/foo.ts" })).toBeNull();
-    expect(getPathBearingToolPath("task", { path: "/src/foo.ts" })).toBeNull();
-  });
-
-  test("returns null when input has no path", () => {
-    expect(getPathBearingToolPath("read", {})).toBeNull();
-    expect(getPathBearingToolPath("read", { path: "" })).toBeNull();
-    expect(getPathBearingToolPath("read", null)).toBeNull();
-  });
-});
-
-describe("getToolInputPath", () => {
-  function lookupOf(
-    toolName: string,
-    extractor: (input: Record<string, unknown>) => string | undefined,
-  ): ToolAccessExtractorLookup {
-    return {
-      get: (name) => (name === toolName ? extractor : undefined),
-    };
-  }
-
-  test("returns input.path for a built-in path-bearing tool", () => {
-    expect(getToolInputPath("read", { path: "/src/foo.ts" })).toBe(
-      "/src/foo.ts",
-    );
-    expect(getToolInputPath("write", { path: "/src/bar.ts" })).toBe(
-      "/src/bar.ts",
-    );
-  });
-
-  test("returns null for bash", () => {
-    expect(getToolInputPath("bash", { path: "/src/foo.ts" })).toBeNull();
-  });
-
-  test("returns the MCP arguments.path for an mcp call", () => {
-    expect(getToolInputPath("mcp", { arguments: { path: "/etc/hosts" } })).toBe(
-      "/etc/hosts",
-    );
-  });
-
-  test("returns null for an mcp call without an arguments.path", () => {
-    expect(getToolInputPath("mcp", { arguments: { query: "x" } })).toBeNull();
-    expect(getToolInputPath("mcp", {})).toBeNull();
-  });
-
-  test("defaults to input.path for an unregistered extension tool", () => {
-    expect(getToolInputPath("my-ext", { path: "/work/file.txt" })).toBe(
-      "/work/file.txt",
-    );
-  });
-
-  test("returns null for an extension tool without a path", () => {
-    expect(getToolInputPath("my-ext", { other: true })).toBeNull();
-    expect(getToolInputPath("my-ext", { path: "" })).toBeNull();
-    expect(getToolInputPath("my-ext", null)).toBeNull();
-  });
-
-  test("uses a registered extractor's path over the default convention", () => {
-    const extractors = lookupOf("ffgrep", (input) =>
-      typeof input.target === "string" ? input.target : undefined,
-    );
-    expect(
-      getToolInputPath("ffgrep", { target: "/etc/passwd" }, extractors),
-    ).toBe("/etc/passwd");
-  });
-
-  test("returns null when a registered extractor declines", () => {
-    const extractors = lookupOf("ffgrep", () => undefined);
-    expect(getToolInputPath("ffgrep", { target: "x" }, extractors)).toBeNull();
-  });
-});

package/test/tool-input-preview.test.ts

@@ -1,129 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-
-// Mock logging collaborator before importing the module under test.
-vi.mock("../src/logging.js", () => ({
-  safeJsonStringify: vi.fn((value: unknown) => JSON.stringify(value)),
-}));
-
-import { safeJsonStringify } from "#src/logging";
-import {
-  countTextLines,
-  formatCount,
-  serializeToolInputPreview,
-  TOOL_INPUT_LOG_PREVIEW_MAX_LENGTH,
-  TOOL_INPUT_PREVIEW_MAX_LENGTH,
-  TOOL_TEXT_SUMMARY_MAX_LENGTH,
-  truncateInlineText,
-} from "#src/tool-input-preview";
-
-const mockedStringify = vi.mocked(safeJsonStringify);
-
-beforeEach(() => {
-  mockedStringify.mockReset();
-});
-
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-
-describe("constants", () => {
-  test("TOOL_INPUT_PREVIEW_MAX_LENGTH is 200", () => {
-    expect(TOOL_INPUT_PREVIEW_MAX_LENGTH).toBe(200);
-  });
-
-  test("TOOL_INPUT_LOG_PREVIEW_MAX_LENGTH is 1000", () => {
-    expect(TOOL_INPUT_LOG_PREVIEW_MAX_LENGTH).toBe(1000);
-  });
-
-  test("TOOL_TEXT_SUMMARY_MAX_LENGTH is 80", () => {
-    expect(TOOL_TEXT_SUMMARY_MAX_LENGTH).toBe(80);
-  });
-});
-
-describe("truncateInlineText", () => {
-  test("returns text unchanged when within maxLength", () => {
-    expect(truncateInlineText("hello", 10)).toBe("hello");
-  });
-
-  test("does not truncate when length equals maxLength", () => {
-    const text = "a".repeat(200);
-    expect(truncateInlineText(text, 200)).toBe(text);
-  });
-
-  test("truncates and appends ellipsis when length exceeds maxLength", () => {
-    const text = "a".repeat(201);
-    const result = truncateInlineText(text, 200);
-    expect(result).toBe(`${"a".repeat(200)}…`);
-  });
-
-  test("truncates long text and appends ellipsis", () => {
-    const result = truncateInlineText("abcdef", 3);
-    expect(result).toBe("abc…");
-  });
-});
-
-describe("countTextLines", () => {
-  test("returns 0 for empty string", () => {
-    expect(countTextLines("")).toBe(0);
-  });
-
-  test("returns 1 for a single line with no newline", () => {
-    expect(countTextLines("hello")).toBe(1);
-  });
-
-  test("counts LF-separated lines", () => {
-    expect(countTextLines("line1\nline2\nline3")).toBe(3);
-  });
-
-  test("counts CRLF-separated lines", () => {
-    expect(countTextLines("line1\r\nline2")).toBe(2);
-  });
-
-  test("counts CR-separated lines", () => {
-    expect(countTextLines("line1\rline2")).toBe(2);
-  });
-});
-
-describe("formatCount", () => {
-  test("uses singular form for 1", () => {
-    expect(formatCount(1, "line", "lines")).toBe("1 line");
-  });
-
-  test("uses plural form for 0", () => {
-    expect(formatCount(0, "line", "lines")).toBe("0 lines");
-  });
-
-  test("uses plural form for 2+", () => {
-    expect(formatCount(3, "line", "lines")).toBe("3 lines");
-  });
-});
-
-describe("serializeToolInputPreview", () => {
-  test("delegates serialization to safeJsonStringify", () => {
-    mockedStringify.mockReturnValue('{"key":"value"}');
-    const result = serializeToolInputPreview({ key: "value" });
-    expect(mockedStringify).toHaveBeenCalledWith({ key: "value" });
-    expect(result).toBe('{"key":"value"}');
-  });
-
-  test("returns empty string when safeJsonStringify returns undefined", () => {
-    mockedStringify.mockReturnValue(undefined);
-    expect(serializeToolInputPreview({})).toBe("");
-  });
-
-  test("returns empty string when serialized value is '{}'", () => {
-    mockedStringify.mockReturnValue("{}");
-    expect(serializeToolInputPreview({})).toBe("");
-  });
-
-  test("returns empty string when serialized value is 'null'", () => {
-    mockedStringify.mockReturnValue("null");
-    expect(serializeToolInputPreview(null)).toBe("");
-  });
-
-  test("collapses whitespace in serialized output", () => {
-    mockedStringify.mockReturnValue('{\n  "key":  "val"\n}');
-    const result = serializeToolInputPreview({});
-    expect(result).toBe('{ "key": "val" }');
-  });
-});

package/test/tool-input-prompt-formatters.test.ts

@@ -1,115 +0,0 @@
-import { describe, expect, test } from "vitest";
-
-import {
-  formatEditInputForPrompt,
-  formatReadInputForPrompt,
-  formatWriteInputForPrompt,
-  getPromptPath,
-} from "#src/tool-input-prompt-formatters";
-
-describe("getPromptPath", () => {
-  test("returns path from 'path' key", () => {
-    expect(getPromptPath({ path: "/foo/bar" })).toBe("/foo/bar");
-  });
-
-  test("falls back to 'file_path' key", () => {
-    expect(getPromptPath({ file_path: "/baz" })).toBe("/baz");
-  });
-
-  test("returns null when neither key is present", () => {
-    expect(getPromptPath({})).toBeNull();
-  });
-
-  test("returns null when path is empty string", () => {
-    expect(getPromptPath({ path: "" })).toBeNull();
-  });
-});
-
-describe("formatEditInputForPrompt", () => {
-  test("returns path-only description when no edits provided", () => {
-    const result = formatEditInputForPrompt({ path: "/foo.ts" });
-    expect(result).toBe("for '/foo.ts' with edit input");
-  });
-
-  test("formats single replacement with line counts", () => {
-    const result = formatEditInputForPrompt({
-      path: "/foo.ts",
-      edits: [{ oldText: "line1\nline2", newText: "replaced" }],
-    });
-    expect(result).toContain("for '/foo.ts'");
-    expect(result).toContain("1 replacement");
-    expect(result).toContain("2 lines");
-    expect(result).toContain("1 line");
-  });
-
-  test("formats multiple replacements mentioning additional edits", () => {
-    const result = formatEditInputForPrompt({
-      path: "/foo.ts",
-      edits: [
-        { oldText: "a", newText: "b" },
-        { oldText: "c", newText: "d" },
-        { oldText: "e", newText: "f" },
-      ],
-    });
-    expect(result).toContain("3 replacements");
-    expect(result).toContain("2 additional edits");
-  });
-
-  test("falls back to oldText/newText when no edits array", () => {
-    const result = formatEditInputForPrompt({
-      path: "/bar.ts",
-      oldText: "old",
-      newText: "new",
-    });
-    expect(result).toContain("for '/bar.ts'");
-    expect(result).toContain("1 replacement");
-  });
-
-  test("works without a path", () => {
-    const result = formatEditInputForPrompt({
-      edits: [{ oldText: "x", newText: "y" }],
-    });
-    expect(result).not.toContain("for '");
-    expect(result).toContain("1 replacement");
-  });
-});
-
-describe("formatWriteInputForPrompt", () => {
-  test("includes path, line count, and character count", () => {
-    const result = formatWriteInputForPrompt({
-      path: "/out.ts",
-      content: "line1\nline2",
-    });
-    expect(result).toContain("for '/out.ts'");
-    expect(result).toContain("2 lines");
-    expect(result).toContain("11 characters");
-  });
-
-  test("handles missing content as empty", () => {
-    const result = formatWriteInputForPrompt({ path: "/out.ts" });
-    expect(result).toContain("0 lines");
-    expect(result).toContain("0 characters");
-  });
-});
-
-describe("formatReadInputForPrompt", () => {
-  test("includes path", () => {
-    expect(formatReadInputForPrompt({ path: "/src/foo.ts" })).toBe(
-      "for path '/src/foo.ts'",
-    );
-  });
-
-  test("includes offset and limit when present", () => {
-    const result = formatReadInputForPrompt({
-      path: "/x",
-      offset: 10,
-      limit: 50,
-    });
-    expect(result).toContain("offset 10");
-    expect(result).toContain("limit 50");
-  });
-
-  test("returns empty string when no path and no options", () => {
-    expect(formatReadInputForPrompt({})).toBe("");
-  });
-});