pi-readseek 0.3.8 → 0.3.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-readseek",
-  "version": "0.3.8",
+  "version": "0.3.10",
   "description": "Pi extension for readseek-backed hash-anchored read/edit/grep, structural code maps, structural search, and file exploration",
   "type": "module",
   "exports": {
@@ -39,7 +39,7 @@
     "node": ">=20.0.0"
   },
   "dependencies": {
-    "@jarkkojs/readseek": "^0.3.0",
+    "@jarkkojs/readseek": "^0.3.8",
     "diff": "^8.0.3",
     "ignore": "^7.0.5",
     "picomatch": "^4.0.4",

package/src/edit-syntax-validate.ts

@@ -1,6 +1,5 @@
 import type { Node as SyntaxNode, Parser as WasmParser, Tree } from "web-tree-sitter";
-import { detectLanguage } from "./readseek/language-detect.js";
-import { getWasmParser } from "./readseek/parser-loader.js";
+import { getWasmParser, type WasmLanguageId } from "./readseek/parser-loader.js";
 import { reportParserError } from "./readseek/parser-errors.js";
 
 export interface ValidateInput {
@@ -75,15 +74,31 @@ function dedupeSortLines(
   return out.map((o) => o.key);
 }
 
+const EXTENSION_TO_LANGUAGE: Record<string, WasmLanguageId> = {
+	".rs": "rust",
+	".c": "cpp",
+	".cc": "cpp",
+	".cpp": "cpp",
+	".cxx": "cpp",
+	".h": "c-header",
+	".hpp": "c-header",
+	".hxx": "c-header",
+	".java": "java",
+};
+
+function detectWasmLang(filePath: string): WasmLanguageId | null {
+	for (const [ext, langId] of Object.entries(EXTENSION_TO_LANGUAGE)) {
+		if (filePath.toLowerCase().endsWith(ext)) return langId;
+	}
+	return null;
+}
+
 export async function validateSyntaxRegression(
-  input: ValidateInput,
+	input: ValidateInput,
 ): Promise<ValidateResult | null> {
-  const lang = detectLanguage(input.filePath);
-  if (!lang) return null;
-  if (lang.id !== "rust" && lang.id !== "cpp" && lang.id !== "c-header" && lang.id !== "java") {
-    return null;
-  }
-  const parser = await getWasmParser(lang.id);
+	const langId = detectWasmLang(input.filePath);
+	if (!langId) return null;
+	const parser = await getWasmParser(langId);
   if (!parser) return null;
 
   try {
@@ -109,12 +124,12 @@ export async function validateSyntaxRegression(
       ...afterStats.missing,
     ]);
     return { errorLines, newErrorCount, newMissingCount };
-  } catch (err) {
-    reportParserError(`wasm:syntax-validate:${lang.id}:${err instanceof Error ? err.message : String(err)}`, err, {
-      context: `tree-sitter syntax validation failed for ${lang.id}`,
-    });
-    return null;
-  } finally {
-    parser.delete();
+	} catch (err) {
+		reportParserError(`wasm:syntax-validate:${langId}:${err instanceof Error ? err.message : String(err)}`, err, {
+			context: `tree-sitter syntax validation failed for ${langId}`,
+		});
+		return null;
+	} finally {
+		parser.delete();
   }
 }

package/src/edit.ts

@@ -19,7 +19,7 @@ import { resolveSyntaxValidateMode, type SyntaxValidateOptions } from "./syntax-
 import { replaceSymbol } from "./replace-symbol.js";
 import { buildEditPreviewKey, buildPendingEditPreviewData, resolvePendingDiffPreview, type PendingDiffPreviewResult } from "./pending-diff-preview.js";
 import { buildDiffData, type DiffBlockRange } from "./diff-data.js";
-import { clampLineToWidth, clampLinesToWidth, isRendererExpanded, linkToolPath, summaryLine } from "./tui-render-utils.js";
+import { clampLineToWidth, clampLinesToWidth, linkToolPath, resolveRenderResultContext, summaryLine } from "./tui-render-utils.js";
 import { DiffPreviewComponent } from "./tui-diff-component.js";
 
 import { resolveEditDiffDisplay } from "./readseek-settings.js";
@@ -86,11 +86,6 @@ type HashlineParams = Static<typeof hashlineEditSchema>;
 const EDIT_PROMPT_METADATA = defineToolPromptMetadata({
 	promptUrl: new URL("../prompts/edit.md", import.meta.url),
 	promptSnippet: "Edit files using hash-verified anchors from read/grep/search/write",
-	promptGuidelines: [
-		"Use edit for changes to existing files; read or search first and copy fresh LINE:HASH anchors.",
-		"Prefer edit anchored set_line, replace_lines, and insert_after over shell rewrites.",
-		"Use edit replace only when anchored edits are impractical.",
-	],
 });
 
 function buildEditError(
@@ -644,13 +639,9 @@ export function registerEditTool(pi: ExtensionAPI, options: EditToolOptions = {}
 			return textComponent;
 		},
 			renderResult(result: any, options: ToolRenderResultOptions, theme: any, ...rest: any[]) {
-			const context: { isPartial?: boolean; isError?: boolean; expanded?: boolean; lastComponent?: any; width?: number } =
-				rest[0] ?? options ?? {};
-			const isPartial = context.isPartial ?? (options as any)?.isPartial ?? false;
-			const isError = context.isError ?? false;
+			const { isPartial, isError, expanded: baseExpanded, width, context } = resolveRenderResultContext(options, rest);
 
 			if (isPartial) {
-				const width = (context as any).width ?? (options as any)?.width;
 				return new Text(clampLinesToWidth([summaryLine("pending edit")], width).join("\n"), 0, 0);
 			}
 
@@ -678,8 +669,7 @@ export function registerEditTool(pi: ExtensionAPI, options: EditToolOptions = {}
 				semanticClassification: semanticClassification as any,
 			});
 
-			const expanded = isRendererExpanded(options as any, context as any) || resolveEditDiffDisplay() === "expanded";
-			const width = (context as any).width ?? (options as any)?.width;
+			const expanded = baseExpanded || resolveEditDiffDisplay() === "expanded";
 			const diffData = (details as any).diffData;
 			const stats = diffData?.stats ?? { added: 0, removed: 0 };
 			let text = "";

package/src/grep.ts

@@ -7,7 +7,7 @@ import { defineToolPromptMetadata } from "./tool-prompt-metadata.js";
 import { normalizeToLF, stripBom, hasBareCarriageReturn } from "./edit-diff.js";
 import { looksLikeBinary } from "./binary-detect.js";
 import { ensureHashInit, formatHashlineDisplay, escapeControlCharsForDisplay } from "./hashline.js";
-import { buildReadseekError, buildReadseekLine } from "./readseek-value.js";
+import { buildReadseekLine, buildToolErrorResult } from "./readseek-value.js";
 import { buildGrepOutput } from "./grep-output.js";
 
 import { getOrGenerateMap } from "./map-cache.js";
@@ -17,16 +17,11 @@ import { throwIfAborted } from "./runtime.js";
 import { Text } from "@earendil-works/pi-tui";
 import { formatGrepCallText, formatGrepResultText } from "./grep-render-helpers.js";
 import { coerceObviousBase10Int } from "./coerce-obvious-int.js";
-import { clampLineToWidth, clampLinesToWidth, isRendererExpanded, linkToolPath, renderToolLabel, summaryLine } from "./tui-render-utils.js";
+import { clampLineToWidth, clampLinesToWidth, linkToolPath, renderToolLabel, resolveRenderResultContext, summaryLine } from "./tui-render-utils.js";
 
 const GREP_PROMPT_METADATA = defineToolPromptMetadata({
 	promptUrl: new URL("../prompts/grep.md", import.meta.url),
 	promptSnippet: "Search file contents and return edit-ready hashline anchors",
-	promptGuidelines: [
-		"Use grep for text search across files instead of bash grep or rg.",
-		"Use grep summary mode when you only need matching files or counts.",
-		"Use search instead of grep when the query depends on code structure.",
-	],
 });
 
 const grepSchema = Type.Object({
@@ -314,76 +309,23 @@ export function registerGrepTool(pi: ExtensionAPI, options: GrepToolOptions = {}
 			const rawParams = params as GrepParams;
 			const context = coerceObviousBase10Int(rawParams.context, "context");
 			if (!context.ok) {
-				return {
-					content: [{ type: "text", text: context.message }],
-					isError: true,
-					details: {
-						readseekValue: {
-							tool: "grep",
-							ok: false,
-							error: buildReadseekError("invalid-params-combo", context.message),
-						},
-					},
-				};
+				return buildToolErrorResult("grep", "invalid-params-combo", context.message);
 			}
 			const limit = coerceObviousBase10Int(rawParams.limit, "limit");
 			if (!limit.ok) {
-				return {
-					content: [{ type: "text", text: limit.message }],
-					isError: true,
-					details: {
-						readseekValue: {
-							tool: "grep",
-							ok: false,
-							error: buildReadseekError("invalid-limit", limit.message),
-						},
-					},
-				};
+				return buildToolErrorResult("grep", "invalid-limit", limit.message);
 			}
 			const scopeContext = coerceObviousBase10Int(rawParams.scopeContext, "scopeContext");
 			if (!scopeContext.ok) {
-				return {
-					content: [{ type: "text", text: scopeContext.message }],
-					isError: true,
-					details: {
-						readseekValue: {
-							tool: "grep",
-							ok: false,
-							error: buildReadseekError("invalid-params-combo", scopeContext.message),
-						},
-					},
-				};
+				return buildToolErrorResult("grep", "invalid-params-combo", scopeContext.message);
 			}
 			if (scopeContext.value !== undefined && rawParams.scope !== "symbol") {
 				const message = 'Invalid scopeContext: requires scope: "symbol". For normal surrounding-line context outside symbol scope, use the `context` parameter.';
-				return {
-					content: [{
-						type: "text",
-						text: message,
-					}],
-					isError: true,
-					details: {
-						readseekValue: {
-							tool: "grep",
-							ok: false,
-							error: buildReadseekError("invalid-params-combo", message),
-						},
-					},
-				};
+				return buildToolErrorResult("grep", "invalid-params-combo", message);
 			}
 			if (scopeContext.value !== undefined && scopeContext.value < 0) {
 				const message = `Invalid scopeContext: expected a non-negative integer, received ${scopeContext.value}.`;
-				return {
-					content: [{ type: "text", text: message }],
-					isError: true,
-					details: {
-						readseekValue: {
-							tool: "grep",
-							ok: false,
-							error: buildReadseekError("invalid-params-combo", message),
-						},
-					},
-				};
+				return buildToolErrorResult("grep", "invalid-params-combo", message);
 			}
 			const p: GrepParams = {
 				...rawParams,
@@ -716,13 +658,7 @@ if (p.scope === "symbol" && !summary) {
 			return new Text(clampLineToWidth(text, context.width), 0, 0);
 		},
 		renderResult(result: any, options: ToolRenderResultOptions, theme: any, ...rest: any[]) {
-			const context: { isPartial?: boolean; isError?: boolean; expanded?: boolean; cwd?: string; width?: number } =
-				rest[0] ?? options ?? {};
-			const isPartial = context.isPartial ?? (options as any)?.isPartial ?? false;
-			const isError = context.isError ?? false;
-			const expanded = isRendererExpanded(options as any, context as any);
-			const cwd = context.cwd ?? process.cwd();
-			const width = (context as any).width ?? (options as any)?.width;
+			const { isPartial, isError, expanded, cwd, width } = resolveRenderResultContext(options, rest);
 
 			if (isPartial) return new Text(clampLinesToWidth([summaryLine("pending search")], width).join("\n"), 0, 0);
 

package/src/image-detect.ts

@@ -0,0 +1,47 @@
+const PNG_SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
+
+function startsWithBytes(buffer: Buffer, bytes: number[]): boolean {
+	return buffer.length >= bytes.length && bytes.every((byte, index) => buffer[index] === byte);
+}
+
+function startsWithAscii(buffer: Buffer, offset: number, text: string): boolean {
+	if (buffer.length < offset + text.length) return false;
+	for (let index = 0; index < text.length; index++) {
+		if (buffer[offset + index] !== text.charCodeAt(index)) return false;
+	}
+	return true;
+}
+
+function readUint32BE(buffer: Buffer, offset: number): number {
+	return (
+		((buffer[offset] ?? 0) * 0x1000000) +
+		((buffer[offset + 1] ?? 0) << 16) +
+		((buffer[offset + 2] ?? 0) << 8) +
+		(buffer[offset + 3] ?? 0)
+	);
+}
+
+function isPng(buffer: Buffer): boolean {
+	return buffer.length >= 16 && readUint32BE(buffer, PNG_SIGNATURE.length) === 13 && startsWithAscii(buffer, 12, "IHDR");
+}
+
+function isAnimatedPng(buffer: Buffer): boolean {
+	let offset = PNG_SIGNATURE.length;
+	while (offset + 8 <= buffer.length) {
+		const chunkLength = readUint32BE(buffer, offset);
+		const chunkTypeOffset = offset + 4;
+		if (startsWithAscii(buffer, chunkTypeOffset, "acTL")) return true;
+		if (startsWithAscii(buffer, chunkTypeOffset, "IDAT")) return false;
+		const nextOffset = offset + 8 + chunkLength + 4;
+		if (nextOffset <= offset || nextOffset > buffer.length) return false;
+		offset = nextOffset;
+	}
+	return false;
+}
+
+export function isSupportedImageBuffer(buffer: Buffer): boolean {
+	if (startsWithBytes(buffer, [0xff, 0xd8, 0xff])) return buffer[3] !== 0xf7;
+	if (startsWithBytes(buffer, PNG_SIGNATURE)) return isPng(buffer) && !isAnimatedPng(buffer);
+	if (startsWithAscii(buffer, 0, "GIF")) return true;
+	return startsWithAscii(buffer, 0, "RIFF") && startsWithAscii(buffer, 8, "WEBP");
+}

package/src/map-cache.ts

@@ -1,18 +1,12 @@
 import { stat } from "node:fs/promises";
 import type { FileMap } from "./readseek/types.js";
-import { generateMap, generateMapWithIdentity, READSEEK_MAPPER_IDENTITY } from "./readseek/mapper.js";
-import {
-  computeKey,
-  contentHashFor64k,
-  readCached,
-  writeCached,
-  persistenceEnabled,
-} from "./persistent-map-cache.js";
+import { generateMap } from "./readseek/mapper.js";
+
 interface CacheEntry {
 	mtimeMs: number;
-	contentHash: string;
 	map: FileMap | null;
 }
+
 export const MAP_CACHE_MAX_SIZE = 500;
 
 interface MapCacheGlobalState {
@@ -41,21 +35,12 @@ function rememberInMemory(absPath: string, entry: CacheEntry): void {
 	}
 }
 
-async function stableContentHash(
-	absPath: string,
-	mtimeMs: number,
-	expectedHash: string,
-): Promise<string | null> {
-	if (!expectedHash) return null;
-	const currentStat = await stat(absPath);
-	if (currentStat.mtimeMs !== mtimeMs) return null;
-	const currentHash = await contentHashFor64k(absPath);
-	if (!currentHash || currentHash !== expectedHash) return null;
-	return currentHash;
-}
-
 /**
- * Get or generate a structural file map, with mtime-based caching.
+ * Get or generate a structural file map, with mtime-based in-memory caching.
+ * Readseek already caches map results in `.readseek/maps/` with its own binary
+ * format.  The in-memory layer here avoids redundant process spawns within a
+ * single session.
+ *
  * Returns null on any failure — never throws.
  */
 export async function getOrGenerateMap(absPath: string): Promise<FileMap | null> {
@@ -65,72 +50,14 @@ export async function getOrGenerateMap(absPath: string): Promise<FileMap | null>
 		const state = getMapCacheState();
 		const cached = state.cache.get(absPath);
 		if (cached && cached.mtimeMs === mtimeMs) {
-			const currentHash = await contentHashFor64k(absPath);
-			if (currentHash && currentHash === cached.contentHash) {
-				state.cache.delete(absPath);
-				state.cache.set(absPath, cached);
-				return cached.map;
-			}
-		}
-		if (!persistenceEnabled()) {
-			const map = await generateMap(absPath);
-			const hash = await contentHashFor64k(absPath);
-			rememberInMemory(absPath, { mtimeMs, contentHash: hash, map });
-			return map;
-		}
-
-		let preContentHash = "";
-		try {
-			preContentHash = await contentHashFor64k(absPath);
-			if (preContentHash) {
-				const key = computeKey(
-					absPath,
-					mtimeMs,
-					preContentHash,
-					READSEEK_MAPPER_IDENTITY.mapperName,
-					READSEEK_MAPPER_IDENTITY.mapperVersion,
-				);
-				const fromDisk = await readCached(key);
-				if (fromDisk) {
-					rememberInMemory(absPath, { mtimeMs, contentHash: preContentHash, map: fromDisk });
-					return fromDisk;
-				}
-			}
-		} catch {
-			// fall through to regeneration on a disk-cache miss
-		}
-		const { map, mapperName, mapperVersion } = await generateMapWithIdentity(absPath);
-		const persistentIdentity = { mapperName, mapperVersion };
-		let stableHash: string | null = null;
-		let shouldRemember = true;
-		if (preContentHash) {
-			try {
-				stableHash = await stableContentHash(absPath, mtimeMs, preContentHash);
-				shouldRemember = stableHash !== null;
-			} catch {
-				shouldRemember = false;
-			}
-		}
-		if (shouldRemember) {
-			const hash = stableHash ?? preContentHash ?? "";
-			rememberInMemory(absPath, { mtimeMs, contentHash: hash, map });
-		}
-		if (map && stableHash) {
-			try {
-				const key = computeKey(
-					absPath,
-					mtimeMs,
-					stableHash,
-					persistentIdentity.mapperName,
-					persistentIdentity.mapperVersion,
-				);
-				await writeCached(key, map);
-			} catch {
-				// never fail the caller on a cache-write miss
-			}
+			state.cache.delete(absPath);
+			state.cache.set(absPath, cached);
+			return cached.map;
 		}
+		const map = await generateMap(absPath);
+		rememberInMemory(absPath, { mtimeMs, map });
 		return map;
 	} catch {
 		return null;
 	}
-}
+}