@vitos-pizza/vitos-pizza 0.1.0 → 0.3.0

package/node_modules/@vitos-pizza/permission-system/src/ui/approval-summary.ts

@@ -1,43 +0,0 @@
-import type { GateContext } from "../types.ts";
-
-export function buildApprovalSummary(ctx: GateContext): string {
-	const { toolName, input } = ctx;
-
-	if (toolName === "bash" && typeof input.command === "string") {
-		return `Run bash command:\n${input.command}`;
-	}
-
-	if (
-		(toolName === "read" ||
-			toolName === "write" ||
-			toolName === "edit" ||
-			toolName === "grep" ||
-			toolName === "find" ||
-			toolName === "ls") &&
-		typeof input.path === "string"
-	) {
-		return `${toolName} ${input.path}`;
-	}
-
-	if (toolName === "mcp") {
-		const server =
-			typeof input.server === "string" ? input.server : "unknown-server";
-		const tool = typeof input.tool === "string" ? input.tool : "unknown-tool";
-		return `MCP ${server}/${tool}`;
-	}
-
-	if (toolName === "edit" && typeof input.old_string === "string") {
-		const lines = input.old_string.split("\n").length;
-		return `edit (${lines} line${lines === 1 ? "" : "s"})`;
-	}
-
-	const preview = JSON.stringify(input, null, 2);
-	if (preview.length > 400) {
-		return `${toolName}: ${preview.slice(0, 400)}…`;
-	}
-	return `${toolName}: ${preview}`;
-}
-
-export function buildApprovalTitle(toolName: string): string {
-	return `Allow ${toolName}?`;
-}

package/node_modules/@vitos-pizza/permission-system/src/ui/config-modal.ts

@@ -1,36 +0,0 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { ExtensionConfig } from "../types.ts";
-
-export async function showPermissionSystemModal(
-	ctx: ExtensionContext,
-	config: ExtensionConfig,
-	onSave: (next: ExtensionConfig) => void,
-): Promise<void> {
-	if (!ctx.hasUI) {
-		ctx.ui.notify(
-			"Permission system settings require an interactive UI.",
-			"info",
-		);
-		return;
-	}
-
-	const yoloLabel = config.yoloMode
-		? "YOLO mode: ON (auto-approve ask)"
-		: "YOLO mode: OFF";
-	const debugLabel = config.debug ? "Debug logging: ON" : "Debug logging: OFF";
-	const selected = await ctx.ui.select("Permission system", [
-		yoloLabel,
-		debugLabel,
-		"Close",
-	]);
-	if (!selected || selected === "Close") return;
-
-	const next = { ...config };
-	if (selected === yoloLabel) next.yoloMode = !config.yoloMode;
-	if (selected === debugLabel) next.debug = !config.debug;
-	onSave(next);
-	ctx.ui.notify(
-		"Permission settings updated. Run /reload to apply runtime changes.",
-		"info",
-	);
-}

package/node_modules/@vitos-pizza/permission-system/src/ui/permission-dialog.ts

@@ -1,52 +0,0 @@
-export type PermissionDecisionState =
-	| "approved"
-	| "approved_for_session"
-	| "denied"
-	| "denied_with_reason";
-
-export interface PermissionPromptDecision {
-	approved: boolean;
-	state: PermissionDecisionState;
-	denialReason?: string;
-	autoApproved?: true;
-	confirmationUnavailable?: true;
-}
-
-export interface PermissionDecisionUi {
-	select(title: string, options: string[]): Promise<string | undefined>;
-	input(title: string, placeholder?: string): Promise<string | undefined>;
-}
-
-const APPROVE_OPTION = "Yes";
-const APPROVE_FOR_SESSION_OPTION = "Yes, for this session";
-const DENY_OPTION = "No";
-const DENY_WITH_REASON_OPTION = "No, provide reason";
-
-export async function requestPermissionDecisionFromUi(
-	ui: PermissionDecisionUi,
-	title: string,
-	_message: string,
-	options?: { sessionLabel?: string },
-): Promise<PermissionPromptDecision> {
-	const sessionOption = options?.sessionLabel ?? APPROVE_FOR_SESSION_OPTION;
-	const decisionOptions = [
-		APPROVE_OPTION,
-		sessionOption,
-		DENY_OPTION,
-		DENY_WITH_REASON_OPTION,
-	];
-	const selected = await ui.select(title, decisionOptions);
-	if (!selected || selected === DENY_OPTION) {
-		return { approved: false, state: "denied" };
-	}
-	if (selected === DENY_WITH_REASON_OPTION) {
-		const reason = await ui.input("Reason for denial", "optional");
-		return reason
-			? { approved: false, state: "denied_with_reason", denialReason: reason }
-			: { approved: false, state: "denied" };
-	}
-	if (selected === sessionOption) {
-		return { approved: true, state: "approved_for_session" };
-	}
-	return { approved: true, state: "approved" };
-}

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

@@ -1,81 +0,0 @@
-import { expandHomePath } from "./expand-home.ts";
-
-export type CompiledWildcardPattern<TState> = {
-	pattern: string;
-	state: TState;
-	regex: RegExp;
-};
-
-export type WildcardPatternMatch<TState> = {
-	state: TState;
-	matchedPattern: string;
-	matchedName: string;
-};
-
-export interface WildcardMatchOptions {
-	caseInsensitive?: boolean;
-	windowsSeparators?: boolean;
-}
-
-function escapeRegExp(value: string): string {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-export function compileWildcardPattern<TState>(
-	pattern: string,
-	state: TState,
-	options?: WildcardMatchOptions,
-): CompiledWildcardPattern<TState> {
-	let expanded = expandHomePath(pattern);
-	if (options?.windowsSeparators) {
-		expanded = expanded.replaceAll("/", "\\");
-	}
-	let escaped = expanded
-		.split("*")
-		.map((part) => escapeRegExp(part).replaceAll("\\?", "."))
-		.join(".*");
-
-	if (escaped.endsWith(" .*")) {
-		escaped = `${escaped.slice(0, -3)}( .*)?`;
-	}
-
-	return {
-		pattern,
-		state,
-		regex: new RegExp(`^${escaped}$`, options?.caseInsensitive ? "si" : "s"),
-	};
-}
-
-export function compileWildcardPatternEntries<TState>(
-	entries: Iterable<readonly [string, TState]>,
-	options?: WildcardMatchOptions,
-): CompiledWildcardPattern<TState>[] {
-	return Array.from(entries, ([pattern, state]) =>
-		compileWildcardPattern(pattern, state, options),
-	);
-}
-
-export function findCompiledWildcardMatch<TState>(
-	patterns: readonly CompiledWildcardPattern<TState>[],
-	name: string,
-): WildcardPatternMatch<TState> | null {
-	for (let index = patterns.length - 1; index >= 0; index -= 1) {
-		const pattern = patterns[index];
-		if (pattern.regex.test(name)) {
-			return {
-				state: pattern.state,
-				matchedPattern: pattern.pattern,
-				matchedName: name,
-			};
-		}
-	}
-	return null;
-}
-
-export function wildcardMatch(
-	pattern: string,
-	value: string,
-	options?: WildcardMatchOptions,
-): boolean {
-	return compileWildcardPattern(pattern, null, options).regex.test(value);
-}

package/node_modules/@vitos-pizza/permission-system/src/yaml-frontmatter.ts

@@ -1,84 +0,0 @@
-export function extractFrontmatter(content: string): {
-	frontmatter: string;
-	body: string;
-} | null {
-	const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(content);
-	if (!match) return null;
-	return {
-		frontmatter: match[1],
-		body: content.slice(match[0].length),
-	};
-}
-
-export function parseSimpleYamlMap(yaml: string): Record<string, unknown> {
-	const result: Record<string, unknown> = {};
-	const lines = yaml.split(/\r?\n/);
-	let currentKey: string | null = null;
-	let currentIndent = 0;
-	const nested: Record<string, Record<string, unknown>> = {};
-
-	for (const rawLine of lines) {
-		if (!rawLine.trim() || rawLine.trim().startsWith("#")) continue;
-
-		const indent = rawLine.search(/\S/);
-		const trimmed = rawLine.trim();
-
-		if (indent === 0) {
-			const colon = trimmed.indexOf(":");
-			if (colon === -1) continue;
-			const key = trimmed.slice(0, colon).trim();
-			const value = trimmed.slice(colon + 1).trim();
-			currentKey = key;
-			currentIndent = 0;
-			if (value) {
-				result[key] = parseScalar(value);
-			} else {
-				nested[key] = {};
-				result[key] = nested[key];
-			}
-			continue;
-		}
-
-		if (currentKey && indent > currentIndent) {
-			const colon = trimmed.indexOf(":");
-			if (colon === -1) continue;
-			const key = trimmed.slice(0, colon).trim();
-			const value = trimmed.slice(colon + 1).trim();
-			const bucket = nested[currentKey] ?? {};
-			if (!nested[currentKey]) nested[currentKey] = bucket;
-			bucket[key] = parseScalar(value);
-		}
-	}
-
-	return result;
-}
-
-function parseScalar(value: string): unknown {
-	if (
-		(value.startsWith('"') && value.endsWith('"')) ||
-		(value.startsWith("'") && value.endsWith("'"))
-	) {
-		return value.slice(1, -1);
-	}
-	if (value === "true") return true;
-	if (value === "false") return false;
-	if (value === "null") return null;
-	return value;
-}
-
-export function parseAgentFrontmatterPermission(
-	content: string,
-): Record<string, unknown> | null {
-	const extracted = extractFrontmatter(content);
-	if (!extracted) return null;
-	const map = parseSimpleYamlMap(extracted.frontmatter);
-	const permission = map.permission;
-	if (
-		!permission ||
-		typeof permission !== "object" ||
-		Array.isArray(permission)
-	) {
-		return null;
-	}
-	return permission as Record<string, unknown>;
-}

package/node_modules/@vitos-pizza/permission-system/src/yolo/runtime-api.ts

@@ -1,49 +0,0 @@
-import type { ExtensionConfig } from "../types.ts";
-
-export interface YoloRuntimeApi {
-	getYoloMode(): boolean;
-	setYoloMode(
-		enabled: boolean,
-		options?: { persist?: boolean },
-	): { error?: string };
-	toggleYoloMode(options?: { persist?: boolean; source?: string }): {
-		error?: string;
-	};
-}
-
-type PermissionSystemGlobal = typeof globalThis & {
-	__piPermissionSystem?: YoloRuntimeApi;
-};
-
-export function installYoloRuntimeApi(
-	getConfig: () => ExtensionConfig,
-	setConfig: (config: ExtensionConfig) => void,
-	onConfigChange?: (config: ExtensionConfig) => void,
-): YoloRuntimeApi {
-	const applyConfig = (next: ExtensionConfig, persist: boolean) => {
-		if (persist) {
-			setConfig(next);
-		} else {
-			Object.assign(getConfig(), next);
-		}
-		onConfigChange?.(getConfig());
-	};
-
-	const api: YoloRuntimeApi = {
-		getYoloMode() {
-			return getConfig().yoloMode === true;
-		},
-		setYoloMode(enabled, options = {}) {
-			const next = { ...getConfig(), yoloMode: enabled };
-			applyConfig(next, options.persist !== false);
-			return {};
-		},
-		toggleYoloMode(options = {}) {
-			const enabled = !(getConfig().yoloMode === true);
-			return api.setYoloMode(enabled, options);
-		},
-	};
-
-	(globalThis as PermissionSystemGlobal).__piPermissionSystem = api;
-	return api;
-}

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

@@ -1,32 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { evaluateBashCommand } from "../src/bash/matcher.ts";
-import {
-	enumerateBashCommands,
-	isTriviallyEmptyCommand,
-} from "../src/bash/parser.ts";
-import { PermissionEvaluator } from "../src/permission-evaluator.ts";
-
-describe("bash parser", () => {
-	it("treats comments as trivially empty", () => {
-		expect(isTriviallyEmptyCommand("# just a comment")).toBe(true);
-	});
-
-	it("splits chained commands", () => {
-		expect(enumerateBashCommands("git status && npm test")).toEqual([
-			{ text: "git status", opaque: false },
-			{ text: "npm test", opaque: false },
-		]);
-	});
-
-	it("fails closed on unparseable non-empty commands", () => {
-		const evaluator = new PermissionEvaluator();
-		const result = evaluateBashCommand(
-			"{{{{",
-			{ "*": "allow", bash: { "*": "allow" } },
-			evaluator,
-			{},
-		);
-		expect(result.state).toBe("ask");
-		expect(result.matchedPattern).toBe("<unparseable-bash-command>");
-	});
-});

package/node_modules/@vitos-pizza/permission-system/tests/detect-preset-mode.test.ts

@@ -1,68 +0,0 @@
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { describe, expect, it } from "vitest";
-import { detectPresetMode } from "../src/detect-preset-mode.ts";
-
-const presetsDir = join(
-	dirname(fileURLToPath(import.meta.url)),
-	"..",
-	"presets",
-);
-
-describe("detect-preset-mode", () => {
-	it("recognizes bundled default preset", () => {
-		const mode = detectPresetMode(
-			{
-				"*": "allow",
-				read: "allow",
-				grep: "allow",
-				find: "allow",
-				ls: "allow",
-				web_search: "ask",
-				web_read: "ask",
-				path: {
-					"*": "allow",
-					"*.env": "deny",
-					"*.env.*": "deny",
-					"*.env.example": "allow",
-					"~/.ssh/*": "deny",
-				},
-				bash: {
-					"*": "ask",
-					"git status": "allow",
-					"git status *": "allow",
-					"git diff": "allow",
-					"git diff *": "allow",
-					"git log": "allow",
-					"git log *": "allow",
-					ls: "allow",
-					"ls *": "allow",
-					"npm test": "allow",
-					"npm test *": "allow",
-					"npm run typecheck": "allow",
-					"npm run lint": "allow",
-					"rm -rf *": "deny",
-					"sudo *": "ask",
-				},
-				external_directory: "ask",
-			},
-			presetsDir,
-		);
-		expect(mode).toBe("default");
-	});
-
-	it("recognizes bundled plan preset", () => {
-		const planPreset = JSON.parse(
-			readFileSync(join(presetsDir, "plan.json"), "utf8"),
-		) as { permission: Record<string, unknown> };
-
-		expect(detectPresetMode(planPreset.permission, presetsDir)).toBe("plan");
-		expect(planPreset.permission.web_search).toBe("ask");
-		expect(planPreset.permission.web_read).toBe("ask");
-	});
-
-	it("returns custom for unknown policy shape", () => {
-		expect(detectPresetMode({ "*": "deny" }, presetsDir)).toBe("custom");
-	});
-});

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

@@ -1,55 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-	forwardPermissionPrompt,
-	PERMISSION_RPC_PROMPT,
-	PERMISSION_RPC_PROMPT_REPLY_PREFIX,
-	startPermissionRpcServer,
-} from "../src/forwarding/forwarder.ts";
-
-describe("permission forwarding", () => {
-	it("forwards prompts over the event bus", async () => {
-		const handlers = new Map<string, Array<(payload: unknown) => void>>();
-		const events = {
-			emit(channel: string, payload: unknown) {
-				for (const handler of handlers.get(channel) ?? []) {
-					handler(payload);
-				}
-			},
-			on(channel: string, handler: (payload: unknown) => void) {
-				const list = handlers.get(channel) ?? [];
-				list.push(handler);
-				handlers.set(channel, list);
-				return () => {
-					handlers.set(
-						channel,
-						(handlers.get(channel) ?? []).filter((item) => item !== handler),
-					);
-				};
-			},
-		};
-
-		startPermissionRpcServer(events, async () => ({
-			approved: true,
-			state: "approved",
-		}));
-
-		const decision = await forwardPermissionPrompt({
-			events,
-			requesterSessionId: "child",
-			targetSessionId: "parent",
-			title: "Allow bash?",
-			message: "git push",
-			surface: "bash",
-			value: "git push",
-			timeoutMs: 1000,
-		});
-
-		expect(decision?.approved).toBe(true);
-		expect(handlers.has(PERMISSION_RPC_PROMPT)).toBe(true);
-		expect(
-			[...handlers.keys()].some((key) =>
-				key.startsWith(PERMISSION_RPC_PROMPT_REPLY_PREFIX),
-			),
-		).toBe(true);
-	});
-});

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

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

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

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