@hank-warren/pi-plan-mode 0.1.0

package/src/settings-menu.ts

@@ -0,0 +1,384 @@
+import type { ExtensionContext, ToolInfo } from "@earendil-works/pi-coding-agent";
+import { defineMenu, type RunMenuResult, runMenu } from "@narumitw/pi-tui-kit";
+import { PLAN_MODE_COMPLETE_TOOL_NAME } from "./completion-tool.js";
+import { retentionLabel } from "./implementation-retention.js";
+import { planExportDestination } from "./plan-export.js";
+import { PLAN_MODE_QUESTION_TOOL_NAME } from "./question-tool.js";
+import {
+	configuredBashPolicy,
+	configuredImplementationPlanRetention,
+	configuredPlanExportPath,
+	IMPLEMENTATION_PLAN_RETENTIONS,
+	PLAN_MODE_BASH_POLICIES,
+	PLAN_MODE_THINKING_LEVELS,
+	type PlanModeBashPolicy,
+	type PlanModeSettings,
+	type PlanModeSettingsLoadResult,
+	type PlanModeSettingsPatch,
+	planModeSettingsPath,
+	readPlanModeSettings,
+	type UpdatePlanModeSettingsOptions,
+	updatePlanModeSettings,
+} from "./settings.js";
+import { canSelectToolInPlanMode } from "./tool-policy.js";
+import { defaultPlanModeToolNames, toolPolicyLabel } from "./tool-selection.js";
+
+interface SettingsMenuState {
+	kind: "valid" | "invalid";
+	settings: PlanModeSettings;
+	notice?: string;
+	reason?: string;
+}
+
+export interface PlanModeSettingsMenuOptions {
+	tools: readonly ToolInfo[];
+	signal: AbortSignal;
+	isCurrent(): boolean;
+	settingsPath?: string;
+	legacySettingsPath?: string;
+	readSettings?: (settingsPath?: string) => Promise<PlanModeSettingsLoadResult>;
+	updateSettings?: (
+		patch: PlanModeSettingsPatch,
+		options?: UpdatePlanModeSettingsOptions,
+	) => Promise<PlanModeSettings>;
+	onSaved(settings: PlanModeSettings): void;
+}
+
+type Screen = "settings" | "tools" | "export";
+type Action =
+	| "set-thinking"
+	| "open-tools"
+	| "toggle-tool"
+	| "reset-tools"
+	| "set-bash-policy"
+	| "set-retention"
+	| "open-export"
+	| "set-export";
+
+export async function showPlanModeSettings(
+	ctx: ExtensionContext,
+	options: PlanModeSettingsMenuOptions,
+): Promise<RunMenuResult> {
+	const settingsPath = options.settingsPath ?? planModeSettingsPath();
+	const readSettings = options.readSettings ?? readPlanModeSettings;
+	const updateSettings = options.updateSettings ?? updatePlanModeSettings;
+	const tools = options.tools.filter(
+		(tool) =>
+			tool.name !== PLAN_MODE_QUESTION_TOOL_NAME && tool.name !== PLAN_MODE_COMPLETE_TOOL_NAME,
+	);
+
+	const loadState = async (): Promise<SettingsMenuState> => {
+		const loaded = await readSettings(options.settingsPath);
+		if (loaded.kind === "invalid") {
+			return {
+				kind: "invalid",
+				settings: { thinkingLevel: "inherit" },
+				notice: loaded.notice,
+				reason: loaded.reason,
+			};
+		}
+		return {
+			kind: "valid",
+			settings: loaded.kind === "loaded" ? loaded.settings : { thinkingLevel: "inherit" },
+			notice: loaded.notice,
+		};
+	};
+
+	const menu = defineMenu<SettingsMenuState, Screen, Action, ExtensionContext>({
+		start: "settings",
+		screens: {
+			settings: ({ state }) =>
+				state.kind === "invalid"
+					? invalidScreen(settingsPath, state)
+					: {
+							kind: "settings",
+							title: "Plan Mode Settings",
+							lines: settingsLines(settingsPath, state.notice),
+							items: [
+								{
+									id: "thinkingLevel",
+									label: "Plan thinking",
+									description: "Set the thinking level when the next Plan workflow starts.",
+									currentValue: state.settings.thinkingLevel,
+									values: PLAN_MODE_THINKING_LEVELS,
+									action: "set-thinking",
+								},
+								{
+									id: "defaultPlanTools",
+									label: "Plan tools",
+									description:
+										"Choose persistent defaults; a launch-time selection still overrides them for that session.",
+									currentValue: defaultToolsValue(state.settings.defaultPlanTools),
+									action: "open-tools",
+								},
+								{
+									id: "bashPolicy",
+									label: "Bash policy",
+									description:
+										"Use Plan mode's allowlist or selectively defer matching guarded commands to Auto Permissions.",
+									currentValue: bashPolicyLabel(configuredBashPolicy(state.settings)),
+									values: PLAN_MODE_BASH_POLICIES.map(bashPolicyLabel),
+									action: "set-bash-policy",
+								},
+								{
+									id: "implementationPlanRetention",
+									label: "After Implement",
+									description: "Choose how long the accepted plan keeps guiding implementation.",
+									currentValue: retentionLabel(
+										configuredImplementationPlanRetention(state.settings),
+									),
+									values: IMPLEMENTATION_PLAN_RETENTIONS.map(retentionLabel),
+									action: "set-retention",
+								},
+								{
+									id: "defaultPlanExportPath",
+									label: "Export destination",
+									description: "Set the destination used when an export omits its path.",
+									currentValue: safeTerminalText(configuredPlanExportPath(state.settings)),
+									action: "open-export",
+								},
+							],
+						},
+			tools: ({ state }) => ({
+				kind: "multiSelect",
+				title: "Default Plan-mode tools",
+				lines: [
+					"Changes apply when a later Plan workflow starts; required Plan tools stay enabled.",
+					"Non-built-in tools run at user risk.",
+				],
+				enableSearch: true,
+				viewportSize: 10,
+				items: defaultToolItems(tools, state.settings.defaultPlanTools),
+				action: "toggle-tool",
+				actions: [
+					{
+						id: "reset-tools",
+						label: "Use automatic safe built-ins",
+						action: "reset-tools",
+					},
+				],
+				hint: "back",
+			}),
+			export: ({ state }) => {
+				const configured = configuredPlanExportPath(state.settings);
+				const destination = planExportDestination(configured, ctx.cwd);
+				return {
+					kind: "input",
+					title: "Export destination",
+					lines: [
+						`Configured: ${destination.configuredPath}`,
+						`Resolves here to: ${destination.resolvedPath}`,
+						"Submit an empty value to reset to PLAN.md. Changes affect the next export.",
+					],
+					placeholder: configured,
+					action: "set-export",
+					hint: "back",
+				};
+			},
+		},
+		actions: {
+			"set-thinking": async ({ ctx: actionCtx, value, signal }) => {
+				if (
+					!PLAN_MODE_THINKING_LEVELS.includes(value as (typeof PLAN_MODE_THINKING_LEVELS)[number])
+				) {
+					return { kind: "rejected" };
+				}
+				return savePatch(
+					actionCtx,
+					{ thinkingLevel: value as PlanModeSettings["thinkingLevel"] },
+					signal,
+					`Plan mode thinking level: ${value}. Applies to the next Plan workflow.`,
+				);
+			},
+			"open-tools": async () => ({ kind: "to", screen: "tools" }),
+			"set-bash-policy": async ({ ctx: actionCtx, value, signal }) => {
+				const bashPolicy = bashPolicyFromLabel(value);
+				if (!bashPolicy) return { kind: "rejected" };
+				return savePatch(
+					actionCtx,
+					{ bashPolicy },
+					signal,
+					bashPolicy === "auto-permissions"
+						? "Bash policy: selectively delegated to Auto Permissions guarded rules."
+						: "Bash policy: Plan-mode inspection allowlist.",
+				);
+			},
+			"set-retention": async ({ ctx: actionCtx, value, signal }) => {
+				const implementationPlanRetention = retentionFromLabel(value);
+				if (!implementationPlanRetention) return { kind: "rejected" };
+				return savePatch(
+					actionCtx,
+					{ implementationPlanRetention },
+					signal,
+					`After Implement: ${retentionLabel(implementationPlanRetention)}. Applies to the next Implement action.`,
+				);
+			},
+			"open-export": async () => ({ kind: "to", screen: "export" }),
+			"set-export": async ({ ctx: actionCtx, value, signal }) => {
+				const defaultPlanExportPath = value?.trim() || null;
+				const result = await savePatch(
+					actionCtx,
+					{ defaultPlanExportPath },
+					signal,
+					defaultPlanExportPath
+						? `Default Plan export destination: ${safeTerminalText(defaultPlanExportPath)}.`
+						: "Default Plan export destination reset to PLAN.md.",
+				);
+				return result.kind === "stay" ? { kind: "to", screen: "settings" } : result;
+			},
+			"toggle-tool": async ({ ctx: actionCtx, state, itemId, selected, signal }) => {
+				const tool = tools.find((candidate) => candidate.name === itemId);
+				if (!tool || !canSelectToolInPlanMode(tool)) return { kind: "rejected" };
+				const names = explicitToolNames(tools, state.settings.defaultPlanTools);
+				const next = selected
+					? Array.from(new Set([...names, tool.name]))
+					: names.filter((name) => name !== tool.name);
+				return savePatch(
+					actionCtx,
+					{ defaultPlanTools: next },
+					signal,
+					`Default Plan-mode tools: ${next.length === 0 ? "required tools only" : `${next.length} selected`}.`,
+				);
+			},
+			"reset-tools": async ({ ctx: actionCtx, state, signal }) => {
+				if (state.settings.defaultPlanTools === undefined) return { kind: "stay" };
+				return savePatch(
+					actionCtx,
+					{ defaultPlanTools: null },
+					signal,
+					"Default Plan-mode tools: automatic safe built-ins.",
+				);
+			},
+		},
+	});
+
+	return runMenu(ctx, menu, {
+		getState: loadState,
+		signal: options.signal,
+		isCurrent: options.isCurrent,
+	});
+
+	async function savePatch(
+		actionCtx: ExtensionContext,
+		patch: PlanModeSettingsPatch,
+		signal: AbortSignal,
+		successMessage: string,
+	) {
+		if (signal.aborted || !options.isCurrent()) return { kind: "rejected" as const };
+		try {
+			const saved = await updateSettings(patch, {
+				settingsPath: options.settingsPath,
+				legacySettingsPath: options.legacySettingsPath,
+				signal,
+			});
+			if (options.isCurrent()) options.onSaved(saved);
+			if (signal.aborted || !options.isCurrent()) return { kind: "rejected" as const };
+			actionCtx.ui.notify(successMessage, "info");
+			return { kind: "stay" as const };
+		} catch (error) {
+			if (!signal.aborted && options.isCurrent()) {
+				actionCtx.ui.notify(
+					`Could not save Plan mode settings; the previous value remains: ${safeTerminalText(formatError(error))}`,
+					"error",
+				);
+			}
+			return { kind: "rejected" as const };
+		}
+	}
+}
+
+function settingsLines(settingsPath: string, notice: string | undefined) {
+	return [
+		`User settings · ${safeTerminalText(settingsPath)}`,
+		"Plan defaults apply to the next workflow; handoff and export choices apply to their next action.",
+		...(notice ? [safeTerminalText(notice)] : []),
+	];
+}
+
+function invalidScreen(settingsPath: string, state: SettingsMenuState) {
+	return {
+		kind: "detail" as const,
+		title: "Plan Mode Settings · Read only",
+		lines: [
+			`Invalid settings file. Fix ${safeTerminalText(settingsPath)} before saving.`,
+			safeTerminalText(state.reason ?? "The settings file is invalid."),
+			...(state.notice ? [safeTerminalText(state.notice)] : []),
+		],
+		hint: "back" as const,
+	};
+}
+
+const BASH_POLICY_LABELS: Record<PlanModeBashPolicy, string> = {
+	limited: "Plan-mode allowlist",
+	"auto-permissions": "Auto Permissions guarded rules",
+};
+
+function bashPolicyLabel(policy: PlanModeBashPolicy) {
+	return BASH_POLICY_LABELS[policy];
+}
+
+function bashPolicyFromLabel(value: string | undefined) {
+	return PLAN_MODE_BASH_POLICIES.find((policy) => bashPolicyLabel(policy) === value);
+}
+
+function retentionFromLabel(value: string | undefined) {
+	return IMPLEMENTATION_PLAN_RETENTIONS.find((retention) => retentionLabel(retention) === value);
+}
+
+function defaultToolsValue(configured: string[] | undefined) {
+	if (configured === undefined) return "Automatic safe built-ins";
+	if (configured.length === 0) return "Required tools only";
+	return `${configured.length} selected`;
+}
+
+function defaultToolItems(tools: readonly ToolInfo[], configured: string[] | undefined) {
+	const selected = new Set(explicitToolNames(tools, configured));
+	const availableNames = new Set(tools.map((tool) => tool.name));
+	const items = tools.map((tool) => {
+		const selectable = canSelectToolInPlanMode(tool);
+		const policy = toolPolicyLabel(tool);
+		const description = tool.description ?? "No description available";
+		return {
+			id: tool.name,
+			label: tool.name,
+			description: `${policy} · ${description}`,
+			searchText: `${policy} ${description}`,
+			selected: selected.has(tool.name),
+			disabled: !selectable,
+			disabledReason: selectable ? undefined : "Blocked by Plan-mode policy",
+		};
+	});
+	for (const name of configured ?? []) {
+		if (availableNames.has(name)) continue;
+		items.push({
+			id: name,
+			label: name,
+			description: "unavailable · Retained in settings but unavailable in this session",
+			searchText: "unavailable retained settings",
+			selected: true,
+			disabled: true,
+			disabledReason: "Unavailable in this session; reset defaults to remove unavailable names",
+		});
+	}
+	return items;
+}
+
+function explicitToolNames(tools: readonly ToolInfo[], configured: string[] | undefined) {
+	return configured === undefined
+		? defaultPlanModeToolNames([...tools], undefined)
+		: [...configured];
+}
+
+function safeTerminalText(value: string) {
+	return [...value]
+		.map((character) => {
+			const codePoint = character.codePointAt(0) ?? 0;
+			return codePoint <= 0x1f || (codePoint >= 0x7f && codePoint <= 0x9f) ? " " : character;
+		})
+		.join("")
+		.trim();
+}
+
+function formatError(error: unknown) {
+	return error instanceof Error ? error.message : String(error);
+}