pi-readseek 0.4.27 → 0.4.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-readseek",
-  "version": "0.4.27",
+  "version": "0.4.28",
   "description": "Pi extension for readseek-backed hash-anchored read/edit/grep, structural code maps, structural search, and file exploration",
   "type": "module",
   "exports": {

package/src/read.ts

@@ -29,7 +29,7 @@ import { coerceObviousBase10Int } from "./coerce-obvious-int.js";
 import { readseekRead, readseekDetect, type ReadSeekDetection } from "./readseek-client.js";
 import { formatReadCallText, formatReadResultText } from "./read-render-helpers.js";
 import { resolveReadSeekOcrMode } from "./readseek-settings.js";
-import { clampLineToWidth, clampLinesToWidth, linkToolPath, renderPendingResult, renderToolLabel, resolveRenderResultContext, summaryLine, wrapReadHashlinesForWidth } from "./tui-render-utils.js";
+import { clampLineToWidth, clampLinesToWidth, linkToolPath, renderPendingResult, renderToolLabel, resolveRenderResultContext, summaryLine, wrapReadHashlinesForWidthCached } from "./tui-render-utils.js";
 import type { FileAnchoredCallback } from "./tool-types.js";
 import { filePathParam, mapParam, optionalIntOrString, registerReadSeekTool } from "./register-tool.js";
 
@@ -543,7 +543,7 @@ export function registerReadTool(pi: ExtensionAPI, options: ReadToolOptions = {}
 			for (const badge of info.badges) summaryParts.push(badge);
 			const summary = summaryParts.join(" • ");
 			let text = summaryLine(summary, { hidden: !!textContent && !expanded });
-			if (expanded && textContent) text += "\n" + wrapReadHashlinesForWidth(textContent, width);
+			if (expanded && textContent) text += "\n" + wrapReadHashlinesForWidthCached(content, textContent, width);
 			return new Text(clampLinesToWidth(text.split("\n"), width).join("\n"), 0, 0);
 		},
 	});

package/src/readseek-client.ts

@@ -286,23 +286,36 @@ function directoryExists(dirPath: string): boolean {
 	}
 }
 
+const ownRepositoryByDir = new Map<string, boolean>();
+
 function isOwnReadSeekRepository(cwd = process.cwd()): boolean {
-	let dir = path.resolve(cwd);
+	const start = path.resolve(cwd);
+	const cached = ownRepositoryByDir.get(start);
+	if (cached !== undefined) return cached;
+
+	let dir = start;
+	let result = false;
 	while (true) {
 		const packageJsonPath = path.join(dir, "package.json");
 		if (existsSync(packageJsonPath)) {
 			try {
 				const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8")) as { name?: unknown };
-				if (typeof packageJson.name === "string" && READSEEK_REPO_PACKAGE_NAMES.has(packageJson.name)) return true;
+				if (typeof packageJson.name === "string" && READSEEK_REPO_PACKAGE_NAMES.has(packageJson.name)) {
+					result = true;
+					break;
+				}
 			} catch {
 				// Ignore unreadable or invalid package manifests while walking up.
 			}
 		}
 
 		const parent = path.dirname(dir);
-		if (parent === dir) return false;
+		if (parent === dir) break;
 		dir = parent;
 	}
+
+	ownRepositoryByDir.set(start, result);
+	return result;
 }
 
 function defaultReadSeekDir(): string | null {
@@ -310,23 +323,43 @@ function defaultReadSeekDir(): string | null {
 	return home ? path.join(home, ".pi", "readseek") : null;
 }
 
+const DEFAULT_READSEEK_TIMEOUT_MS = 120_000;
+
+function readseekTimeoutMs(): number {
+	const raw = process.env.READSEEK_TIMEOUT_MS;
+	if (raw !== undefined && raw !== "") {
+		const parsed = Number(raw);
+		if (Number.isFinite(parsed) && parsed > 0) return parsed;
+	}
+	return DEFAULT_READSEEK_TIMEOUT_MS;
+}
+
 async function spawnReadSeekRaw(args: string[], options: RunReadSeekOptions = {}): Promise<string> {
 	return new Promise<string>((resolve, reject) => {
 		let settled = false;
+		let timeout: ReturnType<typeof setTimeout> | undefined;
 		const fail = (error: Error): void => {
 			if (settled) return;
 			settled = true;
+			if (timeout !== undefined) clearTimeout(timeout);
 			reject(error);
 		};
 		const succeed = (value: string): void => {
 			if (settled) return;
 			settled = true;
+			if (timeout !== undefined) clearTimeout(timeout);
 			resolve(value);
 		};
 
 		const stdin = options.stdin;
 		const stdio: StdioOptions = [stdin === undefined ? "ignore" : "pipe", "pipe", "pipe"];
 		const child = spawn(readseekBinaryPath(), args, { stdio, signal: options.signal });
+		const timeoutMs = options.timeoutMs ?? readseekTimeoutMs();
+		timeout = setTimeout(() => {
+			child.kill("SIGKILL");
+			fail(new Error(`readseek timed out after ${timeoutMs} ms`));
+		}, timeoutMs);
+		timeout.unref?.();
 		const childStdout = child.stdout;
 		const childStderr = child.stderr;
 		const childStdin = child.stdin;
@@ -396,6 +429,7 @@ async function readseekInvocationArgs(args: string[]): Promise<string[]> {
 interface RunReadSeekOptions {
 	signal?: AbortSignal;
 	stdin?: string;
+	timeoutMs?: number;
 }
 
 async function runReadSeekRaw(args: string[], options: RunReadSeekOptions = {}): Promise<string> {

package/src/readseek-settings.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from "node:fs";
+import { readFileSync, statSync, type Stats } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
@@ -89,16 +89,42 @@ function validateSettings(raw: unknown, source: string): ReadSeekSettingsResult
   return { settings, warnings };
 }
 
+interface SettingsFileCacheEntry {
+  mtimeMs: number;
+  size: number;
+  result: ReadSeekSettingsResult;
+}
+
+const settingsFileCache = new Map<string, SettingsFileCacheEntry>();
+
+function statFileOrNull(path: string): Stats | null {
+  try {
+    return statSync(path);
+  } catch {
+    return null;
+  }
+}
+
 function readSettingsFile(path: string): ReadSeekSettingsResult {
-  if (!existsSync(path)) return { settings: {}, warnings: [] };
+  const stats = statFileOrNull(path);
+  if (!stats) {
+    settingsFileCache.delete(path);
+    return { settings: {}, warnings: [] };
+  }
+
+  const cached = settingsFileCache.get(path);
+  if (cached && cached.mtimeMs === stats.mtimeMs && cached.size === stats.size) return cached.result;
 
+  let result: ReadSeekSettingsResult;
   try {
     const text = readFileSync(path, "utf8");
-    return validateSettings(JSON.parse(text) as unknown, path);
+    result = validateSettings(JSON.parse(text) as unknown, path);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    return { settings: {}, warnings: [{ source: path, message: `Invalid JSON: ${message}` }] };
+    result = { settings: {}, warnings: [{ source: path, message: `Invalid JSON: ${message}` }] };
   }
+  settingsFileCache.set(path, { mtimeMs: stats.mtimeMs, size: stats.size, result });
+  return result;
 }
 
 function mergeSettings(base: ReadSeekJsonSettings, override: ReadSeekJsonSettings): ReadSeekJsonSettings {

package/src/tui-render-utils.ts

@@ -149,6 +149,26 @@ export function wrapReadHashlinesForWidth(text: string, width: number | undefine
   return output.join("\n");
 }
 
+const wrappedHashlinesCache = new WeakMap<object, { text: string; width: number | undefined; wrapped: string }>();
+
+/**
+ * Memoized {@link wrapReadHashlinesForWidth} for render paths that re-run on
+ * every TUI frame: the wrapped output is cached per result content object so
+ * an expanded read result is only re-wrapped when its text or the terminal
+ * width changes.
+ */
+export function wrapReadHashlinesForWidthCached(
+  cacheKey: object,
+  text: string,
+  width: number | undefined,
+): string {
+  const cached = wrappedHashlinesCache.get(cacheKey);
+  if (cached && cached.text === text && cached.width === width) return cached.wrapped;
+  const wrapped = wrapReadHashlinesForWidth(text, width);
+  wrappedHashlinesCache.set(cacheKey, { text, width, wrapped });
+  return wrapped;
+}
+
 /**
  * Render the `isPartial` placeholder line shared by every tool's `renderResult`.
  */