@vanillagreen/pi-qol 2.2.1 → 2.3.4

package/extensions/qol.ts

@@ -1,4 +1,6 @@
 import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { join } from "node:path";
+import { pruneLanes } from "../scripts/lane-retention.js";
 import { truncateToWidth, type TUI } from "@earendil-works/pi-tui";
 import { criticalInfo, lastAssistantTextFromAgentEnd, needsDirection, taskStats } from "./qol/agent-end.js";
 import { getQuestionService, readCavemanBridge, type QuestionOpenedEventLike } from "./qol/bridges.js";
@@ -16,6 +18,7 @@ import {
 	DEFAULT_IDLE_COMPACTION_SECONDS,
 	DEFAULT_INPUT_BOTTOM_PADDING_LINES,
 	INSTALL_SYMBOL,
+	QOL_BUDGET_HANDOFF_FOLDER,
 	QOL_NOTIFICATION_SERVICE_SYMBOL,
 	QUESTION_OPENED_EVENT,
 	SESSION_MANAGER_STATUS_KEY,
@@ -23,6 +26,7 @@ import {
 	SESSION_SEARCH_STATUS_KEY,
 	SESSION_TITLE_SYNC_INTERVAL_MS,
 	STATUS_KEY,
+	THINKING_TIMER_MAX_DURATIONS,
 	THINKING_TIMER_STORE_SYMBOL,
 	TMUX_SESSION_TITLE_BORDER_FORMAT,
 } from "./qol/constants.js";
@@ -35,10 +39,11 @@ import {
 	QolEditor,
 } from "./qol/editor.js";
 import { runHandoff } from "./qol/handoff.js";
-import { imageContentForPath, resolveSubmittedImagePaths } from "./qol/images.js";
+import { imageContentsForPaths, resolveSubmittedImagePaths } from "./qol/images.js";
 import {
 	clearTmuxWindowMark,
 	notifyQuestionOpened,
+	resetQolNotificationCooldowns,
 	sendQolNotification,
 	type QolNotificationService,
 } from "./qol/notifications.js";
@@ -61,15 +66,18 @@ import {
 } from "./qol/session-rename.js";
 import { createScheduleController, getScheduleArgumentCompletions } from "./qol/schedule.js";
 import {
+	clearSessionSearchPendingAction,
 	consumePendingSessionSearchContext,
 	openQolSessionSearch,
-	qolSessionSearchPendingActions,
 	refreshQolSessionSearchCache,
+	releaseQolSessionSearchCache,
 	renderSessionSearchContextMessage,
 	runSessionSearchResumeOrFork,
 	sessionSearchShortcut,
+	takeSessionSearchPendingAction,
 } from "./qol/session-search/index.js";
-import { recordProjectTrust, settingBoolean, settingNumber, settingString } from "./qol/settings.js";
+import { installSettingsCacheRefresh, piUserDir, recordProjectTrust } from "./qol/package-config.js";
+import { settingBoolean, settingNumber, settingString } from "./qol/settings.js";
 import { statusMessage } from "./qol/status-message.js";
 import {
 	formatTmuxSessionTitle,
@@ -248,11 +256,24 @@ export default function qol(pi: ExtensionAPI): void {
 		const duration = Math.max(0, endTimeMs - start);
 		thinkingTimerStore.starts.delete(key);
 		thinkingTimerStore.durations.set(key, duration);
+		for (const oldest of thinkingTimerStore.durations.keys()) {
+			if (thinkingTimerStore.durations.size <= THINKING_TIMER_MAX_DURATIONS) break;
+			thinkingTimerStore.durations.delete(oldest);
+		}
 		const label = thinkingTimerStore.labels.get(key);
 		if (label) label.setText(thinkingTimerLabel(thinkingTimerStore.theme, duration, thinkingTimerStore.cwd));
 		if (thinkingTimerStore.starts.size === 0) stopThinkingTimerTicker();
 	};
 
+	// A label is held only to tick it while its block runs. A finished block's
+	// label already shows its final time, and a redraw of that message labels
+	// it again from `durations`.
+	const releaseFinishedThinkingLabels = () => {
+		for (const key of thinkingTimerStore.labels.keys()) {
+			if (!thinkingTimerStore.starts.has(key)) thinkingTimerStore.labels.delete(key);
+		}
+	};
+
 	const clearIdleCompactionTimer = () => {
 		if (idleCompactionTimer) clearTimeout(idleCompactionTimer);
 		idleCompactionTimer = undefined;
@@ -586,8 +607,13 @@ export default function qol(pi: ExtensionAPI): void {
 		rateLimitAutoResumeController.noteExternalRateLimitEvent(payload, currentCtx);
 	});
 
+	installSettingsCacheRefresh(pi);
 	pi.on("session_start", (event, ctx) => {
 		recordProjectTrust(ctx);
+		const pruned = pruneLanes(join(piUserDir(), "kendex", "sessions"), QOL_BUDGET_HANDOFF_FOLDER.split("/"));
+		for (const failure of pruned.failed) {
+			console.warn(`handoff-prune-error: ${failure.path}\n${failure.error}`);
+		}
 		currentCtx = ctx;
 		subscribeCavemanBridge();
 		latestSystemPromptOptions = undefined;
@@ -648,7 +674,8 @@ export default function qol(pi: ExtensionAPI): void {
 		}
 		startQuestionSubscription(ctx);
 		void attemptAutoRename(ctx);
-		if (settingBoolean("sessionSearch.enabled", true, ctx.cwd)) {
+		// A headless session has no search overlay to open, so it loads no index.
+		if (ctx.hasUI && settingBoolean("sessionSearch.enabled", true, ctx.cwd)) {
 			if (sessionSearchWarmupTimer) clearTimeout(sessionSearchWarmupTimer);
 			sessionSearchWarmupTimer = setTimeout(() => {
 				sessionSearchWarmupTimer = undefined;
@@ -673,8 +700,11 @@ export default function qol(pi: ExtensionAPI): void {
 		clearQuestionSubscribeTimer();
 		if (sessionSearchWarmupTimer) clearTimeout(sessionSearchWarmupTimer);
 		sessionSearchWarmupTimer = undefined;
+		releaseQolSessionSearchCache();
+		clearSessionSearchPendingAction();
 		resetThinkingTimer(undefined);
 		clearTmuxWindowMark(pi);
+		resetQolNotificationCooldowns();
 		questionUnsubscribe?.();
 		questionUnsubscribe = undefined;
 		currentCtx = undefined;
@@ -744,6 +774,7 @@ export default function qol(pi: ExtensionAPI): void {
 		}
 	});
 	pi.on("agent_end", (event, ctx) => {
+		releaseFinishedThinkingLabels();
 		if (ctx.hasUI) {
 			void refreshStatusline(ctx);
 			requestRender();
@@ -816,15 +847,24 @@ export default function qol(pi: ExtensionAPI): void {
 		if (event?.toolName === "tasks_write") maybeNotifyTaskCompletion(ctx, event.details?.state);
 	});
 
-	pi.on("input", async (event) => {
+	pi.on("input", async (event, ctx) => {
 		clearTmuxWindowMark(pi);
 		if (event.source === "extension") return { action: "continue" };
 		const text = event.text ?? "";
-		const paths = currentCtx?.cwd ? resolveSubmittedImagePaths(text, currentCtx.cwd) : [];
+		const paths = resolveSubmittedImagePaths(text, ctx.cwd);
 		if (paths.length === 0) return { action: "continue" };
-		const images = paths.map(imageContentForPath).filter(Boolean);
-		if (images.length === 0) return { action: "continue" };
-		return { action: "transform", images: [...(event.images ?? []), ...images], text: event.text };
+		try {
+			const images = await imageContentsForPaths(paths, event.images ?? []);
+			return { action: "transform", images: [...(event.images ?? []), ...images], text: event.text };
+		} catch (error) {
+			const message = `Image submission refused: ${stringifyError(error)}`;
+			ctx.ui.notify(message, "error");
+			// Print and JSON modes reserve stderr for diagnostics; input exceptions
+			// would let Pi continue submission instead of refusing the image.
+			if (!ctx.hasUI) console.error(message);
+			if (ctx.hasUI && ctx.ui.getEditorText() === "") ctx.ui.setEditorText(text);
+			return { action: "handled" };
+		}
 	});
 
 	if (settingBoolean("enableSessionNameCommand", true)) {
@@ -903,13 +943,11 @@ export default function qol(pi: ExtensionAPI): void {
 		pi.registerCommand("search:resume-pending", {
 			description: "Run a pending session-search resume or fork action",
 			handler: async (args, ctx) => {
-				const id = args.trim();
-				const action = qolSessionSearchPendingActions.get(id);
+				const action = takeSessionSearchPendingAction(args.trim());
 				if (!action) {
 					ctx.ui.notify("No pending session-search resume/fork action found.", "warning");
 					return;
 				}
-				qolSessionSearchPendingActions.delete(id);
 				if (!(await runSessionSearchResumeOrFork(pi, ctx, action))) ctx.ui.notify("Session resume/fork is unavailable in this context.", "error");
 			},
 		});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vanillagreen/pi-qol",
-  "version": "2.2.1",
+  "version": "2.3.4",
   "description": "Pi quality-of-life extension: compact statusline/π prompt, reliable multiline input, styled pasted-image chips, session naming/search/context import, scheduled prompts, handoff, permission prompts, notifications, custom compaction, and a collapsed-thinking timer.",
   "license": "MIT",
   "keywords": [
@@ -504,9 +504,9 @@
         {
           "key": "sessionSearch.cacheTtlSeconds",
           "label": "Session cache TTL",
-          "description": "Seconds before the in-memory session list is refreshed. Default 0 keeps the cache until you explicitly run /search refresh.",
+          "description": "Seconds a loaded session index is kept in memory before it is released; the next search opens at once and reloads it. 0 keeps the index until the session ends.",
           "type": "number",
-          "default": 0,
+          "default": 300,
           "category": "Session Search",
           "apply": "live"
         },
@@ -988,6 +988,7 @@
   },
   "files": [
     "extensions/",
+    "scripts/",
     "assets/",
     "README.md",
     "package.json"

package/scripts/lane-retention.ts

@@ -0,0 +1,187 @@
+/**
+ * Lane file retention: the one rule for files a Pi extension package keeps on
+ * disk for a lane (fetched text, transcripts, task logs). A lane's files are
+ * deleted once the lane's working directory is gone, which is how a merged
+ * lane's worktree ends, and no file is kept past LANE_FILE_MAX_AGE_MS.
+ *
+ * A lane directory is one the package made with openLaneDir: a real directory,
+ * owned by this user, that holds a LANE_CWD_FILE record. The prune touches
+ * nothing else under its root, so a folder another tool keeps there, or a
+ * symbolic link to one, is left alone.
+ *
+ * Vendored byte-identical into every package that keeps such files, under
+ * `scripts/`; pi-extensions/package-policy.test.mjs holds the copies equal.
+ * Edit one copy, then copy it over the others.
+ */
+import { lstatSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+export const LANE_FILE_MAX_AGE_MS = 5 * 24 * 60 * 60 * 1000;
+
+/** The file in a lane directory that names the lane's working directory. */
+export const LANE_CWD_FILE = ".lane-cwd";
+
+export interface LanePruneFailure {
+	path: string;
+	error: string;
+}
+
+export interface LanePruneResult {
+	removed: string[];
+	failed: LanePruneFailure[];
+}
+
+/** Create `dir` as a lane directory for `cwd`. Rewriting the record marks the
+ *  lane live, so its directory is not pruned as empty and old. */
+export function openLaneDir(dir: string, cwd: string): string {
+	mkdirSync(dir, { recursive: true, mode: 0o700 });
+	writeFileSync(join(dir, LANE_CWD_FILE), cwd, { mode: 0o600 });
+	return dir;
+}
+
+function message(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
+
+/** Whether `path` is a real directory, not a symbolic link, owned by this
+ *  user. A platform without user ids (Windows) checks the type alone. */
+function ownDirectory(path: string): boolean {
+	let stat;
+	try {
+		stat = lstatSync(path);
+	} catch {
+		return false;
+	}
+	const uid = process.getuid?.();
+	return stat.isDirectory() && (uid === undefined || stat.uid === uid);
+}
+
+function remove(path: string, result: LanePruneResult): void {
+	try {
+		rmSync(path, { recursive: true, force: true });
+		result.removed.push(path);
+	} catch (error) {
+		result.failed.push({ path, error: message(error) });
+	}
+}
+
+/** The lane's recorded working directory; undefined when `dir` holds no
+ *  record, so the package did not make it. */
+function recordedCwd(dir: string): string | undefined {
+	try {
+		const cwd = readFileSync(join(dir, LANE_CWD_FILE), "utf8");
+		return cwd === "" ? undefined : cwd;
+	} catch {
+		return undefined;
+	}
+}
+
+/** Whether a lane's recorded working directory is still there. Only a stat
+ *  that answers ENOENT or ENOTDIR confirms it is gone. Any other failure, such
+ *  as a refused permission or a filesystem that is briefly unavailable, is
+ *  reported against the lane and answers "unknown", so the lane is not
+ *  removed as gone. */
+function cwdState(dir: string, cwd: string, result: LanePruneResult): "present" | "gone" | "unknown" {
+	try {
+		statSync(cwd);
+		return "present";
+	} catch (error) {
+		const code = (error as NodeJS.ErrnoException).code;
+		if (code === "ENOENT" || code === "ENOTDIR") return "gone";
+		result.failed.push({ path: dir, error: `lane-cwd-unchecked: the lane is kept; its working directory could not be checked: ${message(error)}` });
+		return "unknown";
+	}
+}
+
+function modifiedAt(path: string, result: LanePruneResult): number | undefined {
+	try {
+		return lstatSync(path).mtimeMs;
+	} catch (error) {
+		result.failed.push({ path, error: message(error) });
+		return undefined;
+	}
+}
+
+/** Remove the files under `dir` older than `cutoff`, never the lane record;
+ *  return how many entries other than the record remain. */
+function pruneOldFiles(dir: string, cutoff: number, result: LanePruneResult): number {
+	let remaining = 0;
+	let entries;
+	try {
+		entries = readdirSync(dir, { withFileTypes: true });
+	} catch (error) {
+		result.failed.push({ path: dir, error: message(error) });
+		return 1;
+	}
+	for (const entry of entries) {
+		const path = join(dir, entry.name);
+		if (entry.name === LANE_CWD_FILE) continue;
+		if (entry.isDirectory()) {
+			if (pruneOldFiles(path, cutoff, result) === 0) remove(path, result);
+			else remaining++;
+			continue;
+		}
+		const mtime = modifiedAt(path, result);
+		if (mtime !== undefined && mtime < cutoff) remove(path, result);
+		else remaining++;
+	}
+	return remaining;
+}
+
+/**
+ * Apply the retention rule to each lane directory at `root/<entry>/<...below>`,
+ * one entry per session. A lane whose recorded working directory is gone is
+ * removed whole; a working directory that cannot be checked is reported and
+ * does not count as gone. Otherwise each file older than LANE_FILE_MAX_AGE_MS is
+ * removed, and the lane goes too once only its record is left and the record
+ * is that old. The record is kept while the lane is: it is what marks the
+ * directory as the package's. An absent root has no lanes. Every failure,
+ * including an unreadable root, is reported, never thrown, so the caller's
+ * other session_start work still runs.
+ */
+export function pruneLanes(root: string, below: string[] = [], now = Date.now()): LanePruneResult {
+	const result: LanePruneResult = { removed: [], failed: [] };
+	let entries: string[];
+	try {
+		entries = readdirSync(root);
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code !== "ENOENT") result.failed.push({ path: root, error: message(error) });
+		return result;
+	}
+	if (!ownDirectory(root)) {
+		result.failed.push({ path: root, error: "lane-root-not-owned: not a directory this user owns; nothing under it was pruned" });
+		return result;
+	}
+	const cutoff = now - LANE_FILE_MAX_AGE_MS;
+	for (const entry of entries) {
+		let dir = root;
+		let owned = true;
+		for (const part of [entry, ...below]) {
+			dir = join(dir, part);
+			if (!ownDirectory(dir)) {
+				owned = false;
+				break;
+			}
+		}
+		if (!owned) continue;
+		const cwd = recordedCwd(dir);
+		if (cwd === undefined) continue;
+		const state = cwdState(dir, cwd, result);
+		switch (state) {
+			case "gone":
+				remove(dir, result);
+				continue;
+			case "present":
+			case "unknown":
+				break;
+			default: {
+				const unhandled: never = state;
+				throw new Error(`lane-cwd-state-unhandled: ${String(unhandled)}`);
+			}
+		}
+		if (pruneOldFiles(dir, cutoff, result) > 0) continue;
+		const recordAt = modifiedAt(join(dir, LANE_CWD_FILE), result);
+		if (recordAt !== undefined && recordAt < cutoff) remove(dir, result);
+	}
+	return result;
+}