pi-readseek 0.3.13 → 0.3.14

package/package.json

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

package/src/grep.ts

@@ -69,8 +69,8 @@ interface GrepParams {
 	scopeContext?: number | string;
 }
 
-const MATCH_LINE_RE = /^(.*):(\d+): (.*)$/;
-const CONTEXT_LINE_RE = /^(.*)-(\d+)- (.*)$/;
+const MATCH_LINE_RE = /^(.*?):(\d+): (.*)$/;
+const CONTEXT_LINE_RE = /^(.*?)-(\d+)- (.*)$/;
 
 function parseGrepOutputLine(line: string):
 	| { kind: "match"; displayPath: string; lineNumber: number; text: string }
@@ -406,8 +406,8 @@ export function registerGrepTool(pi: ExtensionAPI, options: GrepToolOptions = {}
 					fileCache.set(absolutePath, lines);
 					return lines;
 				} catch {
-					fileCache.set(absolutePath, []);
-					return [];
+					fileCache.set(absolutePath, undefined);
+					return undefined;
 				}
 			};
 

package/src/map-cache.ts

@@ -11,6 +11,7 @@ export const MAP_CACHE_MAX_SIZE = 500;
 
 interface MapCacheGlobalState {
 	cache: Map<string, CacheEntry>;
+	inflight: Map<string, Promise<FileMap | null>>;
 	maxSize: number;
 }
 
@@ -20,6 +21,7 @@ function getMapCacheState(): MapCacheGlobalState {
 	const globalObject = globalThis as any;
 	globalObject[MAP_CACHE_STATE_KEY] ??= {
 		cache: new Map<string, CacheEntry>(),
+		inflight: new Map<string, Promise<FileMap | null>>(),
 		maxSize: MAP_CACHE_MAX_SIZE,
 	} satisfies MapCacheGlobalState;
 	return globalObject[MAP_CACHE_STATE_KEY] as MapCacheGlobalState;
@@ -54,9 +56,20 @@ export async function getOrGenerateMap(absPath: string): Promise<FileMap | null>
 			state.cache.set(absPath, cached);
 			return cached.map;
 		}
-		const map = await generateMap(absPath);
-		rememberInMemory(absPath, { mtimeMs, map });
-		return map;
+		const inflight = state.inflight.get(absPath);
+		if (inflight) return inflight;
+
+		const generation = (async () => {
+			const map = await generateMap(absPath);
+			rememberInMemory(absPath, { mtimeMs, map });
+			return map;
+		})()
+			.catch(() => null)
+			.finally(() => {
+				state.inflight.delete(absPath);
+			});
+		state.inflight.set(absPath, generation);
+		return generation;
 	} catch {
 		return null;
 	}

package/src/readseek-client.ts

@@ -170,6 +170,18 @@ interface RunReadseekOptions {
 
 async function runReadseekRaw(args: string[], options: RunReadseekOptions = {}): Promise<string> {
 	return new Promise<string>((resolve, reject) => {
+		let settled = false;
+		const fail = (error: Error): void => {
+			if (settled) return;
+			settled = true;
+			reject(error);
+		};
+		const succeed = (value: string): void => {
+			if (settled) return;
+			settled = true;
+			resolve(value);
+		};
+
 		const stdin = options.stdin;
 		const stdio: StdioOptions = [stdin === undefined ? "ignore" : "pipe", "pipe", "pipe"];
 		const child = spawn(readseekBinaryPath(), args, { stdio, signal: options.signal });
@@ -178,7 +190,7 @@ async function runReadseekRaw(args: string[], options: RunReadseekOptions = {}):
 		const childStdin = child.stdin;
 		if (!childStdout || !childStderr) {
 			child.kill();
-			reject(new Error("readseek stdio streams are unavailable"));
+			fail(new Error("readseek stdio streams are unavailable"));
 			return;
 		}
 		const stdoutChunks: Buffer[] = [];
@@ -186,32 +198,33 @@ async function runReadseekRaw(args: string[], options: RunReadseekOptions = {}):
 		let stdoutBytes = 0;
 
 		childStdout.on("data", (chunk: Buffer) => {
+			if (settled) return;
 			stdoutBytes += chunk.length;
 			if (stdoutBytes > 32 * 1024 * 1024) {
 				child.kill();
-				reject(new Error("readseek output exceeded 32 MiB"));
+				fail(new Error("readseek output exceeded 32 MiB"));
 				return;
 			}
 			stdoutChunks.push(chunk);
 		});
 		childStderr.on("data", (chunk: Buffer) => stderrChunks.push(chunk));
-		child.on("error", (error: any) => reject(error));
+		child.on("error", (error: any) => fail(error));
 		if (stdin !== undefined) {
 			if (!childStdin) {
 				child.kill();
-				reject(new Error("readseek stdin stream is unavailable"));
+				fail(new Error("readseek stdin stream is unavailable"));
 				return;
 			}
 			childStdin.on("error", (error: any) => {
-				if (error?.code !== "EPIPE") reject(error);
+				if (error?.code !== "EPIPE") fail(error);
 			});
 			childStdin.end(stdin, "utf-8");
 		}
 		child.on("close", (code) => {
 			const stdout = Buffer.concat(stdoutChunks).toString("utf-8");
 			const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
-			if (code === 0) resolve(stdout);
-			else reject(new Error((stderr || `readseek exited with status ${code}`).replace(/^error:\s*/i, "")));
+			if (code === 0) succeed(stdout);
+			else fail(new Error((stderr || `readseek exited with status ${code}`).replace(/^error:\s*/i, "")));
 		});
 	});
 }