@adeildo/pi-ask-permission 4.0.0

package/src/core/config/decode.ts

@@ -0,0 +1,118 @@
+import {
+	boolean,
+	type Decoder,
+	duration,
+	fail,
+	fieldPath,
+	formatProblems,
+	isObject,
+	literal,
+	nullable,
+	object,
+	pass,
+	problem,
+	type Problem,
+	stringList,
+	withDefault,
+	withDefaultOf,
+} from "@adeildo/pi-kit";
+
+import {
+	DEFAULT_CONFIG,
+	DEFAULT_TYPING,
+	DEFAULT_WORKSPACE,
+	defaultConfig,
+	type NoUIMode,
+	type PermissionConfig,
+	type TypingConfig,
+	type WorkspaceConfig,
+} from "#core/config/schema.ts";
+import { defaultJudge } from "#core/judge/config.ts";
+import { judgeConfig } from "#core/judge/decode.ts";
+import { DEFAULT_MODE } from "#core/mode.ts";
+
+export type NoUIConfig = NoUIMode | Record<string, NoUIMode>;
+
+export const noUI: Decoder<NoUIConfig> = {
+	decode(input, path) {
+		if (input === "allow" || input === "deny") return pass(input);
+		if (!isObject(input)) return fail(problem(path, 'expected "allow", "deny", or a per-tool map'));
+
+		const problems: Problem[] = [];
+		const value: Record<string, NoUIMode> = {};
+		for (const [tool, entry] of Object.entries(input)) {
+			if (entry === "allow" || entry === "deny") value[tool] = entry;
+			else problems.push(problem(fieldPath(path, tool), 'expected "allow" or "deny"'));
+		}
+		return pass(value, problems);
+	},
+};
+
+const typing: Decoder<TypingConfig> = object({
+	pause: withDefault(duration, DEFAULT_TYPING.pause),
+	maxWait: withDefault(nullable(duration), DEFAULT_TYPING.maxWait),
+});
+
+const workspace: Decoder<WorkspaceConfig> = object({
+	roots: withDefaultOf(stringList("paths"), () => [...DEFAULT_WORKSPACE.roots]),
+	outside: withDefault(literal("ask", "deny", "allow"), DEFAULT_WORKSPACE.outside),
+});
+
+const config: Decoder<PermissionConfig> = object({
+	allow: withDefaultOf(stringList("tool names"), () => [...DEFAULT_CONFIG.allow]),
+	noUI: withDefaultOf(noUI, () => DEFAULT_CONFIG.noUI),
+	notes: withDefault(literal("result", "message"), DEFAULT_CONFIG.notes),
+	mode: withDefault(literal("manual", "accept-edits", "auto"), DEFAULT_MODE),
+	readOnlyBash: withDefault(boolean, DEFAULT_CONFIG.readOnlyBash),
+	workspace: withDefaultOf(workspace, () => ({
+		...DEFAULT_WORKSPACE,
+		roots: [...DEFAULT_WORKSPACE.roots],
+	})),
+	typing: withDefaultOf(typing, () => ({ ...DEFAULT_TYPING })),
+	judge: withDefaultOf(judgeConfig, defaultJudge),
+});
+
+export function decodeConfig(input: unknown, warnings: string[] = []): PermissionConfig {
+	const result = config.decode(migrate(input, warnings), "");
+	warnings.push(...formatProblems(result.problems));
+
+	return result.ok ? result.value : defaultConfig();
+}
+
+const RENAMED: [section: "judge" | undefined, from: string, to: string][] = [
+	[undefined, "followup", "notes"],
+	[undefined, "headless", "noUI"],
+	["judge", "backend", "provider"],
+	["judge", "autoDeny", "canDeny"],
+	["judge", "onUncertain", "whenUnsure"],
+	["judge", "onError", "whenItFails"],
+	["judge", "never", "alwaysAsk"],
+	["judge", "headless", "noUI"],
+	["judge", "grant", "rememberApprovals"],
+];
+
+// A rename keeps the value and says nothing. The migration writes the new names.
+function migrate(input: unknown, warnings: string[]): unknown {
+	if (!isObject(input)) return input;
+
+	const next: Record<string, unknown> = { ...input };
+	if (isObject(next.judge)) next.judge = { ...next.judge };
+
+	for (const [section, from, to] of RENAMED) {
+		const target = section === undefined ? next : next[section];
+		if (!isObject(target) || !(from in target)) continue;
+
+		if (!(to in target)) target[to] = target[from];
+		delete target[from];
+	}
+
+	if (next.mode === "yolo") {
+		next.mode = "auto";
+		warnings.push('mode "yolo" is now "auto", with workspace.outside "allow" for the same reach');
+	}
+	if ("yolo" in next) {
+		delete next.yolo;
+		warnings.push("yolo is gone, the mode is picked per session");
+	}
+	return next;
+}

package/src/core/config/patterns.ts

@@ -0,0 +1,51 @@
+import type { NoUIMode, PermissionConfig } from "#core/config/schema.ts";
+
+const patternCache = new Map<string, RegExp>();
+
+export function matchesPattern(pattern: string, value: string): boolean {
+	if (pattern === "*") return true;
+
+	let compiled = patternCache.get(pattern);
+	if (!compiled) {
+		const escaped = pattern
+			.replace(/[.+^${}()|[\]\\]/g, "\\$&")
+			.replace(/\*/g, ".*")
+			.replace(/\?/g, ".");
+		compiled = new RegExp(`^${escaped}$`);
+		patternCache.set(pattern, compiled);
+	}
+	return compiled.test(value);
+}
+
+export function isAllowed(config: PermissionConfig, toolName: string): boolean {
+	return config.allow.some((pattern) => matchesPattern(pattern, toolName));
+}
+
+export function isJudged(config: PermissionConfig, toolName: string): boolean {
+	return (
+		config.judge.enabled && config.judge.tools.some((pattern) => matchesPattern(pattern, toolName))
+	);
+}
+
+export function noUIMode(config: PermissionConfig, toolName: string): NoUIMode {
+	if (typeof config.noUI === "string") return config.noUI;
+
+	let bestScore = 0;
+	let best: NoUIMode | undefined;
+	for (const [pattern, value] of Object.entries(config.noUI)) {
+		if (!matchesPattern(pattern, toolName)) continue;
+
+		const score = specificity(pattern);
+		if (score >= bestScore) {
+			bestScore = score;
+			best = value;
+		}
+	}
+	return best ?? "deny";
+}
+
+function specificity(pattern: string): number {
+	if (pattern === "*") return 1;
+	if (pattern.includes("*") || pattern.includes("?")) return 2;
+	return 3;
+}

package/src/core/config/schema.ts

@@ -0,0 +1,72 @@
+import { DEFAULT_JUDGE, defaultJudge, type JudgeConfig } from "#core/judge/config.ts";
+import { DEFAULT_MODE, type PermissionMode } from "#core/mode.ts";
+
+export type NoUIMode = "allow" | "deny";
+
+export type NoteDelivery = "result" | "message";
+
+export type OutsideScope = "ask" | "deny" | "allow";
+
+export interface WorkspaceConfig {
+	roots: string[];
+	outside: OutsideScope;
+}
+
+export interface TypingConfig {
+	pause: number;
+	maxWait: number | null;
+}
+
+export interface PermissionConfig {
+	allow: string[];
+	noUI: NoUIMode | Record<string, NoUIMode>;
+	notes: NoteDelivery;
+	mode: PermissionMode;
+	readOnlyBash: boolean;
+	workspace: WorkspaceConfig;
+	typing: TypingConfig;
+	judge: JudgeConfig;
+}
+
+export const DEFAULT_TYPING: TypingConfig = {
+	pause: 1000,
+	maxWait: null,
+};
+
+export const DEFAULT_WORKSPACE: WorkspaceConfig = {
+	roots: ["."],
+	outside: "ask",
+};
+
+export const DEFAULT_CONFIG: PermissionConfig = {
+	allow: ["read", "grep", "find", "ls"],
+	noUI: "deny",
+	notes: "result",
+	mode: DEFAULT_MODE,
+	readOnlyBash: true,
+	workspace: DEFAULT_WORKSPACE,
+	typing: DEFAULT_TYPING,
+	judge: DEFAULT_JUDGE,
+};
+
+export function defaultConfig(): PermissionConfig {
+	return {
+		...DEFAULT_CONFIG,
+		allow: [...DEFAULT_CONFIG.allow],
+		workspace: { ...DEFAULT_WORKSPACE, roots: [...DEFAULT_WORKSPACE.roots] },
+		typing: { ...DEFAULT_CONFIG.typing },
+		judge: defaultJudge(),
+	};
+}
+
+export function isNoUIMode(value: unknown): value is NoUIMode {
+	return value === "allow" || value === "deny";
+}
+
+export function isNoteDelivery(value: unknown): value is NoteDelivery {
+	return value === "result" || value === "message";
+}
+
+export function isOutsideScope(value: unknown): value is OutsideScope {
+	return value === "ask" || value === "deny" || value === "allow";
+}

package/src/core/config/settings.ts

@@ -0,0 +1,374 @@
+// The permission config lives in the shared settings file, one key per leaf, so the settings screen
+// comes from these declarations instead of a screen written by hand. The nested config the rest of
+// the package reads is assembled here, and writing maps back to the same keys.
+import { existsSync, renameSync } from "node:fs";
+
+import {
+	boolean,
+	type Decoder,
+	duration,
+	literal,
+	nullable,
+	type Setting,
+	setting,
+	type SettingsScope,
+	string,
+	stringList,
+	trimmedString,
+	unit,
+} from "@adeildo/pi-kit";
+
+import { type NoUIConfig, noUI } from "#core/config/decode.ts";
+import {
+	DEFAULT_CONFIG,
+	DEFAULT_TYPING,
+	DEFAULT_WORKSPACE,
+	type NoteDelivery,
+	type OutsideScope,
+	type PermissionConfig,
+	type TypingConfig,
+	type WorkspaceConfig,
+} from "#core/config/schema.ts";
+import { configPath, readLegacyConfig } from "#core/config/store.ts";
+import { DEFAULT_JUDGE, type JudgeBackendId, type JudgeFallback } from "#core/judge/config.ts";
+import { DEFAULT_MODE, PERMISSION_MODES, type PermissionMode } from "#core/mode.ts";
+
+const PERMISSION = "Permission";
+const JUDGE = "Permission judge";
+
+function leaf<T>(
+	id: string,
+	fallback: T,
+	decoder: Decoder<T>,
+	label: string,
+	description: string,
+	ui = PERMISSION,
+): Setting<T> {
+	return setting({
+		id: `permission.${id}`,
+		default: fallback,
+		decoder,
+		ui: { group: ui, label, description },
+	});
+}
+
+const PERMISSION_LEAVES = {
+	allow: leaf(
+		"allow",
+		DEFAULT_CONFIG.allow,
+		stringList("tool names"),
+		"Allowed tools",
+		"Tools that run without asking.",
+	),
+	noUI: leaf<NoUIConfig>(
+		"noUI",
+		DEFAULT_CONFIG.noUI,
+		noUI,
+		"Without a dialog",
+		'What to do when there is no dialog to ask in: "allow", "deny", or a map per tool.',
+	),
+	notes: leaf<NoteDelivery>(
+		"notes",
+		DEFAULT_CONFIG.notes,
+		literal("result", "message"),
+		"Note delivery",
+		'"result" attaches your note to the tool result, "message" sends it as a message.',
+	),
+	mode: leaf<PermissionMode>(
+		"mode",
+		DEFAULT_MODE,
+		literal(...PERMISSION_MODES),
+		"Default mode",
+		"The mode a new session starts in.",
+	),
+	readOnlyBash: leaf(
+		"readOnlyBash",
+		DEFAULT_CONFIG.readOnlyBash,
+		boolean,
+		"Read-only bash",
+		"Let commands that only read run without asking.",
+	),
+	roots: leaf(
+		"workspace.roots",
+		DEFAULT_WORKSPACE.roots,
+		stringList("paths"),
+		"Workspace roots",
+		"Paths the project is made of.",
+	),
+	outside: leaf<OutsideScope>(
+		"workspace.outside",
+		DEFAULT_WORKSPACE.outside,
+		literal("ask", "deny", "allow"),
+		"Outside the workspace",
+		"What to do with a path outside the roots.",
+	),
+	pause: leaf(
+		"typing.pause",
+		DEFAULT_TYPING.pause,
+		duration,
+		"Typing pause",
+		"How long after you stop typing the dialog opens.",
+	),
+	maxWait: leaf<number | null>(
+		"typing.maxWait",
+		DEFAULT_TYPING.maxWait,
+		nullable(duration),
+		"Typing wait cap",
+		"Longest the dialog waits while you type. Empty means no cap.",
+	),
+};
+
+const JUDGE_LEAVES = {
+	enabled: leaf(
+		"judge.enabled",
+		DEFAULT_JUDGE.enabled,
+		boolean,
+		"Judge enabled",
+		"Let a model decide the routine calls.",
+		JUDGE,
+	),
+	provider: leaf<JudgeBackendId>(
+		"judge.provider",
+		DEFAULT_JUDGE.provider,
+		literal("jev", "pi"),
+		"Judge backend",
+		'"jev" asks TypeSafe, "pi" asks the model you are already using.',
+		JUDGE,
+	),
+	model: leaf(
+		"judge.model",
+		DEFAULT_JUDGE.model,
+		trimmedString,
+		"Judge model",
+		"A Jev alias, or provider/modelId for the pi backend.",
+		JUDGE,
+	),
+	tools: leaf(
+		"judge.tools",
+		DEFAULT_JUDGE.tools,
+		stringList("patterns"),
+		"Judged tools",
+		"Tool patterns the judge may decide. Empty means it never runs.",
+		JUDGE,
+	),
+	alwaysAsk: leaf(
+		"judge.alwaysAsk",
+		DEFAULT_JUDGE.alwaysAsk,
+		stringList("patterns"),
+		"Always ask me",
+		"Tool patterns that skip the judge and come to you.",
+		JUDGE,
+	),
+	allowThreshold: leaf(
+		"judge.thresholds.allow",
+		DEFAULT_JUDGE.thresholds.allow,
+		unit,
+		"Judge confidence to allow",
+		"How sure the judge has to be before a call runs.",
+		JUDGE,
+	),
+	denyThreshold: leaf(
+		"judge.thresholds.deny",
+		DEFAULT_JUDGE.thresholds.deny,
+		unit,
+		"Judge confidence to deny",
+		"How sure the judge has to be before it blocks a call on its own.",
+		JUDGE,
+	),
+	riskCeiling: leaf(
+		"judge.riskCeiling",
+		DEFAULT_JUDGE.riskCeiling,
+		unit,
+		"Risk ceiling",
+		"Above this risk the call comes to you, however sure the judge is.",
+		JUDGE,
+	),
+	whenUnsure: leaf<JudgeFallback>(
+		"judge.whenUnsure",
+		DEFAULT_JUDGE.whenUnsure,
+		literal("ask", "allow", "deny"),
+		"When the judge is unsure",
+		"What to do near the thresholds.",
+		JUDGE,
+	),
+	canDeny: leaf(
+		"judge.canDeny",
+		DEFAULT_JUDGE.canDeny,
+		boolean,
+		"Judge may deny",
+		"Let the judge block a call instead of asking you.",
+		JUDGE,
+	),
+	whenItFails: leaf<JudgeFallback>(
+		"judge.whenItFails",
+		DEFAULT_JUDGE.whenItFails,
+		literal("ask", "allow", "deny"),
+		"When the judge fails",
+		"What to do when the judge errors or times out.",
+		JUDGE,
+	),
+	noUI: leaf(
+		"judge.noUI",
+		DEFAULT_JUDGE.noUI,
+		boolean,
+		"Judge without a dialog",
+		"Run the judge even where there is nobody to ask.",
+		JUDGE,
+	),
+	dryRun: leaf(
+		"judge.dryRun",
+		DEFAULT_JUDGE.dryRun,
+		boolean,
+		"Judge dry run",
+		"Ask the judge and log the verdict, deciding nothing.",
+		JUDGE,
+	),
+	rememberApprovals: leaf(
+		"judge.rememberApprovals",
+		DEFAULT_JUDGE.rememberApprovals,
+		boolean,
+		"Remember judge approvals",
+		"Treat an always-yes as a rule for the judge later.",
+		JUDGE,
+	),
+	timeoutMs: leaf(
+		"judge.timeoutMs",
+		DEFAULT_JUDGE.timeoutMs,
+		duration,
+		"Judge timeout",
+		"How long to wait before the call comes to you.",
+		JUDGE,
+	),
+	cache: leaf(
+		"judge.cache",
+		DEFAULT_JUDGE.cache,
+		boolean,
+		"Judge cache",
+		"Reuse a verdict for the same call in one session.",
+		JUDGE,
+	),
+	policy: leaf(
+		"judge.policy",
+		DEFAULT_JUDGE.policy,
+		string,
+		"Judge policy",
+		"The rulebook the judge reads. Plain English.",
+		JUDGE,
+	),
+};
+
+export const PERMISSION_SETTINGS: readonly Setting<unknown>[] = [
+	...Object.values(PERMISSION_LEAVES),
+	...Object.values(JUDGE_LEAVES),
+];
+
+/** A fresh object every read, so a caller that mutates one cannot change the defaults. */
+export function readConfig(scope: SettingsScope): PermissionConfig {
+	const leaves = PERMISSION_LEAVES;
+	const judge = JUDGE_LEAVES;
+
+	return {
+		allow: [...leaves.allow.get(scope)],
+		noUI: leaves.noUI.get(scope),
+		notes: leaves.notes.get(scope),
+		mode: leaves.mode.get(scope),
+		readOnlyBash: leaves.readOnlyBash.get(scope),
+		workspace: workspaceOf(scope),
+		typing: typingOf(scope),
+		judge: {
+			enabled: judge.enabled.get(scope),
+			provider: judge.provider.get(scope),
+			model: judge.model.get(scope),
+			tools: [...judge.tools.get(scope)],
+			alwaysAsk: [...judge.alwaysAsk.get(scope)],
+			thresholds: { allow: judge.allowThreshold.get(scope), deny: judge.denyThreshold.get(scope) },
+			riskCeiling: judge.riskCeiling.get(scope),
+			whenUnsure: judge.whenUnsure.get(scope),
+			canDeny: judge.canDeny.get(scope),
+			whenItFails: judge.whenItFails.get(scope),
+			noUI: judge.noUI.get(scope),
+			dryRun: judge.dryRun.get(scope),
+			rememberApprovals: judge.rememberApprovals.get(scope),
+			timeoutMs: judge.timeoutMs.get(scope),
+			cache: judge.cache.get(scope),
+			policy: judge.policy.get(scope),
+		},
+	};
+}
+
+export function writeConfig(scope: SettingsScope, config: PermissionConfig): string | undefined {
+	return scope.settings.setAll(toEntries(config));
+}
+
+/**
+ * Moves the pre-4.0 config.json into the shared settings and keeps it as a `.bak`. A value that
+ * already reads the same is not written, so migrating a default config leaves no keys behind.
+ */
+export function migrateConfig(scope: SettingsScope): string[] {
+	const path = configPath();
+	if (!existsSync(path)) return [];
+
+	const loaded = readLegacyConfig();
+	const failure = writeConfig(scope, loaded.config);
+	if (failure !== undefined)
+		return [...loaded.warnings, `could not move ${path} to the shared settings: ${failure}`];
+
+	const backup = `${path}.bak`;
+	try {
+		renameSync(path, backup);
+	} catch (error) {
+		return [...loaded.warnings, `could not keep a copy of ${path}: ${describeError(error)}`];
+	}
+	return [...loaded.warnings, `moved the config to the shared settings, keeping ${backup}`];
+}
+
+function workspaceOf(scope: SettingsScope): WorkspaceConfig {
+	return {
+		roots: [...PERMISSION_LEAVES.roots.get(scope)],
+		outside: PERMISSION_LEAVES.outside.get(scope),
+	};
+}
+
+function typingOf(scope: SettingsScope): TypingConfig {
+	return {
+		pause: PERMISSION_LEAVES.pause.get(scope),
+		maxWait: PERMISSION_LEAVES.maxWait.get(scope),
+	};
+}
+
+function toEntries(config: PermissionConfig): (readonly [Setting<unknown>, unknown])[] {
+	const leaves = PERMISSION_LEAVES;
+	const judge = JUDGE_LEAVES;
+	return [
+		[leaves.allow, config.allow],
+		[leaves.noUI, config.noUI],
+		[leaves.notes, config.notes],
+		[leaves.mode, config.mode],
+		[leaves.readOnlyBash, config.readOnlyBash],
+		[leaves.roots, config.workspace.roots],
+		[leaves.outside, config.workspace.outside],
+		[leaves.pause, config.typing.pause],
+		[leaves.maxWait, config.typing.maxWait],
+		[judge.enabled, config.judge.enabled],
+		[judge.provider, config.judge.provider],
+		[judge.model, config.judge.model],
+		[judge.tools, config.judge.tools],
+		[judge.alwaysAsk, config.judge.alwaysAsk],
+		[judge.allowThreshold, config.judge.thresholds.allow],
+		[judge.denyThreshold, config.judge.thresholds.deny],
+		[judge.riskCeiling, config.judge.riskCeiling],
+		[judge.whenUnsure, config.judge.whenUnsure],
+		[judge.canDeny, config.judge.canDeny],
+		[judge.whenItFails, config.judge.whenItFails],
+		[judge.noUI, config.judge.noUI],
+		[judge.dryRun, config.judge.dryRun],
+		[judge.rememberApprovals, config.judge.rememberApprovals],
+		[judge.timeoutMs, config.judge.timeoutMs],
+		[judge.cache, config.judge.cache],
+		[judge.policy, config.judge.policy],
+	];
+}
+
+function describeError(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}

package/src/core/config/store.ts

@@ -0,0 +1,57 @@
+// Where 3.x kept its files. The config is read once by the migration and then retired to a `.bak`.
+// Grants stay here, because they are state and not settings, and a project grant has to live in the
+// project it belongs to.
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { CONFIG_DIR_NAME, getAgentDir } from "@earendil-works/pi-coding-agent";
+
+import { ALWAYS_YES_FILE } from "#core/always-yes.ts";
+import { decodeConfig } from "#core/config/decode.ts";
+import { defaultConfig, type PermissionConfig } from "#core/config/schema.ts";
+import { CONFIG_DIR } from "#identity";
+import { describe, isRecord } from "#util/primitives.ts";
+
+export interface LegacyConfig {
+	config: PermissionConfig;
+	path: string;
+	warnings: string[];
+}
+
+export function configPath(): string {
+	return join(getAgentDir(), "extensions", CONFIG_DIR, "config.json");
+}
+
+export function globalAlwaysYesPath(): string {
+	return join(getAgentDir(), "extensions", CONFIG_DIR, ALWAYS_YES_FILE);
+}
+
+export function projectAlwaysYesPath(cwd: string): string {
+	return join(cwd, CONFIG_DIR_NAME, "extensions", CONFIG_DIR, ALWAYS_YES_FILE);
+}
+
+/** Reads the config.json of 3.x. Only the migration reads it, and only while the file exists. */
+export function readLegacyConfig(): LegacyConfig {
+	const path = configPath();
+	if (!existsSync(path)) return { config: defaultConfig(), path, warnings: [] };
+
+	try {
+		const raw: unknown = JSON.parse(readFileSync(path, "utf8"));
+		if (!isRecord(raw)) {
+			return {
+				config: defaultConfig(),
+				path,
+				warnings: [`${path} must contain a JSON object; using the defaults`],
+			};
+		}
+
+		const warnings: string[] = [];
+		return { config: decodeConfig(raw, warnings), path, warnings };
+	} catch (error) {
+		return {
+			config: defaultConfig(),
+			path,
+			warnings: [`could not parse ${path}: ${describe(error)}; using the defaults`],
+		};
+	}
+}