pi-readseek 0.3.8 → 0.3.9

package/package.json

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

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/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;
 	}
-}
+}

package/src/readseek/mapper.ts

@@ -4,49 +4,25 @@ import { readseekMap, readseekMapContent } from "../readseek-client.js";
 import { throwIfAborted } from "../runtime.js";
 import type { FileMap, MapOptions } from "./types.js";
 
-export const READSEEK_MAPPER_NAME = "readseek";
-export const READSEEK_MAPPER_VERSION = 2;
-
-export interface MapperIdentity {
-  mapperName: string;
-  mapperVersion: number;
-}
-
-export interface MapResultWithIdentity extends MapperIdentity {
-  map: FileMap | null;
-}
-
-export const READSEEK_MAPPER_IDENTITY: MapperIdentity = {
-  mapperName: READSEEK_MAPPER_NAME,
-  mapperVersion: READSEEK_MAPPER_VERSION,
-};
-export async function generateMapWithIdentity(
-  filePath: string,
-  options: MapOptions = {},
-): Promise<MapResultWithIdentity> {
-  throwIfAborted(options.signal);
-  const fileStat = await stat(filePath);
-  throwIfAborted(options.signal);
-  const map = await readseekMap(filePath, fileStat.size, { signal: options.signal });
-  throwIfAborted(options.signal);
-  return { map, ...READSEEK_MAPPER_IDENTITY };
-}
-
 export async function generateMap(
-  filePath: string,
-  options: MapOptions = {},
+	filePath: string,
+	options: MapOptions = {},
 ): Promise<FileMap | null> {
-  return (await generateMapWithIdentity(filePath, options)).map;
+	throwIfAborted(options.signal);
+	const fileStat = await stat(filePath);
+	throwIfAborted(options.signal);
+	const map = await readseekMap(filePath, fileStat.size, { signal: options.signal });
+	throwIfAborted(options.signal);
+	return map;
 }
 
 export async function generateMapFromContent(
-  filePath: string,
-  content: string,
-  options: MapOptions = {},
+	filePath: string,
+	content: string,
+	options: MapOptions = {},
 ): Promise<FileMap | null> {
-  throwIfAborted(options.signal);
-  const map = await readseekMapContent(filePath, content, { signal: options.signal });
-  throwIfAborted(options.signal);
-  return map;
+	throwIfAborted(options.signal);
+	const map = await readseekMapContent(filePath, content, { signal: options.signal });
+	throwIfAborted(options.signal);
+	return map;
 }
-

package/src/readseek-settings.ts

@@ -4,7 +4,6 @@ import { join } from "node:path";
 
 export interface ReadseekJsonSettings {
   grep?: { maxLines?: number; maxBytes?: number };
-  mapCache?: { dir?: string; enabled?: boolean };
   edit?: { diffDisplay?: "collapsed" | "expanded" };
 }
 
@@ -77,16 +76,6 @@ function validateSettings(raw: unknown, source: string): ReadseekSettingsResult
     if (Object.keys(grep).length > 0) settings.grep = grep;
   }
 
-  if (isRecord(raw.mapCache)) {
-    const mapCache: NonNullable<ReadseekJsonSettings["mapCache"]> = {};
-    if ("dir" in raw.mapCache) {
-      if (typeof raw.mapCache.dir === "string" && raw.mapCache.dir.length > 0) mapCache.dir = raw.mapCache.dir;
-      else warnings.push(invalid(source, "mapCache.dir"));
-    }
-    const enabled = readBoolean(raw.mapCache, "enabled", "mapCache.enabled", source, warnings);
-    if (enabled !== undefined) mapCache.enabled = enabled;
-    if (Object.keys(mapCache).length > 0) settings.mapCache = mapCache;
-  }
 
   if (isRecord(raw.edit)) {
     const edit: NonNullable<ReadseekJsonSettings["edit"]> = {};
@@ -117,8 +106,6 @@ function mergeSettings(base: ReadseekJsonSettings, override: ReadseekJsonSetting
   const merged: ReadseekJsonSettings = {};
   const grep = { ...(base.grep ?? {}), ...(override.grep ?? {}) };
   if (Object.keys(grep).length > 0) merged.grep = grep;
-  const mapCache = { ...(base.mapCache ?? {}), ...(override.mapCache ?? {}) };
-  if (Object.keys(mapCache).length > 0) merged.mapCache = mapCache;
   const edit = { ...(base.edit ?? {}), ...(override.edit ?? {}) };
   if (Object.keys(edit).length > 0) merged.edit = edit;
   return merged;

package/src/binary-resolution.ts

@@ -1,77 +0,0 @@
-import { existsSync as defaultExistsSync, readFileSync } from "node:fs";
-import { createRequire } from "node:module";
-import { dirname, resolve } from "node:path";
-
-const require = createRequire(import.meta.url);
-
-export interface ResolveBundledBinDeps {
-  resolvePackageJson?: (specifier: string) => string;
-  readPackageJson?: (packageJsonPath: string) => string;
-  existsSync?: (candidate: string) => boolean;
-  platform?: NodeJS.Platform;
-}
-
-function defaultResolvePackageJson(specifier: string): string {
-  return require.resolve(specifier);
-}
-
-function defaultReadPackageJson(packageJsonPath: string): string {
-  return readFileSync(packageJsonPath, "utf8");
-}
-
-function binEntryFor(packageJsonText: string, binName: string): string | undefined {
-  const parsed = JSON.parse(packageJsonText) as { bin?: string | Record<string, string> };
-  if (typeof parsed.bin === "string") return parsed.bin;
-  return parsed.bin?.[binName];
-}
-
-function commandCandidates(basePath: string, platform: NodeJS.Platform): string[] {
-  if (platform !== "win32") return [basePath];
-  return [`${basePath}.exe`, basePath];
-}
-
-function firstExisting(candidates: string[], existsSync: (candidate: string) => boolean): string | undefined {
-  return candidates.find((candidate) => existsSync(candidate));
-}
-
-export interface ExecutableCommand {
-  command: string;
-  argsPrefix: string[];
-}
-
-export function executableCommand(binaryPath: string, platform: NodeJS.Platform = process.platform): ExecutableCommand {
-  if (platform === "win32" && /\.js$/i.test(binaryPath)) {
-    return { command: process.execPath, argsPrefix: [binaryPath] };
-  }
-  return { command: binaryPath, argsPrefix: [] };
-}
-
-export function resolveBundledBin(
-  packageName: string,
-  binName: string,
-  fallbackCommand: string,
-  deps: ResolveBundledBinDeps = {},
-): string {
-  const resolvePackageJson = deps.resolvePackageJson ?? defaultResolvePackageJson;
-  const readPackageJson = deps.readPackageJson ?? defaultReadPackageJson;
-  const existsSync = deps.existsSync ?? defaultExistsSync;
-  const platform = deps.platform ?? process.platform;
-
-  try {
-    const packageJsonPath = resolvePackageJson(`${packageName}/package.json`);
-    const packageDir = dirname(packageJsonPath);
-    const binEntry = binEntryFor(readPackageJson(packageJsonPath), binName);
-    if (!binEntry) return fallbackCommand;
-
-
-    const packageBinCandidate = firstExisting(
-      commandCandidates(resolve(packageDir, binEntry), platform),
-      existsSync,
-    );
-    if (packageBinCandidate) return packageBinCandidate;
-  } catch {
-    // Fall through to PATH fallback.
-  }
-
-  return fallbackCommand;
-}

package/src/find-parsers.ts

@@ -1,89 +0,0 @@
-const SIZE_MULTIPLIERS: Record<string, number> = {
-  "": 1,
-  B: 1,
-  K: 1024,
-  KB: 1024,
-  M: 1024 * 1024,
-  MB: 1024 * 1024,
-  G: 1024 ** 3,
-  GB: 1024 ** 3,
-};
-
-export function parseSize(field: string, value: number | string): number {
-  if (typeof value === "number") {
-    if (!Number.isFinite(value) || value < 0) {
-      throw new Error(
-        `Invalid ${field} value: ${value} (expected a non-negative number of bytes)`,
-      );
-    }
-    return value;
-  }
-
-  const match = /^\s*(\d+(?:\.\d+)?)\s*([a-zA-Z]*)\s*$/.exec(value);
-  if (!match) {
-    throw new Error(
-      `Invalid ${field} value: ${JSON.stringify(value)} ` +
-        `(expected a number with optional B/K/KB/M/MB/G/GB suffix; units are 1024-based)`,
-    );
-  }
-
-  const num = parseFloat(match[1]);
-  const suffix = match[2].toUpperCase();
-  const mult = SIZE_MULTIPLIERS[suffix];
-  if (mult === undefined) {
-    throw new Error(
-      `Invalid ${field} value: ${JSON.stringify(value)} ` +
-        `(unknown unit '${match[2]}'; accepted: B, K, KB, M, MB, G, GB)`,
-    );
-  }
-
-  return Math.round(num * mult);
-}
-
-const RELATIVE_UNIT_MS: Record<string, number> = {
-  m: 60 * 1000,
-  h: 60 * 60 * 1000,
-  d: 24 * 60 * 60 * 1000,
-};
-
-const ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
-const ISO_TS_RE =
-  /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?(?:Z|[+-]\d{2}:\d{2})$/;
-
-export function parseRelativeOrIsoDate(
-  field: string,
-  value: string,
-  now: Date = new Date(),
-): Date {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new Error(
-      `Invalid ${field} value: ${JSON.stringify(value)} ` +
-        `(expected ISO date/timestamp or relative shorthand like '1h', '24h', '7d', '30m')`,
-    );
-  }
-
-  const rel = /^\s*(\d+)\s*([mhd])\s*$/.exec(value);
-  if (rel) {
-    const n = parseInt(rel[1], 10);
-    return new Date(now.getTime() - n * RELATIVE_UNIT_MS[rel[2]]);
-  }
-
-  if (ISO_DATE_RE.test(value)) {
-    const parsed = new Date(`${value}T00:00:00.000Z`);
-    if (!Number.isNaN(parsed.getTime())) {
-      return parsed;
-    }
-  }
-
-  if (ISO_TS_RE.test(value)) {
-    const parsed = new Date(value);
-    if (!Number.isNaN(parsed.getTime())) {
-      return parsed;
-    }
-  }
-
-  throw new Error(
-    `Invalid ${field} value: ${JSON.stringify(value)} ` +
-      `(expected ISO date/timestamp or relative shorthand like '1h', '24h', '7d', '30m')`,
-  );
-}

package/src/find-stat.ts

@@ -1,36 +0,0 @@
-import * as fsPromises from "node:fs/promises";
-import type { Stats } from "node:fs";
-import { resolve as resolvePath } from "node:path";
-
-export const DEFAULT_STAT_CONCURRENCY = 32;
-export const _testable = {
-  stat: fsPromises.stat,
-};
-
-export async function statAllWithConcurrency(
-  relPaths: string[],
-  baseDir: string,
-  concurrency: number = DEFAULT_STAT_CONCURRENCY,
-): Promise<(Stats | null)[]> {
-  const requested = Number.isFinite(concurrency)
-    ? concurrency
-    : DEFAULT_STAT_CONCURRENCY;
-  const limit = Math.max(1, Math.min(requested, DEFAULT_STAT_CONCURRENCY));
-  const out: (Stats | null)[] = new Array(relPaths.length).fill(null);
-  let next = 0;
-
-  async function worker() {
-    while (true) {
-      const i = next++;
-      if (i >= relPaths.length) return;
-      try {
-        out[i] = await _testable.stat(resolvePath(baseDir, relPaths[i]));
-      } catch {
-        out[i] = null;
-      }
-    }
-  }
-
-  await Promise.all(Array.from({ length: Math.min(limit, relPaths.length) }, () => worker()));
-  return out;
-}

package/src/persistent-map-cache.ts

@@ -1,230 +0,0 @@
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { createHash, randomBytes } from "node:crypto";
-import { open, readFile, writeFile as fsWriteFile, mkdir as fsMkdir, rename, readdir, stat, unlink } from "node:fs/promises";
-import xxhashWasm from "xxhash-wasm";
-import type { FileMap } from "./readseek/types.js";
-import { resolveReadseekJsonSettings } from "./readseek-settings.js";
-
-/**
- * Resolve the on-disk map-cache directory using config precedence:
- * 1. `PI_HASHLINE_MAP_CACHE_DIR` (when non-empty) — used verbatim.
- * 2. JSON `mapCache.dir` (when configured).
- * 3. `$XDG_CACHE_HOME/pi-readseek/maps` (when non-empty).
- * 4. `~/.cache/pi-readseek/maps`.
- */
-function resolveCacheDir(): string {
-  const explicit = process.env.PI_HASHLINE_MAP_CACHE_DIR;
-  if (explicit && explicit.length > 0) return explicit;
-
-  const configured = resolveReadseekJsonSettings().settings.mapCache?.dir;
-  if (configured && configured.length > 0) return configured;
-
-  const xdg = process.env.XDG_CACHE_HOME;
-  if (xdg && xdg.length > 0) return join(xdg, "pi-readseek/maps");
-
-  return join(homedir(), ".cache/pi-readseek/maps");
-}
-
-export function persistenceEnabled(): boolean {
-  if (process.env.PI_HASHLINE_NO_PERSIST_MAPS === "1") return false;
-  const configured = resolveReadseekJsonSettings().settings.mapCache?.enabled;
-  if (configured !== undefined) return configured;
-  return true;
-}
-
-/**
- * Build a deterministic hex cache key from the five input components.
- * Uses SHA-256 truncated to 32 hex chars; collision-safe for our purposes
- * and short enough for readable filenames.
- */
-export function computeKey(
-  absolutePath: string,
-  mtimeMs: number,
-  contentHash: string,
-  mapperName: string,
-  mapperVersion: number,
-): string {
-  return createHash("sha256")
-    .update(`${absolutePath}\0${mtimeMs}\0${contentHash}\0${mapperName}\0${mapperVersion}`)
-    .digest("hex")
-    .slice(0, 32);
-}
-
-const CONTENT_HASH_WINDOW_BYTES = 64 * 1024;
-
-let xxhashReady: Promise<{ h32Raw: (b: Uint8Array, seed?: number) => number }> | null = null;
-
-function loadXxhash(): Promise<{ h32Raw: (b: Uint8Array, seed?: number) => number }> {
-  if (!xxhashReady) {
-    xxhashReady = xxhashWasm().then((h) => ({ h32Raw: h.h32Raw }));
-  }
-
-  return xxhashReady;
-}
-
-/**
- * xxHash32 hex digest over the first 64 KB of `absPath`. Returns "" if the
- * file cannot be opened or read — the caller treats that as a miss.
- */
-export async function contentHashFor64k(absPath: string): Promise<string> {
-  try {
-    const fh = await open(absPath, "r");
-    try {
-      const buf = Buffer.alloc(CONTENT_HASH_WINDOW_BYTES);
-      const { bytesRead } = await fh.read(buf, 0, CONTENT_HASH_WINDOW_BYTES, 0);
-      const view = buf.subarray(0, bytesRead);
-      const { h32Raw } = await loadXxhash();
-      const n = h32Raw(view, 0) >>> 0;
-      return n.toString(16).padStart(8, "0");
-    } finally {
-      await fh.close();
-    }
-  } catch {
-    return "";
-  }
-}
-
-function keyPath(key: string): string {
-  return join(resolveCacheDir(), `${key}.json`);
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null;
-}
-
-function isStringArray(value: unknown): value is string[] {
-  return Array.isArray(value) && value.every((item) => typeof item === "string");
-}
-
-function isFileSymbolLike(value: unknown): boolean {
-  if (!isRecord(value)) return false;
-  if (typeof value.name !== "string") return false;
-  if (typeof value.kind !== "string") return false;
-  if (typeof value.startLine !== "number") return false;
-  if (typeof value.endLine !== "number") return false;
-  if (value.signature !== undefined && typeof value.signature !== "string") return false;
-  if (value.children !== undefined && (!Array.isArray(value.children) || !value.children.every(isFileSymbolLike))) {
-    return false;
-  }
-  if (value.modifiers !== undefined && !isStringArray(value.modifiers)) return false;
-  if (value.docstring !== undefined && typeof value.docstring !== "string") return false;
-  if (value.isExported !== undefined && typeof value.isExported !== "boolean") return false;
-  return true;
-}
-
-function isTruncatedInfoLike(value: unknown): boolean {
-  if (!isRecord(value)) return false;
-  return (
-    typeof value.totalSymbols === "number"
-    && typeof value.shownSymbols === "number"
-    && typeof value.omittedSymbols === "number"
-  );
-}
-
-const DETAIL_LEVELS = new Set(["full", "compact", "minimal", "outline", "truncated"]);
-
-function isFileMap(value: unknown): value is FileMap {
-  if (!isRecord(value)) return false;
-  if (typeof value.path !== "string") return false;
-  if (typeof value.totalLines !== "number") return false;
-  if (typeof value.totalBytes !== "number") return false;
-  if (typeof value.language !== "string") return false;
-  if (!Array.isArray(value.symbols) || !value.symbols.every(isFileSymbolLike)) return false;
-  if (!isStringArray(value.imports)) return false;
-  if (typeof value.detailLevel !== "string" || !DETAIL_LEVELS.has(value.detailLevel)) return false;
-  if (value.truncatedInfo !== undefined && !isTruncatedInfoLike(value.truncatedInfo)) return false;
-  return true;
-}
-
-/** Read a cached FileMap. Returns null on any failure (missing, corrupt, unreadable). */
-export async function readCached(key: string): Promise<FileMap | null> {
-  if (!persistenceEnabled()) return null;
-
-  try {
-    const raw = await readFile(keyPath(key), "utf-8");
-    const parsed: unknown = JSON.parse(raw);
-    return isFileMap(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-
-async function tryWriteCachedRaw(key: string, map: FileMap): Promise<boolean> {
-  if (!persistenceEnabled()) return false;
-  const dir = resolveCacheDir();
-  const target = join(dir, `${key}.json`);
-  const tmp = join(dir, `${key}.${randomBytes(6).toString("hex")}.tmp`);
-  try {
-    await fsMkdir(dir, { recursive: true });
-    await fsWriteFile(tmp, JSON.stringify(map));
-    await rename(tmp, target);
-    return true;
-  } catch {
-    try {
-      await unlink(tmp);
-    } catch {
-      // ignore temp-file cleanup failures
-    }
-    return false;
-  }
-}
-
-/** Low-level atomic write. Internal helper. */
-async function writeCachedRaw(key: string, map: FileMap): Promise<void> {
-  await tryWriteCachedRaw(key, map);
-}
-
-const EVICTION_INTERVAL = 20;
-const EVICTION_CAP = 5000;
-let writeCounter = 0;
-
-
-const CACHE_KEY_FILE = /^[0-9a-f]{32}\.json$/;
-async function maybeEvict(): Promise<void> {
-  try {
-    const dir = resolveCacheDir();
-    const names = (await readdir(dir)).filter((n) => CACHE_KEY_FILE.test(n));
-    if (names.length <= EVICTION_CAP) return;
-
-    const entries: Array<{ path: string; age: number }> = [];
-    for (const name of names) {
-      const path = join(dir, name);
-      try {
-        const s = await stat(path);
-        const age = (s.atimeMs ?? s.mtimeMs) || 0;
-        entries.push({ path, age });
-      } catch {
-        // ignore individual stat failures
-      }
-    }
-
-    entries.sort((a, b) => a.age - b.age);
-    const excess = entries.length - EVICTION_CAP;
-    for (let i = 0; i < excess; i += 1) {
-      try {
-        await unlink(entries[i].path);
-      } catch {
-        // ignore individual unlink failures
-      }
-    }
-  } catch {
-    // Swallow eviction errors — never propagate.
-  }
-}
-
-/**
- * Public atomic write. Counts successful invocations so eviction can trigger lazily.
- */
-export async function writeCached(key: string, map: FileMap): Promise<void> {
-  if (!(await tryWriteCachedRaw(key, map))) return;
-  writeCounter += 1;
-  if (writeCounter % EVICTION_INTERVAL === 0) {
-    try {
-      await maybeEvict();
-    } catch {
-      // Swallow eviction errors at the call site too.
-    }
-  }
-}
-

package/src/readseek/language-detect.ts

@@ -1,29 +0,0 @@
-import type { LanguageInfo } from "./types.js";
-
-const EXTENSION_LANGUAGE_MAP: Record<string, LanguageInfo> = {
-  ".rs": { id: "rust", name: "Rust" },
-  ".c": { id: "cpp", name: "C" },
-  ".cc": { id: "cpp", name: "C++" },
-  ".cpp": { id: "cpp", name: "C++" },
-  ".cxx": { id: "cpp", name: "C++" },
-  ".hpp": { id: "c-header", name: "C/C++ Header" },
-  ".h": { id: "c-header", name: "C/C++ Header" },
-  ".hxx": { id: "c-header", name: "C/C++ Header" },
-  ".java": { id: "java", name: "Java" },
-};
-
-export function detectLanguage(filePath: string): LanguageInfo | null {
-  const normalized = filePath.toLowerCase();
-  for (const [ext, language] of Object.entries(EXTENSION_LANGUAGE_MAP)) {
-    if (normalized.endsWith(ext)) return language;
-  }
-  return null;
-}
-
-export function isSupported(filePath: string): boolean {
-  return detectLanguage(filePath) !== null;
-}
-
-export function getSupportedExtensions(): string[] {
-  return Object.keys(EXTENSION_LANGUAGE_MAP);
-}