@komarspn/pi-permission-system 16.0.2

package/test/active-agent.test.ts

@@ -0,0 +1,155 @@
+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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,144 @@
+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",
+    );
+  });
+});