@narumitw/pi-codex-compact 0.47.0

package/src/settings-menu.ts

@@ -0,0 +1,232 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { defineMenu, runMenu } from "@narumitw/pi-tui-kit";
+import type {
+	CodexCompactSettings,
+	CodexCompactSettingsRuntime,
+	CodexCompactSettingsState,
+} from "./settings.js";
+
+type Screen = "main" | "settings" | "invalid";
+type Action =
+	| "compact-now"
+	| "set-enabled"
+	| "set-timeout"
+	| "set-retries"
+	| "set-retention"
+	| "set-notify";
+
+export interface SettingsMenuOwner {
+	signal: AbortSignal;
+	isCurrent(): boolean;
+}
+
+interface CompactMenuStatus {
+	model: string;
+	remoteCompatible: boolean;
+}
+
+function safeText(value: string): string {
+	return Array.from(value, (character) => {
+		const codePoint = character.codePointAt(0) ?? 0;
+		return codePoint < 32 || (codePoint >= 127 && codePoint <= 159) ? " " : character;
+	}).join("");
+}
+
+function timeoutLabel(milliseconds: number): string {
+	return `${milliseconds / 60_000} min`;
+}
+
+function retentionLabel(tokens: number): string {
+	return `${tokens / 1000}K tokens`;
+}
+
+async function update(
+	runtime: CodexCompactSettingsRuntime,
+	ctx: ExtensionCommandContext,
+	patch: Partial<CodexCompactSettings>,
+	signal: AbortSignal,
+) {
+	try {
+		await runtime.update(patch, signal);
+		ctx.ui.notify("Codex compaction settings saved.", "info");
+		return { kind: "stay" as const };
+	} catch (error) {
+		if (signal.aborted) return { kind: "rejected" as const };
+		ctx.ui.notify(
+			`Could not save pi-codex-compact.json: ${safeText(error instanceof Error ? error.message : String(error))}`,
+			"error",
+		);
+		return { kind: "rejected" as const };
+	}
+}
+
+export function createCodexCompactMenu(
+	runtime: CodexCompactSettingsRuntime,
+	options: { onCompactRequested?: () => void; status?: CompactMenuStatus } = {},
+) {
+	return defineMenu<CodexCompactSettingsState, Screen, Action, ExtensionCommandContext>({
+		start: "main",
+		screens: {
+			main: ({ state }) => ({
+				kind: "actions",
+				title: "Codex Remote Compaction",
+				lines: [
+					`Remote V2: ${state.settings.enabled ? "On" : "Off"}`,
+					`Active model: ${safeText(options.status?.model ?? "none")}`,
+					`Compact route: ${safeText(compactRoute(state, options.status))}`,
+				],
+				items: [
+					{
+						id: "compact-now",
+						label: "Compact now",
+						description: "Close this menu and compact the active session immediately.",
+						action: "compact-now",
+					},
+					state.kind === "invalid"
+						? {
+								id: "settings",
+								label: "Settings",
+								description: "Read-only until the invalid settings file is repaired.",
+								to: "invalid" as const,
+							}
+						: { id: "settings", label: "Settings", to: "settings" as const },
+					{ id: "close", label: "Close", close: true },
+				],
+				hint: "close",
+			}),
+			settings: ({ state }) => ({
+				kind: "settings",
+				title: "Codex Remote Compaction Settings",
+				lines: [`User settings · ${safeText(state.path)}`],
+				items: [
+					{
+						id: "enabled",
+						label: "Remote compaction",
+						description: "Use Codex Remote V2 when the active model is compatible.",
+						currentValue: state.settings.enabled ? "On" : "Off",
+						values: ["On", "Off"],
+						action: "set-enabled",
+					},
+					{
+						id: "requestTimeoutMs",
+						label: "Request timeout",
+						description: "Maximum time for the extension-owned remote compaction request.",
+						currentValue: timeoutLabel(state.settings.requestTimeoutMs),
+						values: ["2 min", "5 min", "10 min"],
+						action: "set-timeout",
+					},
+					{
+						id: "maxRetries",
+						label: "Transport retries",
+						description: "Retry transient provider failures before falling back to Pi.",
+						currentValue: String(state.settings.maxRetries),
+						values: ["0", "1", "2"],
+						action: "set-retries",
+					},
+					{
+						id: "replacementTokenBudget",
+						label: "Retained user history",
+						description: "Approximate user-message budget kept beside the opaque checkpoint.",
+						currentValue: retentionLabel(state.settings.replacementTokenBudget),
+						values: ["32K tokens", "64K tokens", "96K tokens", "128K tokens"],
+						action: "set-retention",
+					},
+					{
+						id: "notifyOnFallback",
+						label: "Fallback notifications",
+						description: "Warn when Remote V2 fails and native Pi compaction takes over.",
+						currentValue: state.settings.notifyOnFallback ? "On" : "Off",
+						values: ["On", "Off"],
+						action: "set-notify",
+					},
+				],
+			}),
+			invalid: ({ state }) => ({
+				kind: "detail",
+				title: "Codex Compact Settings · Read only",
+				lines: [
+					`Invalid settings file: ${safeText(state.path)}`,
+					`Issue: ${safeText(state.issue ?? "unknown validation error")}`,
+					"Built-in defaults are active. Repair the file and run /reload; it will not be overwritten.",
+				],
+				hint: "back",
+			}),
+		},
+		actions: {
+			"compact-now": async () => {
+				options.onCompactRequested?.();
+				return { kind: "close" };
+			},
+			"set-enabled": ({ ctx, value, signal }) =>
+				update(runtime, ctx, { enabled: value === "On" }, signal),
+			"set-timeout": ({ ctx, value, signal }) =>
+				update(
+					runtime,
+					ctx,
+					{ requestTimeoutMs: Number.parseInt(value ?? "5", 10) * 60_000 },
+					signal,
+				),
+			"set-retries": ({ ctx, value, signal }) =>
+				update(runtime, ctx, { maxRetries: Number.parseInt(value ?? "2", 10) }, signal),
+			"set-retention": ({ ctx, value, signal }) =>
+				update(
+					runtime,
+					ctx,
+					{ replacementTokenBudget: Number.parseInt(value ?? "64", 10) * 1000 },
+					signal,
+				),
+			"set-notify": ({ ctx, value, signal }) =>
+				update(runtime, ctx, { notifyOnFallback: value === "On" }, signal),
+		},
+	});
+}
+
+export async function showCodexCompactMenu(
+	runtime: CodexCompactSettingsRuntime,
+	ctx: ExtensionCommandContext,
+	owner: SettingsMenuOwner,
+): Promise<void> {
+	if (ctx.mode !== "tui") {
+		ctx.ui.notify(`Edit Codex compaction settings at ${safeText(runtime.get().path)}.`, "info");
+		return;
+	}
+	let compactRequested = false;
+	await runMenu(
+		ctx,
+		createCodexCompactMenu(runtime, {
+			onCompactRequested: () => {
+				compactRequested = true;
+			},
+			status: compactMenuStatus(ctx),
+		}),
+		{
+			getState: () => runtime.get(),
+			signal: owner.signal,
+			isCurrent: owner.isCurrent,
+		},
+	);
+	if (!compactRequested || owner.signal.aborted || !owner.isCurrent()) return;
+	ctx.compact({
+		onError: (error) => {
+			if (!owner.signal.aborted && owner.isCurrent()) {
+				ctx.ui.notify(`Compaction failed: ${safeText(error.message)}`, "error");
+			}
+		},
+	});
+}
+
+function compactMenuStatus(ctx: ExtensionCommandContext): CompactMenuStatus {
+	const model = ctx.model;
+	return {
+		model: model ? `${model.provider}/${model.id}` : "none",
+		remoteCompatible: model?.provider === "openai-codex" && model.api === "openai-codex-responses",
+	};
+}
+
+function compactRoute(
+	state: Readonly<CodexCompactSettingsState>,
+	status: CompactMenuStatus | undefined,
+): string {
+	if (!state.settings.enabled) return "Pi native (Remote V2 off)";
+	return status?.remoteCompatible ? "Codex Remote V2" : "Pi native (model not compatible)";
+}

package/src/settings.ts

@@ -0,0 +1,227 @@
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { mkdir, open, rename, rm, writeFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+
+export const CODEX_COMPACT_SETTINGS_FILE = "pi-codex-compact.json";
+export const MAX_SETTINGS_BYTES = 64 * 1024;
+
+export interface CodexCompactSettings {
+	enabled: boolean;
+	requestTimeoutMs: number;
+	maxRetries: number;
+	replacementTokenBudget: number;
+	notifyOnFallback: boolean;
+}
+
+export const DEFAULT_CODEX_COMPACT_SETTINGS: Readonly<CodexCompactSettings> = Object.freeze({
+	enabled: true,
+	requestTimeoutMs: 300_000,
+	maxRetries: 2,
+	replacementTokenBudget: 64_000,
+	notifyOnFallback: true,
+});
+
+const LIMITS = Object.freeze({
+	requestTimeoutMs: { minimum: 30_000, maximum: 600_000 },
+	maxRetries: { minimum: 0, maximum: 2 },
+	replacementTokenBudget: { minimum: 8_000, maximum: 128_000 },
+});
+
+export interface CodexCompactSettingsState {
+	kind: "missing" | "loaded" | "invalid";
+	path: string;
+	settings: CodexCompactSettings;
+	document?: Record<string, unknown>;
+	issue?: string;
+}
+
+export interface CodexCompactSettingsRuntime {
+	get(): Readonly<CodexCompactSettingsState>;
+	reload(signal?: AbortSignal): Promise<Readonly<CodexCompactSettingsState>>;
+	update(
+		patch: Partial<CodexCompactSettings>,
+		signal?: AbortSignal,
+	): Promise<Readonly<CodexCompactSettingsState>>;
+	flush(): Promise<void>;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function validInteger(value: unknown, minimum: number, maximum: number): value is number {
+	return (
+		typeof value === "number" && Number.isSafeInteger(value) && value >= minimum && value <= maximum
+	);
+}
+
+export function normalizeCodexCompactSettings(value: unknown): CodexCompactSettings | undefined {
+	if (!isRecord(value)) return undefined;
+	if (Object.hasOwn(value, "enabled") && typeof value.enabled !== "boolean") return undefined;
+	if (Object.hasOwn(value, "notifyOnFallback") && typeof value.notifyOnFallback !== "boolean") {
+		return undefined;
+	}
+	for (const [field, limits] of Object.entries(LIMITS) as Array<
+		[keyof typeof LIMITS, { minimum: number; maximum: number }]
+	>) {
+		if (
+			Object.hasOwn(value, field) &&
+			!validInteger(value[field], limits.minimum, limits.maximum)
+		) {
+			return undefined;
+		}
+	}
+	return {
+		enabled:
+			typeof value.enabled === "boolean" ? value.enabled : DEFAULT_CODEX_COMPACT_SETTINGS.enabled,
+		requestTimeoutMs:
+			typeof value.requestTimeoutMs === "number"
+				? value.requestTimeoutMs
+				: DEFAULT_CODEX_COMPACT_SETTINGS.requestTimeoutMs,
+		maxRetries:
+			typeof value.maxRetries === "number"
+				? value.maxRetries
+				: DEFAULT_CODEX_COMPACT_SETTINGS.maxRetries,
+		replacementTokenBudget:
+			typeof value.replacementTokenBudget === "number"
+				? value.replacementTokenBudget
+				: DEFAULT_CODEX_COMPACT_SETTINGS.replacementTokenBudget,
+		notifyOnFallback:
+			typeof value.notifyOnFallback === "boolean"
+				? value.notifyOnFallback
+				: DEFAULT_CODEX_COMPACT_SETTINGS.notifyOnFallback,
+	};
+}
+
+export function codexCompactSettingsPath(): string {
+	return join(getAgentDir(), CODEX_COMPACT_SETTINGS_FILE);
+}
+
+function aborted(signal?: AbortSignal): void {
+	if (signal?.aborted) throw new DOMException("Settings operation aborted", "AbortError");
+}
+
+export async function loadCodexCompactSettings(
+	path = codexCompactSettingsPath(),
+	signal?: AbortSignal,
+): Promise<CodexCompactSettingsState> {
+	aborted(signal);
+	try {
+		const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+		let text: string;
+		try {
+			const stats = await handle.stat();
+			aborted(signal);
+			if (!stats.isFile()) throw new Error("settings path is not a regular file");
+			if (stats.size > MAX_SETTINGS_BYTES) throw new Error("settings file exceeds 64 KiB");
+			text = await handle.readFile("utf8");
+		} finally {
+			await handle.close();
+		}
+		aborted(signal);
+		const document = JSON.parse(text) as unknown;
+		const settings = normalizeCodexCompactSettings(document);
+		if (!settings || !isRecord(document)) throw new Error("invalid settings shape or bounds");
+		return { kind: "loaded", path, settings, document };
+	} catch (error) {
+		if (signal?.aborted) throw error;
+		if (isNodeError(error) && error.code === "ENOENT") {
+			return {
+				kind: "missing",
+				path,
+				settings: { ...DEFAULT_CODEX_COMPACT_SETTINGS },
+				document: {},
+			};
+		}
+		return {
+			kind: "invalid",
+			path,
+			settings: { ...DEFAULT_CODEX_COMPACT_SETTINGS },
+			issue:
+				isNodeError(error) && error.code === "ELOOP"
+					? "symbolic links are not accepted"
+					: error instanceof Error
+						? error.message
+						: String(error),
+		};
+	}
+}
+
+async function savePatch(
+	path: string,
+	patch: Partial<CodexCompactSettings>,
+	signal?: AbortSignal,
+): Promise<CodexCompactSettingsState> {
+	const latest = await loadCodexCompactSettings(path, signal);
+	if (latest.kind === "invalid") {
+		throw new Error(
+			"Cannot overwrite an invalid pi-codex-compact.json; repair it and reload first",
+		);
+	}
+	const document = { ...latest.document, ...patch };
+	const settings = normalizeCodexCompactSettings(document);
+	if (!settings) throw new Error("Refusing to save invalid Codex compaction settings");
+	const temporaryPath = join(dirname(path), `.${basename(path)}.${randomUUID()}.tmp`);
+	await mkdir(dirname(path), { recursive: true });
+	aborted(signal);
+	try {
+		await writeFile(temporaryPath, `${JSON.stringify(document, null, 2)}\n`, {
+			encoding: "utf8",
+			flag: "wx",
+			mode: 0o600,
+		});
+		aborted(signal);
+		const current = await loadCodexCompactSettings(path, signal);
+		if (
+			current.kind === "invalid" ||
+			current.kind !== latest.kind ||
+			JSON.stringify(current.document) !== JSON.stringify(latest.document)
+		) {
+			throw new Error("pi-codex-compact.json changed while saving; reopen settings and retry");
+		}
+		await rename(temporaryPath, path);
+	} finally {
+		await rm(temporaryPath, { force: true }).catch(() => undefined);
+	}
+	return { kind: "loaded", path, settings, document };
+}
+
+export function createCodexCompactSettingsRuntime(
+	path = codexCompactSettingsPath(),
+): CodexCompactSettingsRuntime {
+	let state: CodexCompactSettingsState = {
+		kind: "missing",
+		path,
+		settings: { ...DEFAULT_CODEX_COMPACT_SETTINGS },
+		document: {},
+	};
+	let queue = Promise.resolve();
+	const enqueue = <T>(operation: () => Promise<T>): Promise<T> => {
+		const result = queue.then(operation, operation);
+		queue = result.then(
+			() => undefined,
+			() => undefined,
+		);
+		return result;
+	};
+	return {
+		get: () => structuredClone(state),
+		reload: (signal) =>
+			enqueue(async () => {
+				state = await loadCodexCompactSettings(path, signal);
+				return structuredClone(state);
+			}),
+		update: (patch, signal) =>
+			enqueue(async () => {
+				state = await savePatch(path, patch, signal);
+				return structuredClone(state);
+			}),
+		flush: () => queue,
+	};
+}
+
+function isNodeError(error: unknown): error is NodeJS.ErrnoException {
+	return error instanceof Error && "code" in error;
+}