pi-readseek 0.4.30 → 0.5.0

package/src/readseek-client.ts

@@ -7,6 +7,7 @@ import path from "node:path";
 import { DetailLevel } from "./readseek/enums.js";
 import type { FileMap, FileSymbol } from "./readseek/types.js";
 import { SymbolKind } from "./readseek/enums.js";
+import { resolveReadSeekTimeoutMs } from "./readseek-settings.js";
 
 export interface ReadSeekHashline {
 	line: number;
@@ -115,6 +116,8 @@ export interface ReadSeekDetectedObject {
 	bbox: [number, number, number, number];
 }
 
+export type ReadSeekImageMode = "ocr" | "caption" | "objects";
+
 export type ReadSeekDetection =
 	| {
 			kind: "source";
@@ -146,6 +149,8 @@ export type ReadSeekDetection =
 			mime?: string;
 		};
 
+type ReadSeekImageDetection = Extract<ReadSeekDetection, { kind: "image" }>;
+
 interface ReadSeekSearchOptions {
 	language?: string;
 	cached?: boolean;
@@ -154,13 +159,6 @@ interface ReadSeekSearchOptions {
 	signal?: AbortSignal;
 }
 
-interface ReadSeekDetectOptions {
-	ocr?: boolean;
-	caption?: boolean;
-	objects?: boolean;
-	signal?: AbortSignal;
-}
-
 function normalizeLanguage(language: string): string {
 	return language === "java" ? "Java" : language;
 }
@@ -215,36 +213,43 @@ const require = createRequire(import.meta.url);
 const READSEEK_REPO_PACKAGE_NAMES = new Set(["@jarkkojs/readseek", "readseek"]);
 let defaultReadSeekDirInit: Promise<string | null> | undefined;
 
-function readseekPackageDir(): string {
+function readSeekPackageDir(): string {
 	return path.dirname(require.resolve("@jarkkojs/readseek/package.json"));
 }
 
-function readseekBinaryPath(): string {
-	if (process.env.READSEEK_BIN) return process.env.READSEEK_BIN;
+const READSEEK_PLATFORM_PACKAGES: Record<string, string> = {
+	"darwin-arm64": "@jarkkojs/readseek-darwin-arm64",
+	"linux-x64": "@jarkkojs/readseek-linux-x64",
+	"win32-x64": "@jarkkojs/readseek-win32-x64",
+};
 
-	const platformPackage = (() => {
-		switch (process.platform) {
-			case "darwin":
-				return "@jarkkojs/readseek-darwin-arm64";
-			case "linux":
-				return "@jarkkojs/readseek-linux-x64";
-			case "win32":
-				return "@jarkkojs/readseek-win32-x64";
-			default:
-				throw new Error(`unsupported readseek platform: ${process.platform}`);
-		}
-	})();
+function readSeekPlatform(): string {
+	return `${process.platform}-${process.arch}`;
+}
+
+function readSeekBinaryPath(): string {
+	const platform = readSeekPlatform();
+	const platformPackage = READSEEK_PLATFORM_PACKAGES[platform];
+	if (!platformPackage) {
+		const supported = Object.keys(READSEEK_PLATFORM_PACKAGES).join(", ");
+		throw new Error(`@jarkkojs/readseek ships no binary for ${platform}; it supports ${supported}`);
+	}
 
-	const packageJson = require.resolve(`${platformPackage}/package.json`, { paths: [readseekPackageDir()] });
+	const packageJson = require.resolve(`${platformPackage}/package.json`, { paths: [readSeekPackageDir()] });
 	return path.join(path.dirname(packageJson), "bin", process.platform === "win32" ? "readseek.exe" : "readseek");
 }
 
-export function isReadSeekAvailable(): boolean {
+/**
+ * Report whether a readseek binary can be resolved for the running platform,
+ * along with the reason when it cannot. Used to keep the readseek tools out of
+ * the active set on hosts that readseek publishes no binary for.
+ */
+export function readSeekBinaryAvailability(): { available: true } | { available: false; reason: string } {
 	try {
-		readseekBinaryPath();
-		return true;
-	} catch {
-		return false;
+		readSeekBinaryPath();
+		return { available: true };
+	} catch (err) {
+		return { available: false, reason: classifyReadSeekFailure(err).message };
 	}
 }
 
@@ -317,13 +322,18 @@ function defaultReadSeekDir(): string | 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;
+function readSeekTimeoutMs(): number {
+	return resolveReadSeekTimeoutMs() ?? DEFAULT_READSEEK_TIMEOUT_MS;
+}
+
+const READSEEK_USAGE_HINT = /\n\s*Run readseek(?: [\w-]+)* --help for more information\.?\s*$/;
+
+function readSeekErrorMessage(stderr: string): string {
+	return stderr
+		.replace(READSEEK_USAGE_HINT, "")
+		.replace(/^error:\s*/i, "")
+		.replace(/\s*\n\s*/g, " ")
+		.trim();
 }
 
 async function spawnReadSeekRaw(args: string[], options: RunReadSeekOptions = {}): Promise<string> {
@@ -345,8 +355,8 @@ async function spawnReadSeekRaw(args: string[], options: RunReadSeekOptions = {}
 
 		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();
+		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`));
@@ -391,8 +401,8 @@ async function spawnReadSeekRaw(args: string[], options: RunReadSeekOptions = {}
 			const stdout = Buffer.concat(stdoutChunks).toString("utf-8");
 			const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
 			if (code === 0) succeed(stdout);
-			else if (signal) fail(new Error((stderr || `readseek killed by signal ${signal}`).replace(/^error:\s*/i, "")));
-			else fail(new Error((stderr || `readseek exited with status ${code}`).replace(/^error:\s*/i, "")));
+			else if (signal) fail(new Error(readSeekErrorMessage(stderr) || `readseek killed by signal ${signal}`));
+			else fail(new Error(readSeekErrorMessage(stderr) || `readseek exited with status ${code}`));
 		});
 	});
 }
@@ -411,11 +421,11 @@ async function ensureDefaultReadSeekDir(): Promise<string | null> {
 	return defaultReadSeekDirInit;
 }
 
-async function readseekInvocationArgs(args: string[]): Promise<string[]> {
+async function readSeekInvocationArgs(args: string[]): Promise<string[]> {
 	if (isOwnReadSeekRepository()) return args;
 
-	const readseekDir = await ensureDefaultReadSeekDir();
-	return readseekDir ? ["--readseek-dir", readseekDir, ...args] : args;
+	const readSeekDir = await ensureDefaultReadSeekDir();
+	return readSeekDir ? ["--readseek-dir", readSeekDir, ...args] : args;
 }
 
 interface RunReadSeekOptions {
@@ -425,7 +435,7 @@ interface RunReadSeekOptions {
 }
 
 async function runReadSeekRaw(args: string[], options: RunReadSeekOptions = {}): Promise<string> {
-	return spawnReadSeekRaw(await readseekInvocationArgs(args), options);
+	return spawnReadSeekRaw(await readSeekInvocationArgs(args), options);
 }
 
 async function runReadSeek(args: string[], options: RunReadSeekOptions = {}): Promise<unknown> {
@@ -548,14 +558,13 @@ function parseSearchOutput(value: unknown): ReadSeekSearchOutput {
 	};
 }
 
-export async function readseekRead(
+export async function readSeekRead(
 	filePath: string,
 	startLine?: number,
 	endLine?: number,
 	options: { signal?: AbortSignal } = {},
 ): Promise<ReadSeekReadOutput> {
-	const args = ["read", filePath];
-	if (startLine !== undefined) args.push("--start", String(startLine));
+	const args = ["read", startLine === undefined ? filePath : `${filePath}:${startLine}`];
 	if (endLine !== undefined) args.push("--end", String(endLine));
 	return parseReadOutput(await runReadSeek(args, { signal: options.signal }));
 }
@@ -572,7 +581,7 @@ function fileMapFromReadSeekOutput(output: ReadSeekMapOutput, filePath: string,
 	};
 }
 
-export async function readseekMap(
+export async function readSeekMap(
 	filePath: string,
 	totalBytes: number,
 	options: { signal?: AbortSignal } = {},
@@ -581,7 +590,7 @@ export async function readseekMap(
 	return fileMapFromReadSeekOutput(output, filePath, totalBytes);
 }
 
-export async function readseekSearch(
+export async function readSeekSearch(
 	target: string,
 	pattern: string,
 	options: ReadSeekSearchOptions = {},
@@ -594,13 +603,13 @@ export async function readseekSearch(
 	return parseSearchOutput(await runReadSeek(args, { signal: options.signal })).results;
 }
 
-export async function readseekMapContent(
+export async function readSeekMapContent(
 	filePath: string,
 	content: string,
 	options: { signal?: AbortSignal } = {},
 ): Promise<FileMap | null> {
 	const output = parseMapOutput(
-		await runReadSeek(["map", "--stdin", filePath], { signal: options.signal, stdin: content }),
+		await runReadSeek(["map", `stdin:${filePath}`], { signal: options.signal, stdin: content }),
 	);
 	return fileMapFromReadSeekOutput(output, filePath, Buffer.byteLength(content, "utf8"));
 }
@@ -635,7 +644,7 @@ function parseRefsOutput(value: unknown): ReadSeekRefsOutput {
 	};
 }
 
-export async function readseekRefs(
+export async function readSeekRefs(
 	target: string,
 	name: string,
 	options: ReadSeekRefsOptions = {},
@@ -675,13 +684,13 @@ function parseCheckOutput(value: unknown): ReadSeekCheckOutput {
 	};
 }
 
-export async function readseekCheck(
+export async function readSeekCheck(
 	filePath: string,
 	content: string,
 	options: { signal?: AbortSignal } = {},
 ): Promise<ReadSeekCheckOutput> {
 	return parseCheckOutput(
-		await runReadSeek(["check", "--stdin", filePath], { signal: options.signal, stdin: content }),
+		await runReadSeek(["check", `stdin:${filePath}`], { signal: options.signal, stdin: content }),
 	);
 }
 
@@ -746,16 +755,48 @@ function parseDetectOutput(value: unknown): ReadSeekDetection {
 	return { kind: "text", type, file, mime };
 }
 
-export async function readseekDetect(
+export async function readSeekDetect(
 	filePath: string,
-	options: ReadSeekDetectOptions = {},
+	options: { signal?: AbortSignal } = {},
 ): Promise<ReadSeekDetection> {
-	const args = ["detect"];
-	if (options.ocr) args.push("--ocr");
-	if (options.caption) args.push("--caption");
-	if (options.objects) args.push("--objects");
-	args.push(filePath);
-	return parseDetectOutput(await runReadSeek(args, { signal: options.signal }));
+	return parseDetectOutput(await runReadSeek(["detect", filePath], { signal: options.signal }));
+}
+
+/**
+ * Analyze an image with each requested vision mode and merge the payloads into
+ * a single detection. readseek accepts one `--image` mode per invocation, so
+ * modes that fail are dropped as long as at least one produced a payload;
+ * otherwise the first failure is rethrown.
+ */
+export async function readSeekImage(
+	filePath: string,
+	modes: ReadSeekImageMode[],
+	options: { signal?: AbortSignal } = {},
+): Promise<ReadSeekDetection> {
+	const results = await Promise.allSettled(
+		modes.map(async (mode) =>
+			parseDetectOutput(await runReadSeek(["read", "--image", mode, filePath], { signal: options.signal })),
+		),
+	);
+
+	let merged: ReadSeekImageDetection | undefined;
+	for (const result of results) {
+		if (result.status !== "fulfilled" || result.value.kind !== "image") continue;
+		const detection = result.value;
+		merged = merged === undefined
+			? detection
+			: {
+				...merged,
+				ocr: detection.ocr ?? merged.ocr,
+				caption: detection.caption ?? merged.caption,
+				objects: detection.objects ?? merged.objects,
+			};
+	}
+	if (merged !== undefined) return merged;
+
+	const failure = results.find((result) => result.status === "rejected");
+	if (failure?.status === "rejected") throw failure.reason;
+	throw new Error(`readseek returned no image analysis for ${filePath}`);
 }
 
 // --- Rename ---
@@ -875,7 +916,7 @@ function parseRenameOutput(value: unknown): RenameOutput {
 	};
 }
 
-export async function readseekRename(
+export async function readSeekRename(
 	filePath: string,
 	options: RenameOptions,
 ): Promise<RenameOutput> {
@@ -962,13 +1003,13 @@ function parseIdentifyOutput(value: unknown): IdentifyOutput {
 	};
 }
 
-export async function readseekIdentify(
+export async function readSeekIdentify(
 	filePath: string,
 	content: string,
 	options: IdentifyOptions = {},
 ): Promise<IdentifyOutput> {
-	const args = ["identify", "--stdin", filePath];
-	if (options.line !== undefined) args.push("--line", String(options.line));
+	const target = options.line === undefined ? `stdin:${filePath}` : `stdin:${filePath}:${options.line}`;
+	const args = ["identify", target];
 	if (options.column !== undefined) args.push("--column", String(options.column));
 	if (options.language) args.push("--language", options.language);
 	return parseIdentifyOutput(await runReadSeek(args, { signal: options.signal, stdin: content }));
@@ -988,9 +1029,7 @@ export interface DefLocation {
 }
 
 interface DefOptions {
-	name?: string;
-	fromIdentify?: boolean;
-	identifyInput?: string;
+	name: string;
 	language?: string;
 	cached?: boolean;
 	others?: boolean;
@@ -1019,21 +1058,14 @@ function parseDefCompact(value: unknown): DefLocation[] {
 	});
 }
 
-export async function readseekDef(
+export async function readSeekDef(
 	target: string,
-	options: DefOptions = {},
+	options: DefOptions,
 ): Promise<DefLocation[]> {
-	const args = ["def", target, "--format", "plain"];
-	if (options.fromIdentify) {
-		args.push("--from-identify");
-	}
-	if (options.name) {
-		args.push(options.name);
-	}
+	const args = ["def", target, "--format", "plain", options.name];
 	if (options.language) args.push("--language", options.language);
 	if (options.cached) args.push("--cached");
 	if (options.others) args.push("--others");
 	if (options.ignored) args.push("--ignored");
-	const stdin = options.fromIdentify && options.identifyInput ? options.identifyInput : undefined;
-	return parseDefCompact(await runReadSeek(args, { signal: options.signal, stdin }));
+	return parseDefCompact(await runReadSeek(args, { signal: options.signal }));
 }

package/src/readseek-params.ts

@@ -16,7 +16,7 @@ export function langParam() {
  * TypeBox fragment for the Git-scope parameters shared by every readseek
  * search tool. Returns fresh schema instances so each tool spreads its own.
  */
-export function readseekGitSearchParams() {
+export function readSeekGitSearchParams() {
   return {
     cached: Type.Optional(Type.Boolean({ description: "In a Git repository, search tracked/indexed files" })),
     others: Type.Optional(Type.Boolean({ description: "In a Git repository, search untracked files" })),

package/src/readseek-settings.ts

@@ -2,23 +2,35 @@ import { readFileSync, statSync, type Stats } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
+export type ReadSeekOcrMode = "force" | "off" | "auto";
+export type ReadSeekSyntaxValidationMode = "warn" | "block" | "off";
+
+interface ReadSeekGrepSettings {
+  maxLines?: number;
+  maxBytes?: number;
+}
+
 interface ReadSeekJsonSettings {
-  grep?: { maxLines?: number; maxBytes?: number };
-  edit?: { diffDisplay?: "collapsed" | "expanded" };
-  read?: { ocrMode?: "on" | "off" | "auto" };
+  excludeTools?: string[];
+  ocrMode?: ReadSeekOcrMode;
+  syntaxValidation?: ReadSeekSyntaxValidationMode;
+  timeoutMs?: number;
+  grep?: ReadSeekGrepSettings;
 }
 
-interface ReadSeekSettingsWarning {
+export interface ReadSeekSettingsWarning {
   source: string;
   message: string;
   path?: string;
 }
 
-interface ReadSeekSettingsResult {
+export interface ReadSeekSettingsResult {
   settings: ReadSeekJsonSettings;
   warnings: ReadSeekSettingsWarning[];
 }
 
+const READSEEK_KEYS = ["excludeTools", "ocrMode", "syntaxValidation", "timeoutMs", "grep"];
+const READSEEK_GREP_KEYS = ["maxLines", "maxBytes"];
 
 function defaultGlobalSettingsPath(): string {
   return join(homedir(), ".pi/agent/readseek/settings.json");
@@ -36,6 +48,20 @@ function invalid(source: string, path: string): ReadSeekSettingsWarning {
   return { source, path, message: `Invalid readseek setting at ${path}` };
 }
 
+function warnUnknownKeys(
+  raw: Record<string, unknown>,
+  known: string[],
+  prefix: string,
+  source: string,
+  warnings: ReadSeekSettingsWarning[],
+): void {
+  for (const key of Object.keys(raw)) {
+    if (known.includes(key)) continue;
+    const path = `${prefix}.${key}`;
+    warnings.push({ source, path, message: `Unknown readseek setting at ${path}` });
+  }
+}
+
 function readPositive(
   raw: Record<string, unknown>,
   key: string,
@@ -50,40 +76,111 @@ function readPositive(
   return undefined;
 }
 
+function readEnum<T extends string>(
+  raw: Record<string, unknown>,
+  key: string,
+  values: readonly T[],
+  path: string,
+  source: string,
+  warnings: ReadSeekSettingsWarning[],
+): T | undefined {
+  if (!(key in raw)) return undefined;
+  const val = raw[key];
+  if (typeof val === "string" && (values as readonly string[]).includes(val)) return val as T;
+  warnings.push(invalid(source, path));
+  return undefined;
+}
+
+function readOcrMode(
+  raw: Record<string, unknown>,
+  source: string,
+  warnings: ReadSeekSettingsWarning[],
+): ReadSeekOcrMode | undefined {
+  if (!("ocrMode" in raw)) return undefined;
+  const val = raw.ocrMode;
+  if (val === "on") return "force";
+  if (val === "force" || val === "off" || val === "auto") return val;
+  warnings.push(invalid(source, "readseek.ocrMode"));
+  return undefined;
+}
+
+function readStringArray(
+  raw: Record<string, unknown>,
+  key: string,
+  path: string,
+  source: string,
+  warnings: ReadSeekSettingsWarning[],
+): string[] | undefined {
+  if (!(key in raw)) return undefined;
+  const value = raw[key];
+  if (!Array.isArray(value)) {
+    warnings.push(invalid(source, path));
+    return undefined;
+  }
+
+  const strings: string[] = [];
+  value.forEach((item, index) => {
+    if (typeof item !== "string" || item.trim() === "") {
+      warnings.push(invalid(source, `${path}[${index}]`));
+      return;
+    }
+    strings.push(item);
+  });
+  return strings;
+}
 
 function validateSettings(raw: unknown, source: string): ReadSeekSettingsResult {
   const settings: ReadSeekJsonSettings = {};
   const warnings: ReadSeekSettingsWarning[] = [];
-  if (!isRecord(raw)) return { settings, warnings };
-
-  if (isRecord(raw.grep)) {
-    const grep: NonNullable<ReadSeekJsonSettings["grep"]> = {};
-    const maxLines = readPositive(raw.grep, "maxLines", "grep.maxLines", source, warnings);
-    if (maxLines !== undefined) grep.maxLines = maxLines;
-    const maxBytes = readPositive(raw.grep, "maxBytes", "grep.maxBytes", source, warnings);
-    if (maxBytes !== undefined) grep.maxBytes = maxBytes;
-    if (Object.keys(grep).length > 0) settings.grep = grep;
+  if (!isRecord(raw)) {
+    warnings.push({ source, message: "Invalid readseek settings: expected a JSON object" });
+    return { settings, warnings };
   }
-
-
-  if (isRecord(raw.edit)) {
-    const edit: NonNullable<ReadSeekJsonSettings["edit"]> = {};
-    if ("diffDisplay" in raw.edit) {
-      const value = raw.edit.diffDisplay;
-      if (value === "collapsed" || value === "expanded") edit.diffDisplay = value;
-      else warnings.push(invalid(source, "edit.diffDisplay"));
+  if (!("readseek" in raw)) {
+    if (Object.keys(raw).length > 0) {
+      warnings.push({ source, path: "readseek", message: "Missing readseek section: every setting belongs under \"readseek\"" });
     }
-    if (Object.keys(edit).length > 0) settings.edit = edit;
+    return { settings, warnings };
+  }
+  if (!isRecord(raw.readseek)) {
+    warnings.push(invalid(source, "readseek"));
+    return { settings, warnings };
   }
 
-  if (isRecord(raw.read)) {
-    const read: NonNullable<ReadSeekJsonSettings["read"]> = {};
-    if ("ocrMode" in raw.read) {
-      const value = raw.read.ocrMode;
-      if (value === "on" || value === "off" || value === "auto") read.ocrMode = value;
-      else warnings.push(invalid(source, "read.ocrMode"));
+  const section = raw.readseek;
+  warnUnknownKeys(section, READSEEK_KEYS, "readseek", source, warnings);
+
+  const excludeTools = readStringArray(section, "excludeTools", "readseek.excludeTools", source, warnings);
+  if (excludeTools !== undefined) settings.excludeTools = excludeTools;
+
+  const ocrMode = readOcrMode(section, source, warnings);
+  if (ocrMode !== undefined) settings.ocrMode = ocrMode;
+
+  const syntaxValidation = readEnum(
+    section,
+    "syntaxValidation",
+    ["warn", "block", "off"] as const,
+    "readseek.syntaxValidation",
+    source,
+    warnings,
+  );
+  if (syntaxValidation !== undefined) settings.syntaxValidation = syntaxValidation;
+
+  const timeoutMs = readPositive(section, "timeoutMs", "readseek.timeoutMs", source, warnings);
+  if (timeoutMs !== undefined) settings.timeoutMs = timeoutMs;
+
+  if ("grep" in section) {
+    if (isRecord(section.grep)) {
+      warnUnknownKeys(section.grep, READSEEK_GREP_KEYS, "readseek.grep", source, warnings);
+      const grep: ReadSeekGrepSettings = {};
+      const maxLines = readPositive(section.grep, "maxLines", "readseek.grep.maxLines", source, warnings);
+      if (maxLines !== undefined) grep.maxLines = maxLines;
+      const maxBytes = readPositive(section.grep, "maxBytes", "readseek.grep.maxBytes", source, warnings);
+      if (maxBytes !== undefined) grep.maxBytes = maxBytes;
+      if (Object.keys(grep).length > 0) settings.grep = grep;
+    } else {
+      warnings.push(invalid(source, "readseek.grep"));
     }
-    if (Object.keys(read).length > 0) settings.read = read;
   }
 
   return { settings, warnings };
@@ -128,14 +225,10 @@ function readSettingsFile(path: string): ReadSeekSettingsResult {
 }
 
 function mergeSettings(base: ReadSeekJsonSettings, override: ReadSeekJsonSettings): ReadSeekJsonSettings {
-  const merged: ReadSeekJsonSettings = {};
+  const settings: ReadSeekJsonSettings = { ...base, ...override };
   const grep = { ...(base.grep ?? {}), ...(override.grep ?? {}) };
-  if (Object.keys(grep).length > 0) merged.grep = grep;
-  const edit = { ...(base.edit ?? {}), ...(override.edit ?? {}) };
-  if (Object.keys(edit).length > 0) merged.edit = edit;
-  const read = { ...(base.read ?? {}), ...(override.read ?? {}) };
-  if (Object.keys(read).length > 0) merged.read = read;
-  return merged;
+  if (Object.keys(grep).length > 0) settings.grep = grep;
+  return settings;
 }
 
 export function resolveReadSeekJsonSettings(): ReadSeekSettingsResult {
@@ -147,24 +240,14 @@ export function resolveReadSeekJsonSettings(): ReadSeekSettingsResult {
   };
 }
 
-export function resolveEditDiffDisplay(env: NodeJS.ProcessEnv = process.env): "collapsed" | "expanded" {
-  const raw = env.READSEEK_EDIT_DIFF_DISPLAY;
-  if (typeof raw === "string") {
-    const normalized = raw.trim().toLowerCase();
-    if (normalized === "expanded" || normalized === "collapsed") return normalized;
-  }
-  const json = resolveReadSeekJsonSettings().settings.edit?.diffDisplay;
-  if (json === "expanded" || json === "collapsed") return json;
-  return "collapsed";
+export function resolveReadSeekOcrMode(): ReadSeekOcrMode {
+  return resolveReadSeekJsonSettings().settings.ocrMode ?? "force";
 }
 
-export function resolveReadSeekOcrMode(env: NodeJS.ProcessEnv = process.env): "on" | "off" | "auto" {
-  const raw = env.READSEEK_READ_OCR_MODE;
-  if (typeof raw === "string") {
-    const normalized = raw.trim().toLowerCase();
-    if (normalized === "on" || normalized === "off" || normalized === "auto") return normalized;
-  }
-  const json = resolveReadSeekJsonSettings().settings.read?.ocrMode;
-  if (json === "on" || json === "off" || json === "auto") return json;
-  return "on";
+export function resolveReadSeekSyntaxValidation(): ReadSeekSyntaxValidationMode | undefined {
+  return resolveReadSeekJsonSettings().settings.syntaxValidation;
+}
+
+export function resolveReadSeekTimeoutMs(): number | undefined {
+  return resolveReadSeekJsonSettings().settings.timeoutMs;
 }

package/src/readseek-value.ts

@@ -129,16 +129,16 @@ export function buildReadSeekError(
 export interface ToolErrorResult {
   content: [{ type: "text"; text: string }];
   isError: true;
-  details: { readseekValue: Record<string, unknown> };
+  details: { readSeekValue: Record<string, unknown> };
 }
 
 /**
  * Build the standard failure envelope shared by every read-family tool: a text
- * content block plus a `readseekValue` carrying `ok: false` and a
+ * content block plus a `readSeekValue` carrying `ok: false` and a
  * {@link buildReadSeekError} payload.
  *
  * `path` is included only when provided, and `extra` is merged into
- * `readseekValue` so callers can attach tool-specific fields (e.g. write's
+ * `readSeekValue` so callers can attach tool-specific fields (e.g. write's
  * `lines`/`warnings`).
  */
 export function buildToolErrorResult(
@@ -151,7 +151,7 @@ export function buildToolErrorResult(
     content: [{ type: "text", text: message }],
     isError: true,
     details: {
-      readseekValue: {
+      readSeekValue: {
         tool,
         ...(opts.extra ?? {}),
         ok: false,

package/src/refs-output.ts

@@ -17,7 +17,7 @@ interface BuildRefsOutputInput {
 
 interface RefsOutputResult {
   text: string;
-  readseekValue: {
+  readSeekValue: {
     tool: "refs";
     files: Array<{
       path: string;
@@ -30,13 +30,13 @@ export function buildRefsOutput(input: BuildRefsOutputInput): RefsOutputResult {
   if (input.files.length === 0) {
     return {
       text: `No references found for: ${input.name}`,
-      readseekValue: { tool: "refs", files: [] },
+      readSeekValue: { tool: "refs", files: [] },
     };
   }
 
   return {
     text: formatAnchoredFileBlocks(input.files, (line) => (line.enclosingSymbol ? ` (in ${line.enclosingSymbol})` : "")),
-    readseekValue: {
+    readSeekValue: {
       tool: "refs",
       files: input.files.map((file) => ({
         path: file.path,