@hank-warren/pi-plan-mode 1.5.0 → 1.7.0

package/src/settings-menu.ts

@@ -1,4 +1,3 @@
-import { readFile } from "node:fs/promises";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { defineMenu, type RunMenuResult, runMenu } from "@narumitw/pi-tui-kit";
 import { planExportDestination } from "./plan-export.js";
@@ -16,17 +15,13 @@ import {
 interface SettingsMenuState {
 	kind: "valid" | "invalid";
 	settings: PlanModeSettings;
-	notice?: string;
 	reason?: string;
-	/** The removed `thinkingLevel` key is still in the file. legacy: delete in 1.4.0 */
-	hasLegacyThinkingLevel?: boolean;
 }
 
-export interface PlanModeSettingsMenuOptions {
+interface PlanModeSettingsMenuOptions {
 	signal: AbortSignal;
 	isCurrent(): boolean;
 	settingsPath?: string;
-	legacySettingsPath?: string;
 	readSettings?: (settingsPath?: string) => Promise<PlanModeSettingsLoadResult>;
 	updateSettings?: (
 		patch: PlanModeSettingsPatch,
@@ -49,19 +44,9 @@ export async function showPlanModeSettings(
 	const loadState = async (): Promise<SettingsMenuState> => {
 		const loaded = await readSettings(options.settingsPath);
 		if (loaded.kind === "invalid") {
-			return {
-				kind: "invalid",
-				settings: {},
-				notice: loaded.notice,
-				reason: loaded.reason,
-			};
+			return { kind: "invalid", settings: {}, reason: loaded.reason };
 		}
-		return {
-			kind: "valid",
-			settings: loaded.kind === "loaded" ? loaded.settings : {},
-			notice: loaded.notice,
-			hasLegacyThinkingLevel: await hasLegacyThinkingLevel(settingsPath),
-		};
+		return { kind: "valid", settings: loaded.kind === "loaded" ? loaded.settings : {} };
 	};
 
 	const menu = defineMenu<SettingsMenuState, Screen, Action, ExtensionContext>({
@@ -73,7 +58,7 @@ export async function showPlanModeSettings(
 					: {
 							kind: "settings",
 							title: "Plan Mode Settings",
-							lines: settingsLines(settingsPath, state),
+							lines: settingsLines(settingsPath),
 							items: [
 								{
 									id: "defaultPlanExportPath",
@@ -132,11 +117,7 @@ export async function showPlanModeSettings(
 	) {
 		if (signal.aborted || !options.isCurrent()) return { kind: "rejected" as const };
 		try {
-			const saved = await updateSettings(patch, {
-				settingsPath: options.settingsPath,
-				legacySettingsPath: options.legacySettingsPath,
-				signal,
-			});
+			const saved = await updateSettings(patch, { settingsPath: options.settingsPath, signal });
 			if (options.isCurrent()) options.onSaved(saved);
 			if (signal.aborted || !options.isCurrent()) return { kind: "rejected" as const };
 			actionCtx.ui.notify(successMessage, "info");
@@ -153,35 +134,13 @@ export async function showPlanModeSettings(
 	}
 }
 
-function settingsLines(settingsPath: string, state: SettingsMenuState) {
+function settingsLines(settingsPath: string) {
 	return [
 		`User settings · ${safeTerminalText(settingsPath)}`,
 		"The export destination applies to its next action.",
-		// legacy: delete in 1.4.0
-		...(state.hasLegacyThinkingLevel
-			? [
-					"thinkingLevel is no longer used — thinking is a session setting and Plan mode never changes it.",
-				]
-			: []),
-		...(state.notice ? [safeTerminalText(state.notice)] : []),
 	];
 }
 
-/**
- * The removed key is preserved verbatim on save, so the only way to know it is
- * still there is to look at the file. A read failure simply hides the notice.
- *
- * legacy: delete in 1.4.0
- */
-async function hasLegacyThinkingLevel(settingsPath: string) {
-	try {
-		const parsed: unknown = JSON.parse(await readFile(settingsPath, "utf8"));
-		return typeof parsed === "object" && parsed !== null && Object.hasOwn(parsed, "thinkingLevel");
-	} catch {
-		return false;
-	}
-}
-
 function invalidScreen(settingsPath: string, state: SettingsMenuState) {
 	return {
 		kind: "detail" as const,
@@ -189,7 +148,6 @@ function invalidScreen(settingsPath: string, state: SettingsMenuState) {
 		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,
 	};

package/src/settings-watch.ts

@@ -0,0 +1,60 @@
+import { watch } from "node:fs";
+import { basename, dirname } from "node:path";
+
+interface SettingsWatcherOptions {
+	/** The settings file to follow; its directory is what actually gets watched. */
+	path: string;
+	debounceMs: number;
+	onChange(): void;
+}
+
+/**
+ * Follows one settings file for out-of-band edits.
+ *
+ * The watch is on the file's *directory* rather than the file itself: saves go
+ * through a temp file and an atomic rename, and a watch bound to the old inode
+ * would go deaf after the first one. One hand-edit or menu save also fans out
+ * into several filesystem events (temp file created, renamed into place), so
+ * `debounceMs` collapses them into a single `onChange`.
+ */
+export function createSettingsWatcher(options: SettingsWatcherOptions) {
+	const watchedFile = basename(options.path);
+	let watcher: ReturnType<typeof watch> | undefined;
+	let reloadTimer: ReturnType<typeof setTimeout> | undefined;
+
+	const stop = () => {
+		if (reloadTimer) {
+			clearTimeout(reloadTimer);
+			reloadTimer = undefined;
+		}
+		watcher?.close();
+		watcher = undefined;
+	};
+
+	return {
+		start() {
+			stop();
+			try {
+				const started = watch(dirname(options.path), { persistent: false }, (event, changed) => {
+					if (event !== "rename" && event !== "change") return;
+					// A null filename means the platform could not name the entry; reload
+					// rather than miss the edit. The directory holds other churn, so a
+					// named entry that is not ours is ignored.
+					if (changed && changed.toString() !== watchedFile) return;
+					if (reloadTimer) clearTimeout(reloadTimer);
+					reloadTimer = setTimeout(() => {
+						reloadTimer = undefined;
+						options.onChange();
+					}, options.debounceMs);
+				});
+				started.on("error", stop);
+				watcher = started;
+			} catch {
+				// An unwatchable directory only costs the live reload; settings still
+				// load at session start.
+				stop();
+			}
+		},
+		stop,
+	};
+}

package/src/settings.ts

@@ -5,7 +5,6 @@ import { basename, dirname, join } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 
 export const PLAN_MODE_SETTINGS_FILE = "pi-plan-mode.json";
-const LEGACY_PLAN_MODE_SETTINGS_FILE = "plan-mode.json";
 const MAX_SETTINGS_BYTES = 64 * 1024;
 export const DEFAULT_PLAN_EXPORT_PATH = "PLAN.md";
 const MAX_PLAN_EXPORT_PATH_LENGTH = 4096;
@@ -18,14 +17,13 @@ export interface PlanModeSettingsPatch {
 }
 export interface UpdatePlanModeSettingsOptions {
 	settingsPath?: string;
-	legacySettingsPath?: string;
 	signal?: AbortSignal;
 	beforeRename?: (temporaryPath: string, settingsPath: string) => Promise<void>;
 }
 export type PlanModeSettingsLoadResult =
-	| { kind: "missing"; notice?: string }
-	| { kind: "invalid"; reason: string; notice?: string }
-	| { kind: "loaded"; settings: PlanModeSettings; notice?: string };
+	| { kind: "missing" }
+	| { kind: "invalid"; reason: string }
+	| { kind: "loaded"; settings: PlanModeSettings };
 
 type SettingsDocument = Record<string, unknown>;
 type SettingsSnapshot = {
@@ -39,10 +37,6 @@ export function planModeSettingsPath() {
 	return join(getAgentDir(), PLAN_MODE_SETTINGS_FILE);
 }
 
-function legacyPlanModeSettingsPath() {
-	return join(getAgentDir(), LEGACY_PLAN_MODE_SETTINGS_FILE);
-}
-
 /**
  * Unknown top-level keys are tolerated and preserved on save. Settings removed
  * over time (defaultPlanTools, bashPolicy, safeSubcommands,
@@ -80,34 +74,10 @@ function normalizePlanExportPath(value: unknown) {
 }
 
 export async function readPlanModeSettings(
-	settingsPath?: string,
+	settingsPath = planModeSettingsPath(),
 ): Promise<PlanModeSettingsLoadResult> {
-	if (settingsPath) {
-		await awaitPlanModeSettingsWrites(settingsPath);
-		return (await readSettingsSnapshot(settingsPath)).result;
-	}
-	const canonicalPath = planModeSettingsPath();
-	await awaitPlanModeSettingsWrites(canonicalPath);
-	const canonical = await readSettingsSnapshot(canonicalPath);
-	const legacyPath = legacyPlanModeSettingsPath();
-	if (canonical.result.kind !== "missing") {
-		return (await pathExists(legacyPath))
-			? {
-					...canonical.result,
-					notice: `${LEGACY_PLAN_MODE_SETTINGS_FILE} ignored because ${PLAN_MODE_SETTINGS_FILE} takes precedence.`,
-				}
-			: canonical.result;
-	}
-
-	const legacy = await readSettingsSnapshot(legacyPath);
-	const raced = await readSettingsSnapshot(canonicalPath);
-	if (raced.result.kind !== "missing") return raced.result;
-	return legacy.result.kind === "loaded"
-		? {
-				...legacy.result,
-				notice: `Using legacy ${LEGACY_PLAN_MODE_SETTINGS_FILE}; rename it to ${PLAN_MODE_SETTINGS_FILE}. The legacy file was not modified.`,
-			}
-		: legacy.result;
+	await awaitPlanModeSettingsWrites(settingsPath);
+	return (await readSettingsSnapshot(settingsPath)).result;
 }
 
 export function updatePlanModeSettings(
@@ -115,11 +85,9 @@ export function updatePlanModeSettings(
 	options: UpdatePlanModeSettingsOptions = {},
 ): Promise<PlanModeSettings> {
 	const settingsPath = options.settingsPath ?? planModeSettingsPath();
-	const legacySettingsPath =
-		options.legacySettingsPath ?? (options.settingsPath ? undefined : legacyPlanModeSettingsPath());
 	return enqueueMutation(settingsPath, async () => {
 		options.signal?.throwIfAborted();
-		const current = await readSettingsDocumentForUpdate(settingsPath, legacySettingsPath);
+		const current = await readSettingsDocumentForUpdate(settingsPath);
 		const updated: SettingsDocument = { ...current };
 		if (patch.defaultPlanExportPath === null) delete updated.defaultPlanExportPath;
 		else if (patch.defaultPlanExportPath !== undefined) {
@@ -152,27 +120,12 @@ function enqueueMutation<T>(settingsPath: string, mutation: () => Promise<T>): P
 	return result;
 }
 
-async function readSettingsDocumentForUpdate(
-	settingsPath: string,
-	legacySettingsPath: string | undefined,
-): Promise<SettingsDocument> {
-	const canonical = await readSettingsSnapshot(settingsPath);
-	if (canonical.result.kind === "loaded") return canonical.document ?? {};
-	if (canonical.result.kind === "invalid") {
-		throw invalidSettingsError(settingsPath, canonical.result.reason);
-	}
-	if (!legacySettingsPath) return {};
-
-	const legacy = await readSettingsSnapshot(legacySettingsPath);
-	const raced = await readSettingsSnapshot(settingsPath);
-	if (raced.result.kind === "loaded") return raced.document ?? {};
-	if (raced.result.kind === "invalid") {
-		throw invalidSettingsError(settingsPath, raced.result.reason);
-	}
-	if (legacy.result.kind === "invalid") {
-		throw invalidSettingsError(legacySettingsPath, legacy.result.reason);
+async function readSettingsDocumentForUpdate(settingsPath: string): Promise<SettingsDocument> {
+	const snapshot = await readSettingsSnapshot(settingsPath);
+	if (snapshot.result.kind === "invalid") {
+		throw invalidSettingsError(settingsPath, snapshot.result.reason);
 	}
-	return legacy.document ?? {};
+	return snapshot.result.kind === "loaded" ? (snapshot.document ?? {}) : {};
 }
 
 async function readSettingsSnapshot(settingsPath: string): Promise<SettingsSnapshot> {
@@ -264,16 +217,6 @@ function isSettingsDocument(value: unknown): value is SettingsDocument {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-async function pathExists(path: string) {
-	try {
-		const handle = await open(path, constants.O_RDONLY | (constants.O_NONBLOCK ?? 0));
-		await handle.close();
-		return true;
-	} catch (error: unknown) {
-		return !(isNodeError(error) && error.code === "ENOENT");
-	}
-}
-
 function invalidSettingsError(settingsPath: string, reason: string) {
 	return new Error(`pi-plan-mode settings at ${settingsPath} are invalid: ${reason}`);
 }

package/src/state.ts

@@ -39,42 +39,6 @@ function newestStateEntry(entries: unknown[], stateEntryType: string): SessionEn
 	return undefined;
 }
 
-// legacy: delete in 1.4.0
-const LEGACY_THINKING_LEVELS = [
-	"off",
-	"minimal",
-	"low",
-	"medium",
-	"high",
-	"xhigh",
-	"max",
-] as const;
-
-// legacy: delete in 1.4.0
-export type LegacyThinkingCapture = {
-	previous: (typeof LEGACY_THINKING_LEVELS)[number];
-	applied: (typeof LEGACY_THINKING_LEVELS)[number];
-};
-
-/**
- * Reads the thinking-level capture written by pi-plan-mode <= 1.2.1, so a
- * session interrupted while Plan mode held a raised level can have the user's
- * level put back once. Both halves must be present and valid: a partial or
- * absent capture is nothing to repair.
- *
- * legacy: delete in 1.4.0
- */
-export function readLegacyThinkingCapture(
-	entries: unknown[],
-	stateEntryType: string,
-): LegacyThinkingCapture | undefined {
-	const entry = newestStateEntry(entries, stateEntryType);
-	if (!isRecord(entry?.data)) return undefined;
-	const previous = legacyThinkingLevel(entry.data.previousThinkingLevel);
-	const applied = legacyThinkingLevel(entry.data.appliedThinkingLevel);
-	return previous && applied ? { previous, applied } : undefined;
-}
-
 /**
  * Persisted paths are only trusted when they are absolute and free of NUL, so
  * malformed state can never redirect a read or a delete to a relative target.
@@ -86,14 +50,6 @@ function absolutePath(value: unknown) {
 	return normalized;
 }
 
-// legacy: delete in 1.4.0
-function legacyThinkingLevel(value: unknown): (typeof LEGACY_THINKING_LEVELS)[number] | undefined {
-	return typeof value === "string" &&
-		LEGACY_THINKING_LEVELS.includes(value as (typeof LEGACY_THINKING_LEVELS)[number])
-		? (value as (typeof LEGACY_THINKING_LEVELS)[number])
-		: undefined;
-}
-
 function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }