@vitos-pizza/vitos-pizza 0.1.0 → 0.2.0

package/node_modules/@vitos-pizza/permission-system/tests/gates.test.ts

@@ -1,61 +1,170 @@
-import { describe, expect, it } from "vitest";
-import { runGatePipeline } from "../src/gates/pipeline.ts";
-import { PermissionEvaluator } from "../src/permission-evaluator.ts";
-
-describe("gate pipeline", () => {
-	const evaluator = new PermissionEvaluator();
-	const permission = {
-		"*": "allow" as const,
-		path: {
-			"*": "allow" as const,
-			"*.env": "deny" as const,
-		},
-		bash: {
-			"*": "ask" as const,
-			"git status": "allow" as const,
-		},
-		external_directory: "ask" as const,
-	};
-
-	it("denies sensitive paths across tools", () => {
-		const result = runGatePipeline(
-			permission,
-			evaluator,
-			{
-				toolName: "read",
-				input: { path: ".env" },
-				cwd: "/workspace/project",
-			},
-			{ registeredTools: new Set(["read"]) },
-		);
-		expect(result.state).toBe("deny");
-	});
-
-	it("asks for external paths", () => {
-		const result = runGatePipeline(
-			permission,
-			evaluator,
-			{
-				toolName: "read",
-				input: { path: "/etc/hosts" },
-				cwd: "/workspace/project",
-			},
-			{ registeredTools: new Set(["read"]) },
-		);
-		expect(result.state).toBe("ask");
-	});
-
-	it("allows whitelisted bash commands", () => {
-		const result = runGatePipeline(
-			permission,
-			evaluator,
-			{
-				toolName: "bash",
-				input: { command: "git status" },
-				cwd: "/workspace/project",
-			},
-			{ registeredTools: new Set(["bash"]) },
-		);
-		expect(result.state).toBe("allow");
-	});
-});
+import { describe, expect, it } from "vitest";
+import { runGatePipeline } from "../src/gates/pipeline.ts";
+import { PermissionEvaluator } from "../src/permission-evaluator.ts";
+import {
+	patternForSessionApproval,
+	SessionApprovals,
+} from "../src/session-approvals.ts";
+
+describe("gate pipeline", () => {
+	const evaluator = new PermissionEvaluator();
+	const permission = {
+		"*": "allow" as const,
+		path: {
+			"*": "allow" as const,
+			"*.env": "deny" as const,
+		},
+		bash: {
+			"*": "ask" as const,
+			"git status": "allow" as const,
+		},
+		external_directory: "ask" as const,
+		web_read: "ask" as const,
+	};
+
+	it("denies sensitive paths across tools", () => {
+		const result = runGatePipeline(
+			permission,
+			evaluator,
+			{
+				toolName: "read",
+				input: { path: ".env" },
+				cwd: "/workspace/project",
+			},
+			{ registeredTools: new Set(["read"]) },
+		);
+		expect(result.state).toBe("deny");
+	});
+
+	it("asks for external paths", () => {
+		const result = runGatePipeline(
+			permission,
+			evaluator,
+			{
+				toolName: "read",
+				input: { path: "/etc/hosts" },
+				cwd: "/workspace/project",
+			},
+			{ registeredTools: new Set(["read"]) },
+		);
+		expect(result.state).toBe("ask");
+		expect(result.surface).toBe("external_directory");
+	});
+
+	it("allows whitelisted bash commands", () => {
+		const result = runGatePipeline(
+			permission,
+			evaluator,
+			{
+				toolName: "bash",
+				input: { command: "git status" },
+				cwd: "/workspace/project",
+			},
+			{ registeredTools: new Set(["bash"]) },
+		);
+		expect(result.state).toBe("allow");
+	});
+
+	it("honors session approval for web_read without re-asking", () => {
+		const approvals = new SessionApprovals();
+		const first = runGatePipeline(
+			permission,
+			evaluator,
+			{
+				toolName: "web_read",
+				input: { url: "https://example.com/a" },
+				cwd: "/workspace/project",
+			},
+			{ registeredTools: new Set(["web_read"]) },
+		);
+		expect(first.state).toBe("ask");
+		approvals.add(
+			first.surface,
+			patternForSessionApproval(first.surface, first.matchedPattern ?? "*"),
+		);
+
+		const second = runGatePipeline(
+			permission,
+			evaluator,
+			{
+				toolName: "web_read",
+				input: { url: "https://other.example/b" },
+				cwd: "/workspace/project",
+			},
+			{
+				registeredTools: new Set(["web_read"]),
+				sessionApprovals: approvals,
+			},
+		);
+		expect(second.state).toBe("allow");
+		expect(second.origin).toBe("session");
+	});
+
+	it("honors session approval for external_directory across paths", () => {
+		const approvals = new SessionApprovals();
+		const first = runGatePipeline(
+			permission,
+			evaluator,
+			{
+				toolName: "read",
+				input: { path: "/etc/hosts" },
+				cwd: "/workspace/project",
+			},
+			{ registeredTools: new Set(["read"]) },
+		);
+		expect(first.state).toBe("ask");
+		approvals.add(
+			first.surface,
+			patternForSessionApproval(first.surface, first.matchedPattern ?? "*"),
+		);
+
+		const second = runGatePipeline(
+			permission,
+			evaluator,
+			{
+				toolName: "read",
+				input: { path: "/tmp/other" },
+				cwd: "/workspace/project",
+			},
+			{
+				registeredTools: new Set(["read"]),
+				sessionApprovals: approvals,
+			},
+		);
+		expect(second.state).toBe("allow");
+	});
+
+	it("honors session approval for bash ask patterns", () => {
+		const approvals = new SessionApprovals();
+		const first = runGatePipeline(
+			permission,
+			evaluator,
+			{
+				toolName: "bash",
+				input: { command: "npm install" },
+				cwd: "/workspace/project",
+			},
+			{ registeredTools: new Set(["bash"]) },
+		);
+		expect(first.state).toBe("ask");
+		approvals.add(
+			first.surface,
+			patternForSessionApproval(first.surface, first.matchedPattern ?? "*"),
+		);
+
+		const second = runGatePipeline(
+			permission,
+			evaluator,
+			{
+				toolName: "bash",
+				input: { command: "npm test" },
+				cwd: "/workspace/project",
+			},
+			{
+				registeredTools: new Set(["bash"]),
+				sessionApprovals: approvals,
+			},
+		);
+		expect(second.state).toBe("allow");
+	});
+});

package/node_modules/@vitos-pizza/permission-system/tests/path-utils.test.ts

@@ -1,68 +1,68 @@
-import { mkdtempSync, mkdirSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { describe, expect, it } from "vitest";
-import { runGatePipeline } from "../src/gates/pipeline.ts";
-import {
-	findProjectRoot,
-	isExternalPath,
-	isPathWithinRoot,
-} from "../src/gates/path-utils.ts";
-import { PermissionEvaluator } from "../src/permission-evaluator.ts";
-
-describe("path-utils project root", () => {
-	it("treats sibling packages inside the git repo as in-project", () => {
-		const repo = mkdtempSync(join(tmpdir(), "perm-repo-"));
-		mkdirSync(join(repo, ".git"));
-		const pkgA = join(repo, "packages", "a");
-		const pkgB = join(repo, "packages", "b", "file.ts");
-		mkdirSync(pkgA, { recursive: true });
-		mkdirSync(join(repo, "packages", "b"), { recursive: true });
-		writeFileSync(pkgB, "export {}\n", "utf8");
-
-		expect(findProjectRoot(pkgA)).toBe(repo);
-		expect(isExternalPath(pkgB, pkgA)).toBe(false);
-		expect(isPathWithinRoot(pkgB, repo)).toBe(true);
-	});
-
-	it("still treats paths outside the git repo as external", () => {
-		const repo = mkdtempSync(join(tmpdir(), "perm-repo-"));
-		mkdirSync(join(repo, ".git"));
-		expect(isExternalPath("/etc/hosts", repo)).toBe(true);
-	});
-});
-
-describe("gate pipeline in-project reads", () => {
-	const evaluator = new PermissionEvaluator();
-	const permission = {
-		"*": "allow" as const,
-		read: "allow" as const,
-		path: {
-			"*": "allow" as const,
-			"*.env": "deny" as const,
-		},
-		external_directory: "ask" as const,
-	};
-
-	it("allows reading another package in the same repo without asking", () => {
-		const repo = mkdtempSync(join(tmpdir(), "perm-gate-repo-"));
-		mkdirSync(join(repo, ".git"));
-		const cwd = join(repo, "packages", "a");
-		const target = join(repo, "packages", "b", "file.ts");
-		mkdirSync(cwd, { recursive: true });
-		mkdirSync(join(repo, "packages", "b"), { recursive: true });
-		writeFileSync(target, "export {}\n", "utf8");
-
-		const result = runGatePipeline(
-			permission,
-			evaluator,
-			{
-				toolName: "read",
-				input: { path: target },
-				cwd,
-			},
-			{ registeredTools: new Set(["read"]) },
-		);
-		expect(result.state).toBe("allow");
-	});
-});
+import { mkdtempSync, mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { runGatePipeline } from "../src/gates/pipeline.ts";
+import {
+	findProjectRoot,
+	isExternalPath,
+	isPathWithinRoot,
+} from "../src/gates/path-utils.ts";
+import { PermissionEvaluator } from "../src/permission-evaluator.ts";
+
+describe("path-utils project root", () => {
+	it("treats sibling packages inside the git repo as in-project", () => {
+		const repo = mkdtempSync(join(tmpdir(), "perm-repo-"));
+		mkdirSync(join(repo, ".git"));
+		const pkgA = join(repo, "packages", "a");
+		const pkgB = join(repo, "packages", "b", "file.ts");
+		mkdirSync(pkgA, { recursive: true });
+		mkdirSync(join(repo, "packages", "b"), { recursive: true });
+		writeFileSync(pkgB, "export {}\n", "utf8");
+
+		expect(findProjectRoot(pkgA)).toBe(repo);
+		expect(isExternalPath(pkgB, pkgA)).toBe(false);
+		expect(isPathWithinRoot(pkgB, repo)).toBe(true);
+	});
+
+	it("still treats paths outside the git repo as external", () => {
+		const repo = mkdtempSync(join(tmpdir(), "perm-repo-"));
+		mkdirSync(join(repo, ".git"));
+		expect(isExternalPath("/etc/hosts", repo)).toBe(true);
+	});
+});
+
+describe("gate pipeline in-project reads", () => {
+	const evaluator = new PermissionEvaluator();
+	const permission = {
+		"*": "allow" as const,
+		read: "allow" as const,
+		path: {
+			"*": "allow" as const,
+			"*.env": "deny" as const,
+		},
+		external_directory: "ask" as const,
+	};
+
+	it("allows reading another package in the same repo without asking", () => {
+		const repo = mkdtempSync(join(tmpdir(), "perm-gate-repo-"));
+		mkdirSync(join(repo, ".git"));
+		const cwd = join(repo, "packages", "a");
+		const target = join(repo, "packages", "b", "file.ts");
+		mkdirSync(cwd, { recursive: true });
+		mkdirSync(join(repo, "packages", "b"), { recursive: true });
+		writeFileSync(target, "export {}\n", "utf8");
+
+		const result = runGatePipeline(
+			permission,
+			evaluator,
+			{
+				toolName: "read",
+				input: { path: target },
+				cwd,
+			},
+			{ registeredTools: new Set(["read"]) },
+		);
+		expect(result.state).toBe("allow");
+	});
+});

package/node_modules/@vitos-pizza/permission-system/tests/permission-evaluator.test.ts

@@ -1,55 +1,82 @@
-import { describe, expect, it } from "vitest";
-import { PermissionEvaluator } from "../src/permission-evaluator.ts";
-import { SessionApprovals } from "../src/session-approvals.ts";
-
-describe("permission-evaluator", () => {
-	const evaluator = new PermissionEvaluator();
-	const permission = {
-		"*": "allow" as const,
-		bash: {
-			"*": "ask" as const,
-			"git status": "allow" as const,
-			"rm -rf *": "deny" as const,
-		},
-	};
-
-	it("evaluates bash patterns with last-match-wins", () => {
-		const allowed = evaluator.evaluateSurface(permission, "bash", "git status");
-		const denied = evaluator.evaluateSurface(permission, "bash", "rm -rf /tmp");
-		const asked = evaluator.evaluateSurface(permission, "bash", "npm install");
-
-		expect(allowed.state).toBe("allow");
-		expect(denied.state).toBe("deny");
-		expect(asked.state).toBe("ask");
-	});
-
-	it("rewrites ask to allow in yolo mode", () => {
-		const result = evaluator.evaluateSurface(
-			permission,
-			"bash",
-			"npm install",
-			"project",
-			{
-				yoloMode: true,
-			},
-		);
-		expect(result.state).toBe("allow");
-		expect(result.origin).toBe("yolo");
-	});
-
-	it("honors session approvals", () => {
-		const approvals = new SessionApprovals();
-		approvals.add("bash", "npm install");
-		const result = evaluator.evaluateSurface(
-			permission,
-			"bash",
-			"npm install",
-			"project",
-			{
-				sessionApprovals: approvals,
-			},
-		);
-		expect(result.state).toBe("allow");
-		expect(result.origin).toBe("session");
-	});
-});
+import { describe, expect, it } from "vitest";
+import { PermissionEvaluator } from "../src/permission-evaluator.ts";
+import {
+	patternForSessionApproval,
+	SessionApprovals,
+} from "../src/session-approvals.ts";
+
+describe("permission-evaluator", () => {
+	const evaluator = new PermissionEvaluator();
+	const permission = {
+		"*": "allow" as const,
+		bash: {
+			"*": "ask" as const,
+			"git status": "allow" as const,
+			"rm -rf *": "deny" as const,
+		},
+		web_read: "ask" as const,
+	};
+
+	it("evaluates bash patterns with last-match-wins", () => {
+		const allowed = evaluator.evaluateSurface(permission, "bash", "git status");
+		const denied = evaluator.evaluateSurface(permission, "bash", "rm -rf /tmp");
+		const asked = evaluator.evaluateSurface(permission, "bash", "npm install");
+
+		expect(allowed.state).toBe("allow");
+		expect(denied.state).toBe("deny");
+		expect(asked.state).toBe("ask");
+	});
+
+	it("rewrites ask to allow in yolo mode", () => {
+		const result = evaluator.evaluateSurface(
+			permission,
+			"bash",
+			"npm install",
+			"project",
+			{
+				yoloMode: true,
+			},
+		);
+		expect(result.state).toBe("allow");
+		expect(result.origin).toBe("yolo");
+	});
+
+	it("honors session approvals", () => {
+		const approvals = new SessionApprovals();
+		approvals.add("bash", "npm install");
+		const result = evaluator.evaluateSurface(
+			permission,
+			"bash",
+			"npm install",
+			"project",
+			{
+				sessionApprovals: approvals,
+			},
+		);
+		expect(result.state).toBe("allow");
+		expect(result.origin).toBe("session");
+	});
+
+	it("getToolPermission honors session approvals for scalar tools", () => {
+		const approvals = new SessionApprovals();
+		const asked = evaluator.getToolPermission(permission, "web_read");
+		expect(asked).toBe("ask");
+
+		approvals.add(
+			"web_read",
+			patternForSessionApproval("web_read", "web_read"),
+		);
+		const allowed = evaluator.getToolPermission(permission, "web_read", {
+			sessionApprovals: approvals,
+		});
+		expect(allowed).toBe("allow");
+	});
+
+	it("patternForSessionApproval widens scalar surface matches to *", () => {
+		expect(patternForSessionApproval("web_read", "web_read")).toBe("*");
+		expect(patternForSessionApproval("bash", "*")).toBe("*");
+		expect(patternForSessionApproval("bash", "npm install")).toBe(
+			"npm install",
+		);
+	});
+});

package/node_modules/@vitos-pizza/permission-system/tests/policy-loader.test.ts

@@ -1,25 +1,25 @@
-import { describe, expect, it } from "vitest";
-import { mergePermissionMaps } from "../src/policy-loader.ts";
-
-describe("policy-loader merge", () => {
-	it("merges nested maps and overrides scalars", () => {
-		const merged = mergePermissionMaps(
-			{
-				"*": "allow",
-				bash: { "*": "ask", "git status": "allow" },
-			},
-			{
-				write: "ask",
-				bash: { "npm install": "deny" },
-			},
-		);
-
-		expect(merged["*"]).toBe("allow");
-		expect(merged.write).toBe("ask");
-		expect(merged.bash).toEqual({
-			"*": "ask",
-			"git status": "allow",
-			"npm install": "deny",
-		});
-	});
-});
+import { describe, expect, it } from "vitest";
+import { mergePermissionMaps } from "../src/policy-loader.ts";
+
+describe("policy-loader merge", () => {
+	it("merges nested maps and overrides scalars", () => {
+		const merged = mergePermissionMaps(
+			{
+				"*": "allow",
+				bash: { "*": "ask", "git status": "allow" },
+			},
+			{
+				write: "ask",
+				bash: { "npm install": "deny" },
+			},
+		);
+
+		expect(merged["*"]).toBe("allow");
+		expect(merged.write).toBe("ask");
+		expect(merged.bash).toEqual({
+			"*": "ask",
+			"git status": "allow",
+			"npm install": "deny",
+		});
+	});
+});

package/node_modules/@vitos-pizza/permission-system/tests/system-prompt-sanitizer.test.ts

@@ -1,22 +1,22 @@
-import { describe, expect, it } from "vitest";
-import { sanitizeAvailableToolsSection } from "../src/sanitizers/system-prompt.ts";
-
-describe("system-prompt sanitizer", () => {
-	it("removes denied tools from Available tools section", () => {
-		const prompt = [
-			"Available tools:",
-			"- read: read files",
-			"- bash: run commands",
-			"- write: write files",
-			"",
-			"Guidelines:",
-			"- use bash for file operations like ls, rg, find",
-		].join("\n");
-
-		const result = sanitizeAvailableToolsSection(prompt, ["read"]);
-		expect(result.removed).toBe(true);
-		expect(result.prompt).toContain("- read:");
-		expect(result.prompt).not.toContain("- bash:");
-		expect(result.prompt).not.toContain("use bash for file operations");
-	});
-});
+import { describe, expect, it } from "vitest";
+import { sanitizeAvailableToolsSection } from "../src/sanitizers/system-prompt.ts";
+
+describe("system-prompt sanitizer", () => {
+	it("removes denied tools from Available tools section", () => {
+		const prompt = [
+			"Available tools:",
+			"- read: read files",
+			"- bash: run commands",
+			"- write: write files",
+			"",
+			"Guidelines:",
+			"- use bash for file operations like ls, rg, find",
+		].join("\n");
+
+		const result = sanitizeAvailableToolsSection(prompt, ["read"]);
+		expect(result.removed).toBe(true);
+		expect(result.prompt).toContain("- read:");
+		expect(result.prompt).not.toContain("- bash:");
+		expect(result.prompt).not.toContain("use bash for file operations");
+	});
+});

package/node_modules/@vitos-pizza/permission-system/tests/wildcard-matcher.test.ts

@@ -1,27 +1,27 @@
-import { describe, expect, it } from "vitest";
-import {
-	compileWildcardPattern,
-	findCompiledWildcardMatch,
-	wildcardMatch,
-} from "../src/wildcard-matcher.ts";
-
-describe("wildcard-matcher", () => {
-	it("matches exact strings", () => {
-		expect(wildcardMatch("git status", "git status")).toBe(true);
-		expect(wildcardMatch("git status", "git diff")).toBe(false);
-	});
-
-	it("supports trailing optional args", () => {
-		expect(wildcardMatch("git *", "git")).toBe(true);
-		expect(wildcardMatch("git *", "git status")).toBe(true);
-	});
-
-	it("uses last-match-wins ordering", () => {
-		const compiled = [
-			compileWildcardPattern("*", "ask"),
-			compileWildcardPattern("git status", "allow"),
-		];
-		const match = findCompiledWildcardMatch(compiled, "git status");
-		expect(match?.state).toBe("allow");
-	});
-});
+import { describe, expect, it } from "vitest";
+import {
+	compileWildcardPattern,
+	findCompiledWildcardMatch,
+	wildcardMatch,
+} from "../src/wildcard-matcher.ts";
+
+describe("wildcard-matcher", () => {
+	it("matches exact strings", () => {
+		expect(wildcardMatch("git status", "git status")).toBe(true);
+		expect(wildcardMatch("git status", "git diff")).toBe(false);
+	});
+
+	it("supports trailing optional args", () => {
+		expect(wildcardMatch("git *", "git")).toBe(true);
+		expect(wildcardMatch("git *", "git status")).toBe(true);
+	});
+
+	it("uses last-match-wins ordering", () => {
+		const compiled = [
+			compileWildcardPattern("*", "ask"),
+			compileWildcardPattern("git status", "allow"),
+		];
+		const match = findCompiledWildcardMatch(compiled, "git status");
+		expect(match?.state).toBe("allow");
+	});
+});