@bdsqqq/pi 0.0.1

package/dist/core/output-buffer.js

@@ -0,0 +1,517 @@
+//#region packages/core/output-buffer/index.ts
+/**
+* output buffer with fixed head + rolling tail.
+*
+* maintains constant memory regardless of output size by keeping:
+* - first N lines (head, fill once then lock)
+* - last M lines (tail, ring buffer, always rolling)
+* - total line count (for truncation message)
+*
+* used by bash tool to show beginning + end of long outputs,
+* rather than only the tail.
+*/
+const DEFAULT_HEAD_LINES = 50;
+const DEFAULT_TAIL_LINES = 50;
+/**
+* truncate an array to head + tail, returning formatted result.
+* simpler than OutputBuffer — for when you have all items upfront (not streaming).
+*
+* @param items - array to truncate
+* @param maxItems - total items to show (split evenly between head/tail)
+* @returns { head, tail, truncated, truncatedCount }
+*/
+function headTail(items, maxItems = 100) {
+	if (items.length <= maxItems) return {
+		head: items,
+		tail: [],
+		truncated: [],
+		truncatedCount: 0
+	};
+	const half = Math.floor(maxItems / 2);
+	const head = items.slice(0, half);
+	const tail = items.slice(-half);
+	const truncated = items.slice(half, -half);
+	return {
+		head,
+		tail,
+		truncated,
+		truncatedCount: truncated.length
+	};
+}
+/**
+* format head+tail arrays with truncation marker.
+* returns a single string with items joined by newlines.
+*/
+function formatHeadTail(items, maxItems = 100, truncatedMsg = (n) => `... [${n} lines truncated] ...`) {
+	const { head, tail, truncatedCount } = headTail(items, maxItems);
+	if (truncatedCount === 0) return head.map(String).join("\n");
+	return [
+		...head.map(String),
+		"",
+		truncatedMsg(truncatedCount),
+		"",
+		...tail.map(String)
+	].join("\n");
+}
+/**
+* truncate raw text to head + tail by characters.
+* for when you have a single string (not lines) that needs truncation.
+*/
+function headTailChars(text, maxChars = 64e3) {
+	const total = text.length;
+	if (total <= maxChars) return {
+		text,
+		truncated: false,
+		totalChars: total
+	};
+	const half = Math.floor(maxChars / 2);
+	const head = text.slice(0, half);
+	const tail = text.slice(-half);
+	return {
+		text: `${head}\n\n... [${total - maxChars} characters truncated] ...\n\n${tail}`,
+		truncated: true,
+		totalChars: total
+	};
+}
+var OutputBuffer = class {
+	head = [];
+	tail = [];
+	headComplete = false;
+	pendingLine = "";
+	totalLines = 0;
+	constructor(maxHead = DEFAULT_HEAD_LINES, maxTail = DEFAULT_TAIL_LINES) {
+		this.maxHead = maxHead;
+		this.maxTail = maxTail;
+	}
+	/**
+	* add a chunk of output. handles partial lines at boundaries.
+	* chunks may end mid-line, so we buffer the incomplete part.
+	*/
+	add(chunk) {
+		const lines = (this.pendingLine + chunk).split("\n");
+		this.pendingLine = lines.pop() ?? "";
+		for (const line of lines) {
+			this.totalLines++;
+			this.addLine(line);
+		}
+	}
+	/**
+	* add a complete line to the appropriate buffer.
+	* fills head first, then rolls tail.
+	*/
+	addLine(line) {
+		if (!this.headComplete && this.head.length < this.maxHead) {
+			this.head.push(line);
+			if (this.head.length === this.maxHead) this.headComplete = true;
+		}
+		this.tail.push(line);
+		if (this.tail.length > this.maxTail) this.tail.shift();
+	}
+	/**
+	* finalize and format the output.
+	* returns the formatted text and count of truncated lines.
+	*
+	* small output (<= head + tail): dedupes overlap, no truncation marker
+	* large output: head + marker + tail
+	*/
+	format() {
+		if (this.pendingLine) {
+			this.totalLines++;
+			this.addLine(this.pendingLine);
+			this.pendingLine = "";
+		}
+		const allLines = this.totalLines;
+		if (allLines <= this.maxHead + this.maxTail) return {
+			text: this.dedupe(allLines).join("\n"),
+			truncatedLines: 0
+		};
+		const truncated = allLines - this.head.length - this.tail.length;
+		return {
+			text: [
+				...this.head,
+				"",
+				`... [${truncated} lines truncated] ...`,
+				"",
+				...this.tail
+			].join("\n"),
+			truncatedLines: truncated
+		};
+	}
+	/**
+	* deduplicate overlapping head/tail for small outputs.
+	*
+	* when total lines <= maxHead + maxTail, the tail buffer
+	* may contain lines already in head. we merge them using
+	* positional overlap (not value matching) to avoid dropping
+	* legitimate lines when content has duplicates.
+	*/
+	dedupe(totalLines) {
+		if (totalLines <= this.maxHead) return this.head;
+		if (totalLines <= this.maxTail) return this.tail;
+		const overlapLen = Math.max(0, this.head.length + this.tail.length - totalLines);
+		if (overlapLen === 0) return [...this.head, ...this.tail];
+		return [...this.head.slice(0, this.head.length - overlapLen), ...this.tail];
+	}
+	/**
+	* get current buffer state for debugging.
+	*/
+	debug() {
+		return {
+			head: [...this.head],
+			tail: [...this.tail],
+			totalLines: this.totalLines,
+			pendingLine: this.pendingLine
+		};
+	}
+};
+if (import.meta.vitest) {
+	const { describe, it, expect } = import.meta.vitest;
+	describe("OutputBuffer", () => {
+		describe("small output (no truncation)", () => {
+			it("returns all lines when output < head + tail", () => {
+				const buf = new OutputBuffer(50, 50);
+				buf.add("line1\nline2\nline3\n");
+				const { text, truncatedLines } = buf.format();
+				expect(truncatedLines).toBe(0);
+				expect(text).toBe("line1\nline2\nline3");
+			});
+			it("handles empty output", () => {
+				const { text, truncatedLines } = new OutputBuffer(50, 50).format();
+				expect(truncatedLines).toBe(0);
+				expect(text).toBe("");
+			});
+			it("handles single line", () => {
+				const buf = new OutputBuffer(50, 50);
+				buf.add("only line\n");
+				const { text, truncatedLines } = buf.format();
+				expect(truncatedLines).toBe(0);
+				expect(text).toBe("only line");
+			});
+			it("handles single line without trailing newline", () => {
+				const buf = new OutputBuffer(50, 50);
+				buf.add("no newline here");
+				const { text, truncatedLines } = buf.format();
+				expect(truncatedLines).toBe(0);
+				expect(text).toBe("no newline here");
+			});
+			it("counts empty lines", () => {
+				const buf = new OutputBuffer(50, 50);
+				buf.add("a\n\nb\n");
+				const { text, truncatedLines } = buf.format();
+				expect(truncatedLines).toBe(0);
+				expect(buf.totalLines).toBe(3);
+				expect(text).toBe("a\n\nb");
+			});
+		});
+		describe("medium output (overlap dedup)", () => {
+			it("dedupes when output smaller than head", () => {
+				const buf = new OutputBuffer(3, 3);
+				buf.add("1\n2\n");
+				const { text, truncatedLines } = buf.format();
+				expect(truncatedLines).toBe(0);
+				expect(text.split("\n")).toEqual(["1", "2"]);
+			});
+			it("dedupes when head and tail overlap exactly", () => {
+				const buf = new OutputBuffer(3, 3);
+				buf.add("1\n2\n3\n");
+				const { text, truncatedLines } = buf.format();
+				expect(truncatedLines).toBe(0);
+				expect(text.split("\n")).toEqual([
+					"1",
+					"2",
+					"3"
+				]);
+			});
+			it("dedupes when tail starts in head region", () => {
+				const buf = new OutputBuffer(3, 3);
+				buf.add("1\n2\n3\n4\n");
+				const { text, truncatedLines } = buf.format();
+				expect(truncatedLines).toBe(0);
+				expect(text.split("\n")).toEqual([
+					"1",
+					"2",
+					"3",
+					"4"
+				]);
+			});
+			it("dedupes when output smaller than tail capacity", () => {
+				const buf = new OutputBuffer(50, 50);
+				buf.add("a\nb\nc\n");
+				const { text, truncatedLines } = buf.format();
+				expect(truncatedLines).toBe(0);
+				expect(text).toBe("a\nb\nc");
+			});
+			it("does not drop lines when content has duplicates (regression)", () => {
+				const buf = new OutputBuffer(3, 3);
+				buf.add("A\nB\nA\nC\n");
+				const { text, truncatedLines } = buf.format();
+				expect(truncatedLines).toBe(0);
+				expect(text.split("\n")).toEqual([
+					"A",
+					"B",
+					"A",
+					"C"
+				]);
+			});
+			it("handles all-identical lines without dropping (regression)", () => {
+				const buf = new OutputBuffer(3, 3);
+				buf.add("x\nx\nx\nx\nx\n");
+				const { text, truncatedLines } = buf.format();
+				expect(truncatedLines).toBe(0);
+				const lines = text.split("\n");
+				expect(lines).toHaveLength(5);
+				expect(lines.every((l) => l === "x")).toBe(true);
+			});
+		});
+		describe("large output (truncation)", () => {
+			it("shows head + marker + tail when truncated", () => {
+				const buf = new OutputBuffer(2, 2);
+				for (let i = 1; i <= 10; i++) buf.add(`line${i}\n`);
+				const { text, truncatedLines } = buf.format();
+				expect(truncatedLines).toBe(6);
+				expect(text).toContain("line1");
+				expect(text).toContain("line2");
+				expect(text).toContain("line9");
+				expect(text).toContain("line10");
+				expect(text).toContain("6 lines truncated");
+				const idx1 = text.indexOf("line1");
+				const idxMarker = text.indexOf("truncated");
+				const idx10 = text.indexOf("line10");
+				expect(idx1).toBeLessThan(idxMarker);
+				expect(idxMarker).toBeLessThan(idx10);
+			});
+			it("tracks totalLines correctly", () => {
+				const buf = new OutputBuffer(5, 5);
+				buf.add("a\nb\nc\nd\ne\nf\ng\nh\n");
+				expect(buf.totalLines).toBe(8);
+			});
+			it("shows exact truncated count", () => {
+				const buf = new OutputBuffer(5, 5);
+				for (let i = 1; i <= 100; i++) buf.add(`line${i}\n`);
+				const { truncatedLines } = buf.format();
+				expect(truncatedLines).toBe(90);
+			});
+			it("handles output exactly at head+tail boundary", () => {
+				const buf = new OutputBuffer(5, 5);
+				for (let i = 1; i <= 10; i++) buf.add(`line${i}\n`);
+				const { text, truncatedLines } = buf.format();
+				expect(truncatedLines).toBe(0);
+				expect(text.split("\n")).toHaveLength(10);
+			});
+			it("handles output just over head+tail boundary", () => {
+				const buf = new OutputBuffer(5, 5);
+				for (let i = 1; i <= 11; i++) buf.add(`line${i}\n`);
+				const { text, truncatedLines } = buf.format();
+				expect(truncatedLines).toBe(1);
+				expect(text).toContain("line1");
+				expect(text).toContain("line11");
+			});
+		});
+		describe("streaming (chunk handling)", () => {
+			it("handles partial lines at chunk boundaries", () => {
+				const buf = new OutputBuffer(5, 5);
+				buf.add("hel");
+				buf.add("lo\nworld");
+				buf.add("\n");
+				const { text, truncatedLines } = buf.format();
+				expect(truncatedLines).toBe(0);
+				expect(text).toBe("hello\nworld");
+			});
+			it("handles multiple chunks without newlines", () => {
+				const buf = new OutputBuffer(5, 5);
+				buf.add("abc");
+				buf.add("def");
+				buf.add("ghi\n");
+				const { text, truncatedLines } = buf.format();
+				expect(truncatedLines).toBe(0);
+				expect(text).toBe("abcdefghi");
+			});
+			it("handles empty chunks", () => {
+				const buf = new OutputBuffer(5, 5);
+				buf.add("");
+				buf.add("test\n");
+				buf.add("");
+				const { text } = buf.format();
+				expect(text).toBe("test");
+			});
+			it("handles chunk ending with newline then more data", () => {
+				const buf = new OutputBuffer(5, 5);
+				buf.add("line1\n");
+				buf.add("line2\n");
+				buf.add("line3\n");
+				const { text } = buf.format();
+				expect(text).toBe("line1\nline2\nline3");
+			});
+		});
+		describe("reversion guards (fail on old behavior)", () => {
+			it("shows FIRST lines, not just tail", () => {
+				const buf = new OutputBuffer(5, 5);
+				for (let i = 1; i <= 100; i++) buf.add(`line ${i}\n`);
+				const { text } = buf.format();
+				expect(text).toContain("line 1");
+				expect(text).toContain("line 5");
+				expect(text).toContain("line 96");
+				expect(text).toContain("line 100");
+			});
+			it("head comes BEFORE tail in output", () => {
+				const buf = new OutputBuffer(5, 5);
+				for (let i = 1; i <= 100; i++) buf.add(`line ${i}\n`);
+				const { text } = buf.format();
+				const firstHeadIdx = text.indexOf("line 1");
+				const lastHeadIdx = text.indexOf("line 5");
+				const firstTailIdx = text.indexOf("line 96");
+				const lastTailIdx = text.indexOf("line 100");
+				expect(lastHeadIdx).toBeLessThan(firstTailIdx);
+				expect(firstHeadIdx).toBeLessThan(lastTailIdx);
+			});
+			it("truncation marker between head and tail", () => {
+				const buf = new OutputBuffer(5, 5);
+				for (let i = 1; i <= 100; i++) buf.add(`line ${i}\n`);
+				const { text } = buf.format();
+				const lastHeadIdx = text.indexOf("line 5");
+				const markerIdx = text.indexOf("truncated");
+				const firstTailIdx = text.indexOf("line 96");
+				expect(lastHeadIdx).toBeLessThan(markerIdx);
+				expect(markerIdx).toBeLessThan(firstTailIdx);
+			});
+		});
+		describe("edge cases", () => {
+			it("handles very long single line (no newlines)", () => {
+				const buf = new OutputBuffer(50, 50);
+				buf.add("x".repeat(1e5));
+				const { text, truncatedLines } = buf.format();
+				expect(truncatedLines).toBe(0);
+				expect(text.length).toBe(1e5);
+			});
+			it("handles many short lines", () => {
+				const buf = new OutputBuffer(5, 5);
+				for (let i = 0; i < 1e3; i++) buf.add("x\n");
+				const { text, truncatedLines } = buf.format();
+				expect(truncatedLines).toBe(990);
+				expect(text.split("\n").filter((l) => l === "x").length).toBe(10);
+			});
+			it("handles mixed empty and non-empty lines", () => {
+				const buf = new OutputBuffer(50, 50);
+				buf.add("a\n\nb\n\nc\n");
+				const { text, truncatedLines } = buf.format();
+				expect(truncatedLines).toBe(0);
+				expect(text).toBe("a\n\nb\n\nc");
+				expect(buf.totalLines).toBe(5);
+			});
+			it("handles carriage returns (treats as part of line)", () => {
+				const buf = new OutputBuffer(50, 50);
+				buf.add("line1\r\nline2\r\n");
+				const { text } = buf.format();
+				expect(text).toBe("line1\r\nline2\r");
+			});
+		});
+	});
+	describe("headTail helper", () => {
+		it("returns all items when under limit", () => {
+			const { head, tail, truncated, truncatedCount } = headTail([
+				1,
+				2,
+				3,
+				4,
+				5
+			], 10);
+			expect(head).toEqual([
+				1,
+				2,
+				3,
+				4,
+				5
+			]);
+			expect(tail).toEqual([]);
+			expect(truncated).toEqual([]);
+			expect(truncatedCount).toBe(0);
+		});
+		it("splits evenly at limit", () => {
+			const { head, tail, truncatedCount } = headTail([
+				1,
+				2,
+				3,
+				4,
+				5,
+				6,
+				7,
+				8,
+				9,
+				10
+			], 10);
+			expect(head).toEqual([
+				1,
+				2,
+				3,
+				4,
+				5,
+				6,
+				7,
+				8,
+				9,
+				10
+			]);
+			expect(tail).toEqual([]);
+			expect(truncatedCount).toBe(0);
+		});
+		it("splits into head + tail when over limit", () => {
+			const { head, tail, truncated, truncatedCount } = headTail(Array.from({ length: 100 }, (_, i) => i + 1), 20);
+			expect(head).toEqual([
+				1,
+				2,
+				3,
+				4,
+				5,
+				6,
+				7,
+				8,
+				9,
+				10
+			]);
+			expect(tail).toEqual([
+				91,
+				92,
+				93,
+				94,
+				95,
+				96,
+				97,
+				98,
+				99,
+				100
+			]);
+			expect(truncatedCount).toBe(80);
+			expect(truncated.length).toBe(80);
+		});
+		it("uses even split for head and tail", () => {
+			const { head, tail, truncatedCount } = headTail(Array.from({ length: 100 }, (_, i) => i + 1), 21);
+			expect(head.length).toBe(10);
+			expect(tail.length).toBe(10);
+			expect(truncatedCount).toBe(80);
+		});
+	});
+	describe("formatHeadTail helper", () => {
+		it("joins items when under limit", () => {
+			expect(formatHeadTail([
+				"a",
+				"b",
+				"c"
+			], 10)).toBe("a\nb\nc");
+		});
+		it("formats with truncation marker when over limit", () => {
+			const result = formatHeadTail(Array.from({ length: 100 }, (_, i) => `item ${i + 1}`), 20);
+			expect(result).toContain("item 1");
+			expect(result).toContain("item 10");
+			expect(result).toContain("item 91");
+			expect(result).toContain("item 100");
+			expect(result).toContain("80 lines truncated");
+			expect(result.indexOf("item 10")).toBeLessThan(result.indexOf("truncated"));
+			expect(result.indexOf("truncated")).toBeLessThan(result.indexOf("item 91"));
+		});
+		it("uses custom truncation message", () => {
+			expect(formatHeadTail(Array.from({ length: 50 }, () => `x`), 10, (n) => `-- ${n} hidden --`)).toContain("-- 40 hidden --");
+		});
+	});
+}
+//#endregion
+export { OutputBuffer, formatHeadTail, headTail, headTailChars };

package/dist/core/permissions.d.ts

@@ -0,0 +1,19 @@
+//#region packages/core/permissions/index.d.ts
+interface PermissionRule {
+  tool: string;
+  matches?: {
+    cmd?: string | string[];
+  };
+  action: "allow" | "reject";
+  message?: string;
+}
+interface PermissionVerdict {
+  action: "allow" | "reject";
+  message?: string;
+}
+declare function evaluatePermission(toolName: string, params: {
+  cmd?: string;
+}, rules: PermissionRule[]): PermissionVerdict;
+declare function loadPermissions(): PermissionRule[];
+//#endregion
+export { PermissionRule, PermissionVerdict, evaluatePermission, loadPermissions };

package/dist/core/permissions.js

@@ -0,0 +1,140 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+//#region packages/core/permissions/index.ts
+/**
+* permission evaluation for tool calls.
+*
+* reads rules from ~/.pi/agent/permissions.json (separate from
+* settings.json since this is extension-owned config). rules are
+* evaluated first-match-wins, matching tool name and params via
+* glob patterns. default action when no rule matches: allow.
+*
+* format mirrors amp's amp.permissions schema:
+*   { tool, matches?, action, message? }
+*
+* only "allow" and "reject" actions for now — no "ask" or "delegate"
+* because pi's tool execute API has no confirmation mechanism.
+*/
+/**
+* convert a simple glob pattern (only `*` wildcards) to a regex.
+* covers all patterns amp documents: `*git push*`, `rm *`, `*`.
+*/
+function globToRegex(pattern) {
+	const withWildcards = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+	return new RegExp(`^${withWildcards}$`, "i");
+}
+function evaluatePermission(toolName, params, rules) {
+	for (const rule of rules) {
+		if (!globToRegex(rule.tool).test(toolName)) continue;
+		if (rule.matches?.cmd) {
+			if (!(Array.isArray(rule.matches.cmd) ? rule.matches.cmd : [rule.matches.cmd]).some((p) => globToRegex(p).test(params.cmd ?? ""))) continue;
+		}
+		return {
+			action: rule.action,
+			message: rule.message
+		};
+	}
+	return { action: "allow" };
+}
+const PERMISSIONS_PATH = path.join(os.homedir(), ".pi", "agent", "permissions.json");
+function loadPermissions() {
+	try {
+		const raw = fs.readFileSync(PERMISSIONS_PATH, "utf-8");
+		const parsed = JSON.parse(raw);
+		if (!Array.isArray(parsed)) return [];
+		return parsed;
+	} catch {
+		return [];
+	}
+}
+if (import.meta.vitest) {
+	const { describe, it, expect } = import.meta.vitest;
+	const RULES = [
+		{
+			tool: "Bash",
+			matches: { cmd: ["*git add -A*", "*git add .*"] },
+			action: "reject",
+			message: "stage files explicitly with 'git add <file>' — unstaged changes may not be yours"
+		},
+		{
+			tool: "Bash",
+			matches: { cmd: [
+				"*git push --force*",
+				"*git push -f*",
+				"*--force-with-lease*"
+			] },
+			action: "reject",
+			message: "never force push. if diverged: 'git fetch origin && git rebase origin/main && git push'"
+		},
+		{
+			tool: "Bash",
+			matches: { cmd: [
+				"rm *",
+				"* && rm *",
+				"* || rm *",
+				"* ; rm *"
+			] },
+			action: "reject",
+			message: "use 'trash <file>' instead of rm — recoverable deletion"
+		},
+		{
+			tool: "*",
+			action: "allow"
+		}
+	];
+	describe("evaluatePermission", () => {
+		it("allows normal commands", () => {
+			expect(evaluatePermission("Bash", { cmd: "git status" }, RULES)).toEqual({ action: "allow" });
+			expect(evaluatePermission("Bash", { cmd: "ls -la" }, RULES)).toEqual({ action: "allow" });
+			expect(evaluatePermission("Bash", { cmd: "nix build .#foo" }, RULES)).toEqual({ action: "allow" });
+		});
+		it("rejects git add -A", () => {
+			const v = evaluatePermission("Bash", { cmd: "git add -A" }, RULES);
+			expect(v.action).toBe("reject");
+			expect(v.message).toContain("stage files explicitly");
+		});
+		it("rejects git add .", () => {
+			expect(evaluatePermission("Bash", { cmd: "git add ." }, RULES).action).toBe("reject");
+		});
+		it("allows explicit git add", () => {
+			expect(evaluatePermission("Bash", { cmd: "git add src/foo.ts" }, RULES).action).toBe("allow");
+		});
+		it("rejects force push variants", () => {
+			expect(evaluatePermission("Bash", { cmd: "git push --force" }, RULES).action).toBe("reject");
+			expect(evaluatePermission("Bash", { cmd: "git push -f origin main" }, RULES).action).toBe("reject");
+			expect(evaluatePermission("Bash", { cmd: "git push --force-with-lease" }, RULES).action).toBe("reject");
+		});
+		it("allows normal git push", () => {
+			expect(evaluatePermission("Bash", { cmd: "git push" }, RULES).action).toBe("allow");
+			expect(evaluatePermission("Bash", { cmd: "git push origin main" }, RULES).action).toBe("allow");
+		});
+		it("rejects rm commands", () => {
+			expect(evaluatePermission("Bash", { cmd: "rm foo.txt" }, RULES).action).toBe("reject");
+			expect(evaluatePermission("Bash", { cmd: "rm -rf /tmp/junk" }, RULES).action).toBe("reject");
+			expect(evaluatePermission("Bash", { cmd: "ls && rm foo" }, RULES).action).toBe("reject");
+			expect(evaluatePermission("Bash", { cmd: "false || rm foo" }, RULES).action).toBe("reject");
+			expect(evaluatePermission("Bash", { cmd: "echo hi ; rm foo" }, RULES).action).toBe("reject");
+		});
+		it("allows non-Bash tools via wildcard catch-all", () => {
+			expect(evaluatePermission("Read", { cmd: "/etc/passwd" }, RULES)).toEqual({ action: "allow" });
+		});
+		it("allows everything when no rules", () => {
+			expect(evaluatePermission("Bash", { cmd: "rm -rf /" }, [])).toEqual({ action: "allow" });
+		});
+		it("matches tool name with glob", () => {
+			const rules = [{
+				tool: "mcp__*",
+				action: "reject",
+				message: "no mcp"
+			}, {
+				tool: "*",
+				action: "allow"
+			}];
+			expect(evaluatePermission("mcp__playwright_click", {}, rules).action).toBe("reject");
+			expect(evaluatePermission("Bash", { cmd: "ls" }, rules).action).toBe("allow");
+		});
+	});
+}
+//#endregion
+export { evaluatePermission, loadPermissions };