@gotgenes/pi-permission-system 18.1.1 → 18.1.2

package/test/active-agent.test.ts

@@ -1,155 +0,0 @@
-import { afterEach, describe, expect, test, vi } from "vitest";
-import {
-  ACTIVE_AGENT_TAG_REGEX,
-  type ActiveAgentContext,
-  getActiveAgentName,
-  getActiveAgentNameFromSystemPrompt,
-  normalizeAgentName,
-  type SessionEntryView,
-} from "#src/active-agent";
-
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-
-function makeCtx(entries: SessionEntryView[]): ActiveAgentContext {
-  return {
-    sessionManager: {
-      getEntries: vi.fn(() => entries),
-    },
-  };
-}
-
-describe("ACTIVE_AGENT_TAG_REGEX", () => {
-  test("matches double-quoted name attribute", () => {
-    const match = '<active_agent name="my-agent">'.match(
-      ACTIVE_AGENT_TAG_REGEX,
-    );
-    expect(match?.[1]).toBe("my-agent");
-  });
-
-  test("matches single-quoted name attribute", () => {
-    const match = "<active_agent name='my-agent'>".match(
-      ACTIVE_AGENT_TAG_REGEX,
-    );
-    expect(match?.[1]).toBe("my-agent");
-  });
-
-  test("is case-insensitive", () => {
-    const match = '<ACTIVE_AGENT name="bot">'.match(ACTIVE_AGENT_TAG_REGEX);
-    expect(match?.[1]).toBe("bot");
-  });
-
-  test("does not match when tag is absent", () => {
-    expect("no tag here".match(ACTIVE_AGENT_TAG_REGEX)).toBeNull();
-  });
-});
-
-describe("normalizeAgentName", () => {
-  test("returns trimmed string for valid input", () => {
-    expect(normalizeAgentName("  my-agent  ")).toBe("my-agent");
-  });
-
-  test("returns null for empty string", () => {
-    expect(normalizeAgentName("")).toBeNull();
-  });
-
-  test("returns null for whitespace-only string", () => {
-    expect(normalizeAgentName("   ")).toBeNull();
-  });
-
-  test("returns null for non-string values", () => {
-    expect(normalizeAgentName(null)).toBeNull();
-    expect(normalizeAgentName(undefined)).toBeNull();
-    expect(normalizeAgentName(42)).toBeNull();
-    expect(normalizeAgentName({})).toBeNull();
-  });
-});
-
-describe("getActiveAgentName", () => {
-  test("returns null when session has no entries", () => {
-    expect(getActiveAgentName(makeCtx([]))).toBeNull();
-  });
-
-  test("returns null when no active_agent custom entry exists", () => {
-    const ctx = makeCtx([{ type: "message", data: { name: "agent" } }]);
-    expect(getActiveAgentName(ctx)).toBeNull();
-  });
-
-  test("returns agent name from active_agent entry", () => {
-    const ctx = makeCtx([
-      { type: "custom", customType: "active_agent", data: { name: "bot" } },
-    ]);
-    expect(getActiveAgentName(ctx)).toBe("bot");
-  });
-
-  test("last-entry-wins: returns name from the last matching entry", () => {
-    const ctx = makeCtx([
-      { type: "custom", customType: "active_agent", data: { name: "first" } },
-      { type: "custom", customType: "active_agent", data: { name: "last" } },
-    ]);
-    expect(getActiveAgentName(ctx)).toBe("last");
-  });
-
-  test("entry with name: null resets agent name to null", () => {
-    const ctx = makeCtx([
-      { type: "custom", customType: "active_agent", data: { name: "bot" } },
-      { type: "custom", customType: "active_agent", data: { name: null } },
-    ]);
-    expect(getActiveAgentName(ctx)).toBeNull();
-  });
-
-  test("skips entries with whitespace-only name and continues scanning", () => {
-    const ctx = makeCtx([
-      { type: "custom", customType: "active_agent", data: { name: "first" } },
-      { type: "custom", customType: "active_agent", data: { name: "   " } },
-    ]);
-    // "   " normalizes to null — not a sentinel reset, keeps scanning backwards
-    expect(getActiveAgentName(ctx)).toBe("first");
-  });
-
-  test("ignores entries with wrong customType", () => {
-    const ctx = makeCtx([
-      { type: "custom", customType: "something_else", data: { name: "bot" } },
-    ]);
-    expect(getActiveAgentName(ctx)).toBeNull();
-  });
-
-  test("ignores entries with wrong type", () => {
-    const ctx = makeCtx([
-      { type: "tool_call", customType: "active_agent", data: { name: "bot" } },
-    ]);
-    expect(getActiveAgentName(ctx)).toBeNull();
-  });
-});
-
-describe("getActiveAgentNameFromSystemPrompt", () => {
-  test("returns null for undefined system prompt", () => {
-    expect(getActiveAgentNameFromSystemPrompt(undefined)).toBeNull();
-  });
-
-  test("returns null for empty system prompt", () => {
-    expect(getActiveAgentNameFromSystemPrompt("")).toBeNull();
-  });
-
-  test("returns null when tag is absent", () => {
-    expect(
-      getActiveAgentNameFromSystemPrompt("You are a helpful assistant."),
-    ).toBeNull();
-  });
-
-  test("extracts agent name from tag in system prompt", () => {
-    const prompt = 'You are helpful.\n<active_agent name="my-bot">\nDo work.';
-    expect(getActiveAgentNameFromSystemPrompt(prompt)).toBe("my-bot");
-  });
-
-  test("returns null when tag name is empty", () => {
-    const prompt = '<active_agent name="">';
-    expect(getActiveAgentNameFromSystemPrompt(prompt)).toBeNull();
-  });
-
-  test("trims whitespace from extracted name", () => {
-    const prompt = '<active_agent name="  trimmed  ">';
-    expect(getActiveAgentNameFromSystemPrompt(prompt)).toBe("trimmed");
-  });
-});

package/test/async-cache.test.ts

@@ -1,48 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-import { memoizeAsyncWithRetry } from "#src/async-cache";
-
-describe("memoizeAsyncWithRetry", () => {
-  it("invokes the factory once and shares the resolved value across calls", async () => {
-    const factory = vi.fn<() => Promise<number>>().mockResolvedValue(42);
-    const memoized = memoizeAsyncWithRetry(factory);
-
-    const results = await Promise.all([memoized(), memoized(), memoized()]);
-
-    expect(results).toEqual([42, 42, 42]);
-    expect(factory).toHaveBeenCalledTimes(1);
-  });
-
-  it("caches the same promise instance on success", async () => {
-    const factory = vi.fn<() => Promise<string>>().mockResolvedValue("parser");
-    const memoized = memoizeAsyncWithRetry(factory);
-
-    await memoized();
-    await memoized();
-
-    expect(factory).toHaveBeenCalledTimes(1);
-  });
-
-  it("surfaces the rejection to the caller each time the factory fails", async () => {
-    const error = new Error("init failed");
-    const factory = vi.fn<() => Promise<number>>().mockRejectedValue(error);
-    const memoized = memoizeAsyncWithRetry(factory);
-
-    await expect(memoized()).rejects.toThrow("init failed");
-    await expect(memoized()).rejects.toThrow("init failed");
-  });
-
-  it("drops a rejected result so the next call re-invokes the factory", async () => {
-    const factory = vi
-      .fn<() => Promise<number>>()
-      .mockRejectedValueOnce(new Error("transient"))
-      .mockResolvedValue(7);
-    const memoized = memoizeAsyncWithRetry(factory);
-
-    await expect(memoized()).rejects.toThrow("transient");
-    const recovered = await memoized();
-
-    expect(recovered).toBe(7);
-    expect(factory).toHaveBeenCalledTimes(2);
-  });
-});

package/test/bash-arity.test.ts

@@ -1,144 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { ARITY, prefix, stripBashCommentLines } from "#src/bash-arity";
-
-describe("ARITY dictionary", () => {
-  it("is exported as a plain object", () => {
-    expect(typeof ARITY).toBe("object");
-  });
-
-  it("maps 'git' to arity 2", () => {
-    expect(ARITY.git).toBe(2);
-  });
-
-  it("maps 'npm run' to arity 3", () => {
-    expect(ARITY["npm run"]).toBe(3);
-  });
-
-  it("maps 'npm' to arity 2 (fallback when 'npm run' does not match)", () => {
-    expect(ARITY.npm).toBe(2);
-  });
-
-  it("maps 'docker compose' to arity 3", () => {
-    expect(ARITY["docker compose"]).toBe(3);
-  });
-
-  it("maps 'docker' to arity 2 (fallback)", () => {
-    expect(ARITY.docker).toBe(2);
-  });
-});
-
-describe("prefix", () => {
-  it("returns empty array for empty input", () => {
-    expect(prefix([])).toEqual([]);
-  });
-
-  it("returns single-element array for a bare known command", () => {
-    // 'git' alone has arity 2 but only 1 token is available — clamp.
-    expect(prefix(["git"])).toEqual(["git"]);
-  });
-
-  it("returns arity-2 prefix for git subcommands", () => {
-    expect(prefix(["git", "checkout", "main"])).toEqual(["git", "checkout"]);
-  });
-
-  it("returns arity-2 prefix for git status with flags", () => {
-    expect(prefix(["git", "status", "--short"])).toEqual(["git", "status"]);
-  });
-
-  it("returns arity-3 prefix for npm run (longest match wins over npm arity-2)", () => {
-    expect(prefix(["npm", "run", "dev"])).toEqual(["npm", "run", "dev"]);
-  });
-
-  it("returns arity-2 prefix for npm install (npm fallback, npm run does not match)", () => {
-    expect(prefix(["npm", "install", "lodash"])).toEqual(["npm", "install"]);
-  });
-
-  it("returns arity-3 prefix for docker compose subcommands", () => {
-    expect(prefix(["docker", "compose", "up", "--build"])).toEqual([
-      "docker",
-      "compose",
-      "up",
-    ]);
-  });
-
-  it("returns arity-2 prefix for docker pull (docker fallback)", () => {
-    expect(prefix(["docker", "pull", "ubuntu"])).toEqual(["docker", "pull"]);
-  });
-
-  it("returns arity-1 prefix for unknown commands", () => {
-    expect(prefix(["unknown-tool", "--flag"])).toEqual(["unknown-tool"]);
-  });
-
-  it("returns arity-1 prefix for rm (args are targets, not subcommands)", () => {
-    expect(prefix(["rm", "-rf", "node_modules"])).toEqual(["rm"]);
-  });
-
-  it("returns arity-1 prefix for cat", () => {
-    expect(prefix(["cat", "file.txt"])).toEqual(["cat"]);
-  });
-
-  it("is case-insensitive: 'Git' looks up as 'git'", () => {
-    // Tokens are preserved as-is; only the lookup key is lowercased.
-    expect(prefix(["Git", "checkout", "main"])).toEqual(["Git", "checkout"]);
-  });
-
-  it("clamps arity to available token count when command is shorter than arity", () => {
-    // npm run has arity 3; only ["npm", "run"] provided → return both.
-    expect(prefix(["npm", "run"])).toEqual(["npm", "run"]);
-  });
-
-  it("returns arity-2 prefix for pnpm run (longest match wins over pnpm)", () => {
-    // pnpm run <script> — arity 3 means include the script name.
-    expect(prefix(["pnpm", "run", "build"])).toEqual(["pnpm", "run", "build"]);
-  });
-
-  it("returns arity-2 prefix for cargo subcommands", () => {
-    expect(prefix(["cargo", "build", "--release"])).toEqual(["cargo", "build"]);
-  });
-
-  it("returns arity-2 prefix for kubectl subcommands", () => {
-    expect(prefix(["kubectl", "get", "pods"])).toEqual(["kubectl", "get"]);
-  });
-
-  it("returns arity-1 for bare 'ls' (args are paths)", () => {
-    expect(prefix(["ls", "-la", "/tmp"])).toEqual(["ls"]);
-  });
-});
-
-describe("stripBashCommentLines", () => {
-  it("removes a single leading comment line", () => {
-    expect(
-      stripBashCommentLines("# Check debug logs\nfind /home -type f"),
-    ).toBe("find /home -type f");
-  });
-
-  it("removes multiple leading comment lines", () => {
-    expect(
-      stripBashCommentLines("# Step 1\n# Step 2\ngit status --short"),
-    ).toBe("git status --short");
-  });
-
-  it("returns empty string when all lines are comments", () => {
-    expect(stripBashCommentLines("# just a comment")).toBe("");
-  });
-
-  it("returns empty string for blank input", () => {
-    expect(stripBashCommentLines("")).toBe("");
-  });
-
-  it("returns the command unchanged when no comment lines are present", () => {
-    expect(stripBashCommentLines("grep -rn foo src/")).toBe(
-      "grep -rn foo src/",
-    );
-  });
-
-  it("trims surrounding whitespace from the result", () => {
-    expect(stripBashCommentLines("\n\n  ls -la  \n")).toBe("ls -la");
-  });
-
-  it("treats indented comment lines as comments", () => {
-    expect(stripBashCommentLines("    # indented comment\necho hi")).toBe(
-      "echo hi",
-    );
-  });
-});