@komarspn/pi-permission-system 16.0.2

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

@@ -0,0 +1,109 @@
+import { describe, expect, test } from "vitest";
+
+import {
+  formatMcpInputForPrompt,
+  registerBuiltinToolInputFormatters,
+} from "#src/builtin-tool-input-formatters";
+import { ToolInputFormatterRegistry } from "#src/tool-input-formatter-registry";
+
+// ── formatMcpInputForPrompt ───────────────────────────────────────────────
+
+describe("formatMcpInputForPrompt", () => {
+  test("returns undefined when arguments is absent", () => {
+    expect(formatMcpInputForPrompt({ tool: "exa:search" })).toBeUndefined();
+  });
+
+  test("returns undefined when arguments is an empty object", () => {
+    expect(
+      formatMcpInputForPrompt({ tool: "exa:search", arguments: {} }),
+    ).toBeUndefined();
+  });
+
+  test("returns a summary for a single string argument", () => {
+    const result = formatMcpInputForPrompt({
+      tool: "exa:search",
+      arguments: { query: "typescript generics" },
+    });
+    expect(result).toBeDefined();
+    expect(result).toContain("query");
+    expect(result).toContain("typescript generics");
+    expect(result).toMatch(/^with /);
+  });
+
+  test("returns a comma-separated summary for multiple arguments", () => {
+    const result = formatMcpInputForPrompt({
+      tool: "exa:search",
+      arguments: { query: "test", numResults: 5 },
+    });
+    expect(result).toContain("query");
+    expect(result).toContain("numResults");
+    expect(result).toContain("5");
+  });
+
+  test("renders number arguments without quotes", () => {
+    const result = formatMcpInputForPrompt({
+      arguments: { count: 42 },
+    });
+    expect(result).toContain("42");
+    expect(result).not.toContain('"42"');
+  });
+
+  test("renders boolean arguments without quotes", () => {
+    const result = formatMcpInputForPrompt({
+      arguments: { verbose: true },
+    });
+    expect(result).toContain("true");
+  });
+
+  test("renders array arguments as '[N items]'", () => {
+    const result = formatMcpInputForPrompt({
+      arguments: { ids: [1, 2, 3] },
+    });
+    expect(result).toContain("[3 items]");
+  });
+
+  test("renders nested object arguments as '{…}'", () => {
+    const result = formatMcpInputForPrompt({
+      arguments: { filter: { type: "file" } },
+    });
+    expect(result).toContain("{…}");
+  });
+
+  test("truncates the full summary when it exceeds the limit", () => {
+    // Need multiple long-valued args so the joined summary exceeds 160 chars
+    const result = formatMcpInputForPrompt({
+      arguments: {
+        first: "x".repeat(80),
+        second: "y".repeat(80),
+        third: "z".repeat(80),
+      },
+    });
+    expect(result).toBeDefined();
+    expect(result!.endsWith("…")).toBe(true);
+  });
+
+  test("truncates long string argument values", () => {
+    const result = formatMcpInputForPrompt({
+      arguments: { query: "x".repeat(100) },
+    });
+    expect(result).toBeDefined();
+    // Should not include the full 100-char string verbatim
+    expect(result).not.toContain("x".repeat(100));
+  });
+});
+
+// ── registerBuiltinToolInputFormatters ────────────────────────────────────
+
+describe("registerBuiltinToolInputFormatters", () => {
+  test("registers the mcp formatter in the registry", () => {
+    const registry = new ToolInputFormatterRegistry();
+    registerBuiltinToolInputFormatters(registry);
+    expect(registry.get("mcp")).toBe(formatMcpInputForPrompt);
+  });
+
+  test("throws if called twice (duplicate registration guard)", () => {
+    const registry = new ToolInputFormatterRegistry();
+    registerBuiltinToolInputFormatters(registry);
+    expect(() => registerBuiltinToolInputFormatters(registry)).toThrow("mcp");
+  });
+});

package/test/canonicalize-path.test.ts

@@ -0,0 +1,93 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+
+const realpathSync = vi.hoisted(() => vi.fn<(path: string) => string>());
+
+vi.mock("node:fs", () => ({
+  realpathSync,
+  default: { realpathSync },
+}));
+
+import { canonicalizePath } from "#src/canonicalize-path";
+
+function enoent(p: string): NodeJS.ErrnoException {
+  return Object.assign(new Error(`ENOENT: no such file or directory '${p}'`), {
+    code: "ENOENT",
+  });
+}
+
+describe("canonicalizePath", () => {
+  beforeEach(() => {
+    realpathSync.mockReset();
+  });
+
+  test("returns empty string for empty input", () => {
+    expect(canonicalizePath("")).toBe("");
+  });
+
+  test("returns realpathSync result when path exists", () => {
+    realpathSync.mockReturnValueOnce("/real/projects/app");
+    expect(canonicalizePath("/projects/link")).toBe("/real/projects/app");
+  });
+
+  test("re-appends a non-existent leaf to the canonical parent", () => {
+    realpathSync
+      .mockImplementationOnce(() => {
+        throw enoent("/projects/app/new-file.ts");
+      })
+      .mockReturnValueOnce("/canonical/app");
+    expect(canonicalizePath("/projects/app/new-file.ts")).toBe(
+      "/canonical/app/new-file.ts",
+    );
+  });
+
+  test("walks up multiple levels for a deeply non-existent path", () => {
+    realpathSync
+      .mockImplementationOnce(() => {
+        throw enoent("/projects/app/src/new-file.ts");
+      })
+      .mockImplementationOnce(() => {
+        throw enoent("/projects/app/src");
+      })
+      .mockImplementationOnce(() => {
+        throw enoent("/projects/app");
+      })
+      .mockReturnValueOnce("/canonical/projects");
+    expect(canonicalizePath("/projects/app/src/new-file.ts")).toBe(
+      "/canonical/projects/app/src/new-file.ts",
+    );
+  });
+
+  test("returns input unchanged when walk reaches filesystem root (all ENOENT)", () => {
+    realpathSync.mockImplementation(() => {
+      throw enoent("");
+    });
+    expect(canonicalizePath("/nonexistent/path/file.ts")).toBe(
+      "/nonexistent/path/file.ts",
+    );
+  });
+
+  test("returns input unchanged on ELOOP (symlink loop)", () => {
+    realpathSync.mockImplementation(() => {
+      throw Object.assign(new Error("ELOOP"), { code: "ELOOP" });
+    });
+    expect(canonicalizePath("/some/looping/path")).toBe("/some/looping/path");
+  });
+
+  test("returns input unchanged on EACCES (permission denied)", () => {
+    realpathSync.mockImplementation(() => {
+      throw Object.assign(new Error("EACCES"), { code: "EACCES" });
+    });
+    expect(canonicalizePath("/restricted/path")).toBe("/restricted/path");
+  });
+
+  test("handles ENOTDIR by walking up (like ENOENT)", () => {
+    realpathSync
+      .mockImplementationOnce(() => {
+        throw Object.assign(new Error("ENOTDIR"), { code: "ENOTDIR" });
+      })
+      .mockReturnValueOnce("/real/parent");
+    expect(canonicalizePath("/real/parent/not-a-dir")).toBe(
+      "/real/parent/not-a-dir",
+    );
+  });
+});

package/test/common.test.ts

@@ -0,0 +1,287 @@
+import { afterEach, describe, expect, it, test, vi } from "vitest";
+
+import {
+  extractFrontmatter,
+  getNonEmptyString,
+  isDenyWithReason,
+  isPermissionState,
+  normalizeOptionalPositiveInt,
+  normalizeOptionalStringArray,
+  parseSimpleYamlMap,
+  toRecord,
+} from "#src/common";
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("toRecord", () => {
+  test("returns empty object for null", () => {
+    expect(toRecord(null)).toEqual({});
+  });
+
+  test("returns empty object for undefined", () => {
+    expect(toRecord(undefined)).toEqual({});
+  });
+
+  test("returns empty object for a string", () => {
+    expect(toRecord("hello")).toEqual({});
+  });
+
+  test("returns empty object for a number", () => {
+    expect(toRecord(42)).toEqual({});
+  });
+
+  test("returns empty object for an array", () => {
+    expect(toRecord(["a", "b"])).toEqual({});
+  });
+
+  test("returns the object itself for a plain object", () => {
+    const input = { a: 1, b: "two" };
+    expect(toRecord(input)).toBe(input);
+  });
+
+  test("returns the object for a nested object", () => {
+    const input = { x: { y: 3 } };
+    expect(toRecord(input)).toBe(input);
+  });
+});
+
+describe("getNonEmptyString", () => {
+  test("returns null for non-string values", () => {
+    expect(getNonEmptyString(null)).toBeNull();
+    expect(getNonEmptyString(undefined)).toBeNull();
+    expect(getNonEmptyString(42)).toBeNull();
+    expect(getNonEmptyString({})).toBeNull();
+    expect(getNonEmptyString([])).toBeNull();
+  });
+
+  test("returns null for empty string", () => {
+    expect(getNonEmptyString("")).toBeNull();
+  });
+
+  test("returns null for whitespace-only string", () => {
+    expect(getNonEmptyString("   ")).toBeNull();
+    expect(getNonEmptyString("\t\n")).toBeNull();
+  });
+
+  test("returns trimmed string for valid string", () => {
+    expect(getNonEmptyString("hello")).toBe("hello");
+    expect(getNonEmptyString("  hello  ")).toBe("hello");
+  });
+
+  test("returns single non-whitespace character", () => {
+    expect(getNonEmptyString("a")).toBe("a");
+  });
+});
+
+describe("isPermissionState", () => {
+  test("returns true for 'allow'", () => {
+    expect(isPermissionState("allow")).toBe(true);
+  });
+
+  test("returns true for 'deny'", () => {
+    expect(isPermissionState("deny")).toBe(true);
+  });
+
+  test("returns true for 'ask'", () => {
+    expect(isPermissionState("ask")).toBe(true);
+  });
+
+  test("returns false for unrecognized strings", () => {
+    expect(isPermissionState("ALLOW")).toBe(false);
+    expect(isPermissionState("permit")).toBe(false);
+    expect(isPermissionState("")).toBe(false);
+    expect(isPermissionState("block")).toBe(false);
+  });
+
+  test("returns false for non-string types", () => {
+    expect(isPermissionState(null)).toBe(false);
+    expect(isPermissionState(undefined)).toBe(false);
+    expect(isPermissionState(1)).toBe(false);
+    expect(isPermissionState({})).toBe(false);
+  });
+});
+
+describe("isDenyWithReason", () => {
+  test("returns true for { action: 'deny' } without a reason", () => {
+    expect(isDenyWithReason({ action: "deny" })).toBe(true);
+  });
+
+  test("returns true for { action: 'deny', reason: '...' }", () => {
+    expect(isDenyWithReason({ action: "deny", reason: "Use pnpm" })).toBe(true);
+  });
+
+  test("returns false for non-deny actions", () => {
+    expect(isDenyWithReason({ action: "allow" })).toBe(false);
+    expect(isDenyWithReason({ action: "ask" })).toBe(false);
+  });
+
+  test("returns false for a non-string reason", () => {
+    expect(isDenyWithReason({ action: "deny", reason: 42 })).toBe(false);
+    expect(isDenyWithReason({ action: "deny", reason: null })).toBe(false);
+  });
+
+  test("returns false for non-object types", () => {
+    expect(isDenyWithReason(null)).toBe(false);
+    expect(isDenyWithReason(undefined)).toBe(false);
+    expect(isDenyWithReason("deny")).toBe(false);
+    expect(isDenyWithReason(["deny"])).toBe(false);
+  });
+});
+
+describe("extractFrontmatter", () => {
+  test("returns empty string when no frontmatter delimiter", () => {
+    expect(extractFrontmatter("# Hello\nSome content")).toBe("");
+  });
+
+  test("returns empty string when only opening delimiter with no closing", () => {
+    expect(extractFrontmatter("---\nkey: value")).toBe("");
+  });
+
+  test("returns frontmatter body between delimiters", () => {
+    const markdown = "---\nissue: 1\ntitle: Test\n---\n# Content";
+    expect(extractFrontmatter(markdown)).toBe("issue: 1\ntitle: Test");
+  });
+
+  test("returns empty string when file does not start with ---", () => {
+    expect(extractFrontmatter("content\n---\nkey: val\n---")).toBe("");
+  });
+
+  test("handles CRLF line endings", () => {
+    const markdown = "---\r\nissue: 5\r\n---\r\n# Content";
+    expect(extractFrontmatter(markdown)).toBe("issue: 5");
+  });
+
+  test("returns empty string for empty string input", () => {
+    expect(extractFrontmatter("")).toBe("");
+  });
+
+  test("returns empty frontmatter for --- \\n--- with nothing between", () => {
+    const markdown = "---\n---\n# Content";
+    expect(extractFrontmatter(markdown)).toBe("");
+  });
+});
+
+describe("parseSimpleYamlMap", () => {
+  test("returns empty object for empty string", () => {
+    expect(parseSimpleYamlMap("")).toEqual({});
+  });
+
+  test("parses simple key-value pairs", () => {
+    const yaml = "issue: 21\ntitle: Test";
+    expect(parseSimpleYamlMap(yaml)).toEqual({ issue: "21", title: "Test" });
+  });
+
+  test("strips surrounding quotes from values", () => {
+    const yaml = 'title: "My Title"';
+    expect(parseSimpleYamlMap(yaml)).toEqual({ title: "My Title" });
+
+    const yaml2 = "title: 'My Title'";
+    expect(parseSimpleYamlMap(yaml2)).toEqual({ title: "My Title" });
+  });
+
+  test("skips lines without colon or with colon at position 0", () => {
+    const yaml = "no separator here\n:starts-with-colon: val\nkey: val";
+    const result = parseSimpleYamlMap(yaml);
+    expect(result.key).toBe("val");
+    expect(result["no separator here"]).toBeUndefined();
+  });
+
+  test("skips comment lines", () => {
+    const yaml = "# This is a comment\nkey: value";
+    expect(parseSimpleYamlMap(yaml)).toEqual({ key: "value" });
+  });
+
+  test("skips blank lines", () => {
+    const yaml = "\n\nkey: value\n\n";
+    expect(parseSimpleYamlMap(yaml)).toEqual({ key: "value" });
+  });
+
+  test("parses nested map (child indented under parent)", () => {
+    const yaml = "parent:\n  child: nested_value";
+    const result = parseSimpleYamlMap(yaml);
+    expect(result.parent).toEqual({ child: "nested_value" });
+  });
+
+  test("handles multi-line values correctly (second line is new key)", () => {
+    const yaml = "key1: val1\nkey2: val2";
+    const result = parseSimpleYamlMap(yaml);
+    expect(result.key1).toBe("val1");
+    expect(result.key2).toBe("val2");
+  });
+
+  test("strips quotes from keys", () => {
+    const yaml = '"quoted-key": value';
+    const result = parseSimpleYamlMap(yaml);
+    expect(result["quoted-key"]).toBe("value");
+  });
+});
+
+describe("normalizeOptionalStringArray", () => {
+  it("returns the array for a valid string array", () => {
+    expect(normalizeOptionalStringArray(["a", "b", "c"])).toEqual([
+      "a",
+      "b",
+      "c",
+    ]);
+  });
+
+  it("returns an empty array for an empty array", () => {
+    expect(normalizeOptionalStringArray([])).toEqual([]);
+  });
+
+  it("returns undefined for a plain string", () => {
+    expect(normalizeOptionalStringArray("x")).toBeUndefined();
+  });
+
+  it("returns undefined for a number", () => {
+    expect(normalizeOptionalStringArray(42)).toBeUndefined();
+  });
+
+  it("returns undefined for a plain object", () => {
+    expect(normalizeOptionalStringArray({ a: "b" })).toBeUndefined();
+  });
+
+  it("returns undefined for a mixed-type array", () => {
+    expect(normalizeOptionalStringArray(["a", 1])).toBeUndefined();
+  });
+
+  it("returns undefined for undefined", () => {
+    expect(normalizeOptionalStringArray(undefined)).toBeUndefined();
+  });
+
+  it("returns undefined for null", () => {
+    expect(normalizeOptionalStringArray(null)).toBeUndefined();
+  });
+});
+
+describe("normalizeOptionalPositiveInt", () => {
+  it("returns the value for a valid positive integer", () => {
+    expect(normalizeOptionalPositiveInt(1)).toBe(1);
+    expect(normalizeOptionalPositiveInt(200)).toBe(200);
+    expect(normalizeOptionalPositiveInt(9999)).toBe(9999);
+  });
+
+  it("returns undefined for zero", () => {
+    expect(normalizeOptionalPositiveInt(0)).toBeUndefined();
+  });
+
+  it("returns undefined for negative integers", () => {
+    expect(normalizeOptionalPositiveInt(-1)).toBeUndefined();
+    expect(normalizeOptionalPositiveInt(-100)).toBeUndefined();
+  });
+
+  it("returns undefined for non-integer numbers (floats)", () => {
+    expect(normalizeOptionalPositiveInt(400.5)).toBeUndefined();
+    expect(normalizeOptionalPositiveInt(1.1)).toBeUndefined();
+  });
+
+  it("returns undefined for non-number types", () => {
+    expect(normalizeOptionalPositiveInt("200")).toBeUndefined();
+    expect(normalizeOptionalPositiveInt(true)).toBeUndefined();
+    expect(normalizeOptionalPositiveInt(null)).toBeUndefined();
+    expect(normalizeOptionalPositiveInt(undefined)).toBeUndefined();
+    expect(normalizeOptionalPositiveInt({})).toBeUndefined();
+  });
+});