@gotgenes/pi-permission-system 8.2.0 → 8.3.0

package/test/service.test.ts

@@ -6,6 +6,7 @@ import {
   publishPermissionsService,
   unpublishPermissionsService,
 } from "#src/service";
+import { ToolInputFormatterRegistry } from "#src/tool-input-formatter-registry";
 import type { PermissionCheckResult } from "#src/types";
 
 // ── helpers ────────────────────────────────────────────────────────────────
@@ -16,6 +17,7 @@ function makeService(
   return {
     checkPermission: vi.fn(),
     getToolPermission: vi.fn(),
+    registerToolInputFormatter: vi.fn(),
     ...overrides,
   };
 }
@@ -136,6 +138,7 @@ describe("service adapter delegation", () => {
       getToolPermission(toolName, agentName) {
         return getToolPermissionFn(toolName, agentName);
       },
+      registerToolInputFormatter: vi.fn(),
     };
 
     publishPermissionsService(service);
@@ -157,6 +160,7 @@ describe("service adapter delegation", () => {
       getToolPermission(toolName, agentName) {
         return getToolPermissionFn(toolName, agentName);
       },
+      registerToolInputFormatter: vi.fn(),
     };
 
     publishPermissionsService(service);
@@ -182,3 +186,51 @@ describe("service adapter delegation", () => {
     expect(checkPermission).toHaveBeenCalledWith("read", {}, undefined, []);
   });
 });
+
+// ── registerToolInputFormatter delegation ─────────────────────────────────
+
+describe("registerToolInputFormatter delegation", () => {
+  afterEach(() => {
+    unpublishPermissionsService();
+  });
+
+  it("delegates to the registry and returns its disposer", () => {
+    const registry = new ToolInputFormatterRegistry();
+    const formatter = () => "preview";
+
+    const service = makeService({
+      registerToolInputFormatter(toolName, fmt) {
+        return registry.register(toolName, fmt);
+      },
+    });
+
+    publishPermissionsService(service);
+    const dispose = getPermissionsService()!.registerToolInputFormatter(
+      "my-tool",
+      formatter,
+    );
+
+    // Registry received the registration
+    expect(registry.get("my-tool")).toBe(formatter);
+
+    // Disposer returned from service removes it from the registry
+    dispose();
+    expect(registry.get("my-tool")).toBeUndefined();
+  });
+
+  it("throws when a formatter is already registered for the tool name", () => {
+    const registry = new ToolInputFormatterRegistry();
+    registry.register("my-tool", () => undefined);
+
+    const service = makeService({
+      registerToolInputFormatter(toolName, fmt) {
+        return registry.register(toolName, fmt);
+      },
+    });
+
+    publishPermissionsService(service);
+    expect(() =>
+      getPermissionsService()!.registerToolInputFormatter("my-tool", () => ""),
+    ).toThrow("my-tool");
+  });
+});

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

@@ -0,0 +1,75 @@
+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-preview-formatter.test.ts

@@ -1,5 +1,7 @@
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 
+import type { ToolInputFormatterLookup } from "#src/tool-input-formatter-registry";
+
 // Mock logging collaborator before importing the module under test.
 vi.mock("../src/logging.js", () => ({
   safeJsonStringify: vi.fn((value: unknown) => JSON.stringify(value)),
@@ -201,6 +203,77 @@ describe("ToolPreviewFormatter.formatToolInputForPrompt", () => {
   });
 });
 
+// ── formatToolInputForPrompt (custom formatter seam) ───────────────────────
+
+describe("ToolPreviewFormatter.formatToolInputForPrompt — custom formatter seam", () => {
+  function makeLookup(
+    toolName: string,
+    result: string | undefined,
+  ): ToolInputFormatterLookup {
+    return {
+      get: (name) => (name === toolName ? () => result : undefined),
+    };
+  }
+
+  test("uses a custom formatter's string result verbatim, bypassing the switch", () => {
+    const lookup = makeLookup("my-tool", "custom preview");
+    const f = new ToolPreviewFormatter(
+      {
+        toolInputPreviewMaxLength: TOOL_INPUT_PREVIEW_MAX_LENGTH,
+        toolTextSummaryMaxLength: TOOL_TEXT_SUMMARY_MAX_LENGTH,
+        toolInputLogPreviewMaxLength: TOOL_INPUT_LOG_PREVIEW_MAX_LENGTH,
+      },
+      lookup,
+    );
+    expect(f.formatToolInputForPrompt("my-tool", {})).toBe("custom preview");
+  });
+
+  test("falls through to the built-in switch when custom formatter returns undefined", () => {
+    mockedStringify.mockReturnValue('{"x":1}');
+    const lookup = makeLookup("unknown-tool", undefined);
+    const f = new ToolPreviewFormatter(
+      {
+        toolInputPreviewMaxLength: TOOL_INPUT_PREVIEW_MAX_LENGTH,
+        toolTextSummaryMaxLength: TOOL_TEXT_SUMMARY_MAX_LENGTH,
+        toolInputLogPreviewMaxLength: TOOL_INPUT_LOG_PREVIEW_MAX_LENGTH,
+      },
+      lookup,
+    );
+    // Falls through to JSON default for unknown tools
+    expect(f.formatToolInputForPrompt("unknown-tool", { x: 1 })).toContain(
+      '{"x":1}',
+    );
+  });
+
+  test("custom formatter for a built-in tool overrides the built-in preview", () => {
+    const lookup = makeLookup("read", "custom read summary");
+    const f = new ToolPreviewFormatter(
+      {
+        toolInputPreviewMaxLength: TOOL_INPUT_PREVIEW_MAX_LENGTH,
+        toolTextSummaryMaxLength: TOOL_TEXT_SUMMARY_MAX_LENGTH,
+        toolInputLogPreviewMaxLength: TOOL_INPUT_LOG_PREVIEW_MAX_LENGTH,
+      },
+      lookup,
+    );
+    // Would normally use formatReadInputForPrompt; custom overrides it
+    expect(f.formatToolInputForPrompt("read", { path: "/foo.ts" })).toBe(
+      "custom read summary",
+    );
+  });
+
+  test("absent lookup preserves current behaviour for all tool types", () => {
+    const f = new ToolPreviewFormatter({
+      toolInputPreviewMaxLength: TOOL_INPUT_PREVIEW_MAX_LENGTH,
+      toolTextSummaryMaxLength: TOOL_TEXT_SUMMARY_MAX_LENGTH,
+      toolInputLogPreviewMaxLength: TOOL_INPUT_LOG_PREVIEW_MAX_LENGTH,
+    });
+    // Built-in path still works
+    expect(f.formatToolInputForPrompt("read", { path: "/foo.ts" })).toContain(
+      "/foo.ts",
+    );
+  });
+});
+
 // ── formatGenericToolInputForLog ──────────────────────────────────────────
 
 describe("ToolPreviewFormatter.formatGenericToolInputForLog", () => {