@gotgenes/pi-permission-system 2.0.0 → 3.0.1

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

@@ -0,0 +1,452 @@
+import { afterEach, 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.js";
+import {
+  countTextLines,
+  formatCount,
+  formatEditInputForPrompt,
+  formatGenericToolInputForLog,
+  formatReadInputForPrompt,
+  formatSearchInputForPrompt,
+  formatToolInputForPrompt,
+  formatWriteInputForPrompt,
+  getPermissionLogContext,
+  getPromptPath,
+  getToolInputPreviewForLog,
+  sanitizeInlineText,
+  serializeToolInputPreview,
+  TOOL_INPUT_LOG_PREVIEW_MAX_LENGTH,
+  TOOL_INPUT_PREVIEW_MAX_LENGTH,
+  TOOL_TEXT_SUMMARY_MAX_LENGTH,
+  truncateInlineText,
+} from "../src/tool-input-preview.js";
+import type { PermissionCheckResult } from "../src/types.js";
+
+const mockedStringify = vi.mocked(safeJsonStringify);
+
+afterEach(() => {
+  vi.clearAllMocks();
+  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("sanitizeInlineText", () => {
+  test("collapses whitespace and trims", () => {
+    expect(sanitizeInlineText("  hello   world  ")).toBe("hello world");
+  });
+
+  test("returns 'empty text' for blank string", () => {
+    expect(sanitizeInlineText("")).toBe("empty text");
+    expect(sanitizeInlineText("   ")).toBe("empty text");
+  });
+
+  test("truncates to default TOOL_TEXT_SUMMARY_MAX_LENGTH", () => {
+    const long = "x".repeat(100);
+    const result = sanitizeInlineText(long);
+    expect(result.length).toBeLessThanOrEqual(TOOL_TEXT_SUMMARY_MAX_LENGTH + 1); // +1 for ellipsis char
+    expect(result).toContain("…");
+  });
+
+  test("respects custom maxLength", () => {
+    const result = sanitizeInlineText("hello world", 5);
+    expect(result).toBe("hello…");
+  });
+});
+
+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("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("");
+  });
+});
+
+describe("formatSearchInputForPrompt", () => {
+  test("includes pattern and path", () => {
+    const result = formatSearchInputForPrompt("grep", {
+      pattern: "TODO",
+      path: "/src",
+    });
+    expect(result).toContain("pattern 'TODO'");
+    expect(result).toContain("path '/src'");
+  });
+
+  test("includes glob when present", () => {
+    const result = formatSearchInputForPrompt("find", { glob: "*.ts" });
+    expect(result).toContain("glob '*.ts'");
+  });
+
+  test("uses 'current working directory' for find/grep/ls without path", () => {
+    for (const toolName of ["find", "grep", "ls"]) {
+      const result = formatSearchInputForPrompt(toolName, {});
+      expect(result).toContain("current working directory");
+    }
+  });
+
+  test("returns empty string for other tools with no input", () => {
+    expect(formatSearchInputForPrompt("other", {})).toBe("");
+  });
+});
+
+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" }');
+  });
+});
+
+describe("formatToolInputForPrompt", () => {
+  test("dispatches 'edit' to formatEditInputForPrompt", () => {
+    mockedStringify.mockReturnValue(undefined);
+    const result = formatToolInputForPrompt("edit", {
+      path: "/foo.ts",
+      edits: [],
+    });
+    expect(result).toContain("for '/foo.ts'");
+  });
+
+  test("dispatches 'write' to formatWriteInputForPrompt", () => {
+    const result = formatToolInputForPrompt("write", {
+      path: "/out.ts",
+      content: "hi",
+    });
+    expect(result).toContain("for '/out.ts'");
+  });
+
+  test("dispatches 'read' to formatReadInputForPrompt", () => {
+    const result = formatToolInputForPrompt("read", { path: "/src/x.ts" });
+    expect(result).toContain("path '/src/x.ts'");
+  });
+
+  test("dispatches 'find'/'grep'/'ls' to formatSearchInputForPrompt", () => {
+    for (const tool of ["find", "grep", "ls"]) {
+      const result = formatToolInputForPrompt(tool, {});
+      expect(result).toContain("current working directory");
+    }
+  });
+
+  test("falls back to JSON preview for unknown tools", () => {
+    mockedStringify.mockReturnValue('{"x":1}');
+    const result = formatToolInputForPrompt("unknown", { x: 1 });
+    expect(result).toContain('{"x":1}');
+  });
+});
+
+describe("formatGenericToolInputForLog", () => {
+  test("returns undefined when serialization yields empty string", () => {
+    mockedStringify.mockReturnValue(undefined);
+    expect(formatGenericToolInputForLog({})).toBeUndefined();
+  });
+
+  test("returns prefixed input preview", () => {
+    mockedStringify.mockReturnValue('{"k":"v"}');
+    expect(formatGenericToolInputForLog({ k: "v" })).toBe('input {"k":"v"}');
+  });
+
+  test("truncates to TOOL_INPUT_LOG_PREVIEW_MAX_LENGTH", () => {
+    const longJson = `{"k":"${"x".repeat(2000)}"}`;
+    mockedStringify.mockReturnValue(longJson);
+    const result = formatGenericToolInputForLog({});
+    expect(result).toBeDefined();
+    // result is "input " + truncated, so total > TOOL_INPUT_LOG_PREVIEW_MAX_LENGTH by "input ".length
+    const preview = result!.slice("input ".length);
+    expect(preview.length).toBeLessThanOrEqual(
+      TOOL_INPUT_LOG_PREVIEW_MAX_LENGTH + 1,
+    );
+  });
+});
+
+describe("getToolInputPreviewForLog", () => {
+  const pathBearingTools = new Set(["read", "write", "edit"]);
+
+  test("returns undefined for bash tool", () => {
+    const result: PermissionCheckResult = {
+      toolName: "bash",
+      state: "allow",
+      source: "tool",
+    };
+    expect(
+      getToolInputPreviewForLog(result, { command: "ls" }, pathBearingTools),
+    ).toBeUndefined();
+  });
+
+  test("returns undefined for mcp tool", () => {
+    const result: PermissionCheckResult = {
+      toolName: "mcp",
+      state: "allow",
+      source: "tool",
+    };
+    expect(
+      getToolInputPreviewForLog(result, {}, pathBearingTools),
+    ).toBeUndefined();
+  });
+
+  test("returns undefined for mcp source", () => {
+    const result: PermissionCheckResult = {
+      toolName: "some-server:some-tool",
+      state: "allow",
+      source: "mcp",
+    };
+    expect(
+      getToolInputPreviewForLog(result, {}, pathBearingTools),
+    ).toBeUndefined();
+  });
+
+  test("returns path-based preview for path-bearing tools", () => {
+    const result: PermissionCheckResult = {
+      toolName: "read",
+      state: "allow",
+      source: "tool",
+    };
+    const preview = getToolInputPreviewForLog(
+      result,
+      { path: "/src/foo.ts" },
+      pathBearingTools,
+    );
+    expect(preview).toContain("/src/foo.ts");
+  });
+
+  test("returns generic JSON preview for non-path-bearing tools", () => {
+    mockedStringify.mockReturnValue('{"n":1}');
+    const result: PermissionCheckResult = {
+      toolName: "task",
+      state: "allow",
+      source: "tool",
+    };
+    const preview = getToolInputPreviewForLog(
+      result,
+      { n: 1 },
+      pathBearingTools,
+    );
+    expect(preview).toContain('{"n":1}');
+  });
+});
+
+describe("getPermissionLogContext", () => {
+  const pathBearingTools = new Set(["read", "write", "edit"]);
+
+  test("returns command, target, and toolInputPreview", () => {
+    const result: PermissionCheckResult = {
+      toolName: "bash",
+      state: "allow",
+      source: "tool",
+      command: "ls -la",
+    };
+    const ctx = getPermissionLogContext(result, {}, pathBearingTools);
+    expect(ctx.command).toBe("ls -la");
+    expect(ctx.target).toBeUndefined();
+    expect(ctx.toolInputPreview).toBeUndefined();
+  });
+
+  test("includes toolInputPreview for non-bash path-bearing tools", () => {
+    const result: PermissionCheckResult = {
+      toolName: "read",
+      state: "allow",
+      source: "tool",
+    };
+    const ctx = getPermissionLogContext(
+      result,
+      { path: "/foo.ts" },
+      pathBearingTools,
+    );
+    expect(ctx.toolInputPreview).toContain("/foo.ts");
+  });
+});

package/tests/tool-registry.test.ts

@@ -0,0 +1,155 @@
+import { afterEach, describe, expect, test, vi } from "vitest";
+
+import {
+  checkRequestedToolRegistration,
+  getToolNameFromValue,
+} from "../src/tool-registry.js";
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("getToolNameFromValue", () => {
+  test("returns string value directly", () => {
+    expect(getToolNameFromValue("read")).toBe("read");
+  });
+
+  test("returns null for empty string", () => {
+    expect(getToolNameFromValue("")).toBeNull();
+  });
+
+  test("returns null for whitespace-only string", () => {
+    expect(getToolNameFromValue("   ")).toBeNull();
+  });
+
+  test("returns null for null", () => {
+    expect(getToolNameFromValue(null)).toBeNull();
+  });
+
+  test("returns null for undefined", () => {
+    expect(getToolNameFromValue(undefined)).toBeNull();
+  });
+
+  test("extracts toolName from object", () => {
+    expect(getToolNameFromValue({ toolName: "write" })).toBe("write");
+  });
+
+  test("extracts name from object", () => {
+    expect(getToolNameFromValue({ name: "edit" })).toBe("edit");
+  });
+
+  test("extracts tool from object", () => {
+    expect(getToolNameFromValue({ tool: "bash" })).toBe("bash");
+  });
+
+  test("prefers toolName over name over tool", () => {
+    expect(
+      getToolNameFromValue({
+        toolName: "first",
+        name: "second",
+        tool: "third",
+      }),
+    ).toBe("first");
+  });
+
+  test("falls back to name when toolName is empty", () => {
+    expect(getToolNameFromValue({ toolName: "", name: "edit" })).toBe("edit");
+  });
+
+  test("returns null for object with no recognised keys", () => {
+    expect(getToolNameFromValue({ unknown: "read" })).toBeNull();
+  });
+
+  test("returns null for number input", () => {
+    expect(getToolNameFromValue(42)).toBeNull();
+  });
+});
+
+describe("checkRequestedToolRegistration", () => {
+  test("returns missing-tool-name for null requested name", () => {
+    const result = checkRequestedToolRegistration(null, []);
+    expect(result.status).toBe("missing-tool-name");
+  });
+
+  test("returns missing-tool-name for whitespace-only requested name", () => {
+    const result = checkRequestedToolRegistration("   ", []);
+    expect(result.status).toBe("missing-tool-name");
+  });
+
+  test("returns registered when tool name matches a string entry", () => {
+    const result = checkRequestedToolRegistration("read", ["read", "write"]);
+    expect(result.status).toBe("registered");
+    if (result.status === "registered") {
+      expect(result.requestedToolName).toBe("read");
+      expect(result.normalizedToolName).toBe("read");
+    }
+  });
+
+  test("returns registered when tool name matches an object entry by name", () => {
+    const result = checkRequestedToolRegistration("edit", [{ name: "edit" }]);
+    expect(result.status).toBe("registered");
+  });
+
+  test("returns registered when tool name matches an object entry by toolName", () => {
+    const result = checkRequestedToolRegistration("bash", [
+      { toolName: "bash" },
+    ]);
+    expect(result.status).toBe("registered");
+  });
+
+  test("returns unregistered when tool is not in the list", () => {
+    const result = checkRequestedToolRegistration("ghost", ["read", "write"]);
+    expect(result.status).toBe("unregistered");
+    if (result.status === "unregistered") {
+      expect(result.requestedToolName).toBe("ghost");
+      expect(result.availableToolNames).toContain("read");
+      expect(result.availableToolNames).toContain("write");
+    }
+  });
+
+  test("available tool names are sorted alphabetically", () => {
+    const result = checkRequestedToolRegistration("ghost", [
+      "write",
+      "read",
+      "edit",
+    ]);
+    if (result.status === "unregistered") {
+      expect(result.availableToolNames).toEqual(["edit", "read", "write"]);
+    }
+  });
+
+  test("resolves alias: requested alias maps to registered canonical name", () => {
+    const aliases = { Execute: "bash" };
+    const result = checkRequestedToolRegistration("Execute", ["bash"], aliases);
+    expect(result.status).toBe("registered");
+    if (result.status === "registered") {
+      expect(result.normalizedToolName).toBe("bash");
+    }
+  });
+
+  test("resolves alias: registered canonical is found via reverse alias lookup", () => {
+    // "bash" is registered; alias maps "Execute" → "bash"
+    // requesting "bash" directly should still resolve via the alias table
+    const aliases = { Execute: "bash" };
+    const result = checkRequestedToolRegistration("bash", ["bash"], aliases);
+    expect(result.status).toBe("registered");
+  });
+
+  test("returns unregistered with empty availableToolNames for empty tool list", () => {
+    const result = checkRequestedToolRegistration("read", []);
+    expect(result.status).toBe("unregistered");
+    if (result.status === "unregistered") {
+      expect(result.availableToolNames).toEqual([]);
+    }
+  });
+
+  test("skips tool list entries that yield no name", () => {
+    const result = checkRequestedToolRegistration("read", [
+      null,
+      {},
+      { unrelated: "x" },
+      "read",
+    ]);
+    expect(result.status).toBe("registered");
+  });
+});