@vitos-pizza/vitos-pizza 0.1.0

package/packages/permission-system/src/permission-session.ts

@@ -0,0 +1,62 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { PermissionEvaluator } from "./permission-evaluator.ts";
+import { PolicyLoader } from "./policy-loader.ts";
+import { SessionApprovals } from "./session-approvals.ts";
+import type { ExtensionConfig } from "./types.ts";
+
+const AGENT_NAME_RE = /<active_agent>\s*([^\s<]+)/i;
+
+export class PermissionSession {
+	readonly evaluator = new PermissionEvaluator();
+	readonly sessionApprovals = new SessionApprovals();
+	private readonly loader: PolicyLoader;
+	private config: ExtensionConfig = { permission: { "*": "ask" } };
+	private cwd = process.cwd();
+	private agentName: string | undefined;
+	private explicitSkillInvocations = new Set<string>();
+
+	constructor(agentDir: string) {
+		this.loader = new PolicyLoader(agentDir);
+	}
+
+	refresh(ctx: ExtensionContext): void {
+		this.cwd = ctx.cwd;
+		this.loader.setCwd(ctx.cwd);
+		this.config = this.loader.load(this.agentName).config;
+	}
+
+	setAgentName(agentName: string | undefined): void {
+		this.agentName = agentName;
+	}
+
+	resolveAgentName(
+		_ctx: ExtensionContext,
+		systemPrompt?: string,
+	): string | undefined {
+		if (this.agentName) return this.agentName;
+		const fromPrompt = systemPrompt
+			? AGENT_NAME_RE.exec(systemPrompt)?.[1]
+			: undefined;
+		return fromPrompt;
+	}
+
+	getConfig(): ExtensionConfig {
+		return this.config;
+	}
+
+	getCwd(): string {
+		return this.cwd;
+	}
+
+	trackExplicitSkillInvocation(skillName: string): void {
+		this.explicitSkillInvocations.add(skillName.trim().toLowerCase());
+	}
+
+	wasExplicitSkillInvocation(skillName: string): boolean {
+		return this.explicitSkillInvocations.has(skillName.trim().toLowerCase());
+	}
+
+	clearExplicitSkillInvocations(): void {
+		this.explicitSkillInvocations.clear();
+	}
+}

package/packages/permission-system/src/policy-loader.ts

@@ -0,0 +1,211 @@
+import {
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	statSync,
+	writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import {
+	getGlobalAgentsDir,
+	getGlobalConfigPath,
+	getProjectAgentsDir,
+	getProjectConfigPath,
+} from "./config-paths.ts";
+import type {
+	ExtensionConfig,
+	FlatPermissionConfig,
+	PatternMap,
+	PatternValue,
+} from "./types.ts";
+import { isDenyWithReason, isPermissionState } from "./types.ts";
+import { parseAgentFrontmatterPermission } from "./yaml-frontmatter.ts";
+
+function stripJsonComments(text: string): string {
+	return text.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|\s)\/\/.*$/gm, "$1");
+}
+
+function toRecord(value: unknown): Record<string, unknown> {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) {
+		return {};
+	}
+	return value as Record<string, unknown>;
+}
+
+function isPatternMap(value: PatternValue): value is PatternMap {
+	return typeof value === "object" && value !== null && !("action" in value);
+}
+
+function normalizePermissionValue(value: unknown): PatternValue | undefined {
+	if (isPermissionState(value)) return value;
+	if (isDenyWithReason(value)) return value;
+	if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+		const nested: PatternMap = {};
+		for (const [key, nestedValue] of Object.entries(value)) {
+			const normalized = normalizePermissionValue(nestedValue);
+			if (normalized !== undefined) nested[key] = normalized;
+		}
+		return Object.keys(nested).length > 0 ? nested : undefined;
+	}
+	return undefined;
+}
+
+function normalizePermissionConfig(raw: unknown): FlatPermissionConfig {
+	const record = toRecord(raw);
+	const result: FlatPermissionConfig = {};
+	for (const [key, value] of Object.entries(record)) {
+		const normalized = normalizePermissionValue(value);
+		if (normalized !== undefined) result[key] = normalized;
+	}
+	return result;
+}
+
+export function loadConfigFile(path: string): ExtensionConfig {
+	try {
+		const raw = readFileSync(path, "utf8");
+		const parsed = JSON.parse(stripJsonComments(raw)) as unknown;
+		const record = toRecord(parsed);
+		const agentMode = record.agentMode;
+		const normalizedAgentMode =
+			agentMode === "agent" ||
+			agentMode === "plan" ||
+			agentMode === "execute"
+				? agentMode
+				: undefined;
+		return {
+			yoloMode: record.yoloMode === true,
+			debug: record.debug === true,
+			agentMode: normalizedAgentMode,
+			permission: normalizePermissionConfig(record.permission),
+		};
+	} catch {
+		return { permission: { "*": "ask" } };
+	}
+}
+
+export function saveConfigFile(path: string, config: ExtensionConfig): void {
+	mkdirSync(join(path, ".."), { recursive: true });
+	writeFileSync(path, `${JSON.stringify(config, null, "\t")}\n`, "utf8");
+}
+
+function getFileStamp(path: string): string {
+	try {
+		return existsSync(path) ? String(statSync(path).mtimeMs) : "missing";
+	} catch {
+		return "missing";
+	}
+}
+
+function findAgentFile(dir: string, agentName: string): string | null {
+	const candidates = [`${agentName}.md`, `${agentName}.agent.md`];
+	for (const name of candidates) {
+		const path = join(dir, name);
+		if (existsSync(path)) return path;
+	}
+	return null;
+}
+
+export interface LoadedPolicy {
+	config: ExtensionConfig;
+	agentPermission?: FlatPermissionConfig;
+}
+
+export class PolicyLoader {
+	private readonly agentDir: string;
+	private cwd: string | null = null;
+	private cacheStamp = "";
+	private cached: LoadedPolicy | null = null;
+
+	constructor(agentDir: string) {
+		this.agentDir = agentDir;
+	}
+
+	setCwd(cwd: string): void {
+		this.cwd = cwd;
+		this.cached = null;
+	}
+
+	load(agentName?: string): LoadedPolicy {
+		const stamp = [
+			getFileStamp(getGlobalConfigPath(this.agentDir)),
+			this.cwd ? getFileStamp(getProjectConfigPath(this.cwd)) : "no-cwd",
+			agentName ?? "no-agent",
+		].join("|");
+		if (this.cached && this.cacheStamp === stamp) {
+			return this.cached;
+		}
+
+		const global = loadConfigFile(getGlobalConfigPath(this.agentDir));
+		const project =
+			this.cwd && existsSync(getProjectConfigPath(this.cwd))
+				? loadConfigFile(getProjectConfigPath(this.cwd))
+				: { permission: {} };
+
+		const mergedPermission = mergePermissionMaps(
+			global.permission ?? {},
+			project.permission ?? {},
+		);
+
+		let agentPermission: FlatPermissionConfig | undefined;
+		if (agentName) {
+			const globalAgentDir = getGlobalAgentsDir(this.agentDir);
+			const projectAgentDir = this.cwd ? getProjectAgentsDir(this.cwd) : null;
+			const globalAgentPath = findAgentFile(globalAgentDir, agentName);
+			const projectAgentPath = projectAgentDir
+				? findAgentFile(projectAgentDir, agentName)
+				: null;
+			const globalAgentPerm = globalAgentPath
+				? loadAgentPermission(globalAgentPath)
+				: {};
+			const projectAgentPerm = projectAgentPath
+				? loadAgentPermission(projectAgentPath)
+				: {};
+			agentPermission = mergePermissionMaps(globalAgentPerm, projectAgentPerm);
+			Object.assign(
+				mergedPermission,
+				mergePermissionMaps(mergedPermission, agentPermission),
+			);
+		}
+
+		const config: ExtensionConfig = {
+			yoloMode: project.yoloMode ?? global.yoloMode ?? false,
+			debug: project.debug ?? global.debug ?? false,
+			agentMode: project.agentMode ?? global.agentMode,
+			permission: mergedPermission,
+		};
+
+		this.cacheStamp = stamp;
+		this.cached = { config, agentPermission };
+		return this.cached;
+	}
+}
+
+function loadAgentPermission(path: string): FlatPermissionConfig {
+	try {
+		const content = readFileSync(path, "utf8");
+		const permission = parseAgentFrontmatterPermission(content);
+		return permission ? normalizePermissionConfig(permission) : {};
+	} catch {
+		return {};
+	}
+}
+
+export function mergePermissionMaps(
+	base: FlatPermissionConfig,
+	override: FlatPermissionConfig,
+): FlatPermissionConfig {
+	const result: FlatPermissionConfig = { ...base };
+	for (const [key, value] of Object.entries(override)) {
+		const existing = result[key];
+		if (
+			existing !== undefined &&
+			isPatternMap(existing) &&
+			isPatternMap(value)
+		) {
+			result[key] = mergePermissionMaps(existing, value);
+		} else {
+			result[key] = value;
+		}
+	}
+	return result;
+}

package/packages/permission-system/src/sanitizers/skill-prompt.ts

@@ -0,0 +1,99 @@
+import type { PermissionEvaluator } from "../permission-evaluator.ts";
+import type { FlatPermissionConfig } from "../types.ts";
+
+export interface SkillPromptEntry {
+	name: string;
+	start: number;
+	end: number;
+}
+
+export function findSkillBlocks(prompt: string): SkillPromptEntry[] {
+	const lines = prompt.replace(/\r\n/g, "\n").split("\n");
+	const entries: SkillPromptEntry[] = [];
+	let current: SkillPromptEntry | null = null;
+
+	for (let index = 0; index < lines.length; index += 1) {
+		const line = lines[index];
+		const match = /^## Skill:\s*(.+)$/.exec(line.trim());
+		if (match) {
+			if (current) {
+				current.end = index;
+				entries.push(current);
+			}
+			current = { name: match[1].trim(), start: index, end: lines.length };
+			continue;
+		}
+		if (/^## /.test(line.trim()) && current) {
+			current.end = index;
+			entries.push(current);
+			current = null;
+		}
+	}
+
+	if (current) entries.push(current);
+	return entries;
+}
+
+export function sanitizeSkillPromptBlocks(
+	prompt: string,
+	permission: FlatPermissionConfig,
+	evaluator: PermissionEvaluator,
+	options: { yoloMode?: boolean; agentName?: string },
+): { prompt: string; entries: SkillPromptEntry[] } {
+	const blocks = findSkillBlocks(prompt);
+	if (blocks.length === 0) return { prompt, entries: [] };
+
+	const lines = prompt.replace(/\r\n/g, "\n").split("\n");
+	const deniedRanges: Array<{ start: number; end: number }> = [];
+	const allowedEntries: SkillPromptEntry[] = [];
+
+	for (const block of blocks) {
+		const result = evaluator.evaluateSurface(
+			permission,
+			"skill",
+			block.name,
+			"project",
+			{ yoloMode: options.yoloMode },
+		);
+		if (result.state === "deny") {
+			deniedRanges.push({ start: block.start, end: block.end });
+		} else {
+			allowedEntries.push(block);
+		}
+	}
+
+	if (deniedRanges.length === 0) {
+		return { prompt, entries: allowedEntries };
+	}
+
+	const keepLine = new Array(lines.length).fill(true);
+	for (const range of deniedRanges) {
+		for (let index = range.start; index < range.end; index += 1) {
+			keepLine[index] = false;
+		}
+	}
+
+	const filtered = lines.filter((_line, index) => keepLine[index]);
+	return {
+		prompt: filtered
+			.join("\n")
+			.replace(/\n{3,}/g, "\n\n")
+			.trimEnd(),
+		entries: allowedEntries,
+	};
+}
+
+export function inferSkillNameFromPath(
+	filePath: string,
+	skillDirs: readonly string[],
+): string | null {
+	const normalized = filePath.replace(/\\/g, "/");
+	for (const dir of skillDirs) {
+		const normalizedDir = dir.replace(/\\/g, "/").replace(/\/$/, "");
+		if (!normalized.startsWith(`${normalizedDir}/`)) continue;
+		const remainder = normalized.slice(normalizedDir.length + 1);
+		const skillName = remainder.split("/")[0];
+		return skillName || null;
+	}
+	return null;
+}

package/packages/permission-system/src/sanitizers/system-prompt.ts

@@ -0,0 +1,221 @@
+export interface SanitizeSystemPromptResult {
+	prompt: string;
+	removed: boolean;
+}
+
+type LineSection = { start: number; end: number };
+
+type GuidelineRule = {
+	matches: (guideline: string) => boolean;
+	shouldKeep: (allowedTools: ReadonlySet<string>) => boolean;
+};
+
+const AVAILABLE_TOOLS_SECTION_HEADER = "Available tools:";
+const GUIDELINES_SECTION_HEADER = "Guidelines:";
+
+const TOOL_GUIDELINE_RULES: readonly GuidelineRule[] = [
+	{
+		matches: (g) => g === "use bash for file operations like ls, rg, find",
+		shouldKeep: (tools) => tools.has("bash"),
+	},
+	{
+		matches: (g) =>
+			g ===
+			"prefer grep/find/ls tools over bash for file exploration (faster, respects .gitignore)",
+		shouldKeep: (tools) =>
+			tools.has("bash") &&
+			(tools.has("grep") || tools.has("find") || tools.has("ls")),
+	},
+	{
+		matches: (g) =>
+			g ===
+				"use read to examine files before editing. you must use this tool instead of cat or sed." ||
+			g === "use read to examine files instead of cat or sed.",
+		shouldKeep: (tools) => tools.has("read"),
+	},
+	{
+		matches: (g) =>
+			g === "use edit for precise changes (old text must match exactly)",
+		shouldKeep: (tools) => tools.has("edit"),
+	},
+	{
+		matches: (g) => g === "use write only for new files or complete rewrites",
+		shouldKeep: (tools) => tools.has("write"),
+	},
+	{
+		matches: (g) =>
+			g ===
+			"when summarizing your actions, output plain text directly - do not use cat or bash to display what you did",
+		shouldKeep: (tools) => tools.has("edit") || tools.has("write"),
+	},
+	{
+		matches: (g) =>
+			g ===
+			"use task when work should be delegated to one or more specialized agents instead of handled entirely in the current session.",
+		shouldKeep: (tools) => tools.has("task"),
+	},
+	{
+		matches: (g) =>
+			g ===
+			"use mcp for mcp discovery first: search by capability, describe one exact tool name, then call it.",
+		shouldKeep: (tools) => tools.has("mcp"),
+	},
+];
+
+function normalizePrompt(prompt: string): string {
+	return (prompt || "").replace(/\r\n/g, "\n");
+}
+
+function collapseExtraBlankLines(text: string): string {
+	return text.replace(/\n{3,}/g, "\n\n").trimEnd();
+}
+
+function normalizeGuidelineText(line: string): string {
+	return line
+		.trim()
+		.replace(/^[-*]\s+/, "")
+		.replace(/\s+/g, " ")
+		.toLowerCase();
+}
+
+function isTopLevelSectionHeader(line: string): boolean {
+	const trimmed = line.trim();
+	return (
+		trimmed.length > 0 && trimmed.endsWith(":") && !trimmed.startsWith("-")
+	);
+}
+
+function isSectionBodyLine(line: string): boolean {
+	const trimmed = line.trim();
+	if (!trimmed) return true;
+	if (trimmed.startsWith("- ")) return true;
+	return line !== line.trimStart();
+}
+
+function findSection(
+	lines: readonly string[],
+	header: string,
+): LineSection | null {
+	const start = lines.findIndex((line) => line.trim() === header);
+	if (start === -1) return null;
+
+	for (let index = start + 1; index < lines.length; index += 1) {
+		if (isTopLevelSectionHeader(lines[index])) {
+			return { start, end: index };
+		}
+	}
+
+	let end = start + 1;
+	for (let index = start + 1; index < lines.length; index += 1) {
+		if (!isSectionBodyLine(lines[index])) {
+			end = index;
+			break;
+		}
+		end = index + 1;
+	}
+	return { start, end };
+}
+
+function extractToolBulletName(line: string): string | null {
+	const match = /^\s*-\s+([A-Za-z0-9_-]+)/.exec(line);
+	return match ? match[1] : null;
+}
+
+function narrowAvailableToolsSection(
+	lines: readonly string[],
+	allowedTools: ReadonlySet<string>,
+): { lines: string[]; removed: boolean } {
+	const section = findSection(lines, AVAILABLE_TOOLS_SECTION_HEADER);
+	if (!section) return { lines: [...lines], removed: false };
+
+	const before = lines.slice(0, section.start);
+	const header = lines[section.start];
+	const body = lines.slice(section.start + 1, section.end);
+	const after = lines.slice(section.end);
+
+	const filteredBody = body.filter((line) => {
+		const toolName = extractToolBulletName(line);
+		if (!toolName) return true;
+		return allowedTools.has(toolName);
+	});
+
+	const removed = filteredBody.length !== body.length;
+	if (!removed) return { lines: [...lines], removed: false };
+
+	const hasToolBullet = filteredBody.some(
+		(line) => extractToolBulletName(line) !== null,
+	);
+	if (!hasToolBullet) return { lines: [...before, ...after], removed: true };
+
+	return {
+		lines: [...before, header, ...filteredBody, ...after],
+		removed: true,
+	};
+}
+
+function shouldKeepGuideline(
+	line: string,
+	allowedTools: ReadonlySet<string>,
+): boolean {
+	const normalized = normalizeGuidelineText(line);
+	for (const rule of TOOL_GUIDELINE_RULES) {
+		if (rule.matches(normalized)) return rule.shouldKeep(allowedTools);
+	}
+	return true;
+}
+
+function sanitizeGuidelinesSection(
+	lines: readonly string[],
+	allowedTools: ReadonlySet<string>,
+): { lines: string[]; removed: boolean } {
+	const section = findSection(lines, GUIDELINES_SECTION_HEADER);
+	if (!section) return { lines: [...lines], removed: false };
+
+	const before = lines.slice(0, section.start + 1);
+	const after = lines.slice(section.end);
+	const body = lines.slice(section.start + 1, section.end);
+	const filteredBody = body.filter((line) => {
+		const trimmed = line.trim();
+		if (!trimmed.startsWith("- ")) return true;
+		return shouldKeepGuideline(line, allowedTools);
+	});
+
+	const removed = filteredBody.length !== body.length;
+	if (!removed) return { lines: [...lines], removed: false };
+
+	const hasBullet = filteredBody.some((line) => line.trim().startsWith("- "));
+	if (!hasBullet) {
+		return {
+			lines: [...lines.slice(0, section.start), ...after],
+			removed: true,
+		};
+	}
+
+	return { lines: [...before, ...filteredBody, ...after], removed: true };
+}
+
+export function sanitizeAvailableToolsSection(
+	systemPrompt: string,
+	allowedToolNames: readonly string[],
+): SanitizeSystemPromptResult {
+	const allowedTools = new Set(
+		allowedToolNames.map((toolName) => toolName.trim()).filter(Boolean),
+	);
+	const normalizedLines = normalizePrompt(systemPrompt).split("\n");
+	const narrowedToolsSection = narrowAvailableToolsSection(
+		normalizedLines,
+		allowedTools,
+	);
+	const sanitizedGuidelines = sanitizeGuidelinesSection(
+		narrowedToolsSection.lines,
+		allowedTools,
+	);
+	const removed = narrowedToolsSection.removed || sanitizedGuidelines.removed;
+
+	return {
+		prompt: removed
+			? collapseExtraBlankLines(sanitizedGuidelines.lines.join("\n"))
+			: systemPrompt,
+		removed,
+	};
+}

package/packages/permission-system/src/service.ts

@@ -0,0 +1,66 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { PermissionEvaluator } from "./permission-evaluator.ts";
+import type { SessionApprovals } from "./session-approvals.ts";
+import type { ExtensionConfig, PermissionCheckResult } from "./types.ts";
+
+export interface PermissionsService {
+	checkPermission(surface: string, value: string): PermissionCheckResult;
+	getToolPermission(toolName: string): "allow" | "ask" | "deny";
+}
+
+let serviceInstance: PermissionsService | null = null;
+
+export function setPermissionsService(
+	service: PermissionsService | null,
+): void {
+	serviceInstance = service;
+}
+
+export function getPermissionsService(): PermissionsService | null {
+	return serviceInstance;
+}
+
+export function createPermissionsService(deps: {
+	getConfig: () => ExtensionConfig;
+	evaluator: PermissionEvaluator;
+	sessionApprovals: SessionApprovals;
+	getAgentName: () => string | undefined;
+}): PermissionsService {
+	return {
+		checkPermission(surface, value) {
+			const config = deps.getConfig();
+			return deps.evaluator.evaluateSurface(
+				config.permission ?? {},
+				surface,
+				value,
+				"project",
+				{
+					yoloMode: config.yoloMode,
+					sessionApprovals: deps.sessionApprovals,
+				},
+			);
+		},
+		getToolPermission(toolName) {
+			const config = deps.getConfig();
+			return deps.evaluator.getToolPermission(
+				config.permission ?? {},
+				toolName,
+				{
+					yoloMode: config.yoloMode,
+					sessionApprovals: deps.sessionApprovals,
+				},
+			);
+		},
+	};
+}
+
+export function emitPermissionEvent(
+	pi: ExtensionAPI,
+	channel:
+		| "permissions:ready"
+		| "permissions:decision"
+		| "permissions:ui_prompt",
+	payload: unknown,
+): void {
+	pi.events.emit(channel, payload);
+}

package/packages/permission-system/src/session-approvals.ts

@@ -0,0 +1 @@
+export { SessionApprovals } from "./permission-evaluator.ts";