pi-readseek 0.4.30 → 0.5.1

package/src/read.ts

@@ -26,16 +26,16 @@ import { buildReadOutput } from "./read-output.js";
 
 import { buildLocalBundle } from "./read-local-bundle.js";
 import { coerceObviousBase10Int } from "./coerce-obvious-int.js";
-import { readseekRead, readseekDetect, type ReadSeekDetection } from "./readseek-client.js";
+import { readSeekRead, readSeekDetect, readSeekImage, type ReadSeekDetection } from "./readseek-client.js";
 import { formatReadCallText, formatReadResultText } from "./read-render-helpers.js";
-import { resolveReadSeekOcrMode } from "./readseek-settings.js";
+import { resolveReadSeekImageMode } from "./readseek-settings.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";
 
 const READ_PROMPT_METADATA = defineToolPromptMetadata({
 	promptUrl: new URL("../prompts/read.md", import.meta.url),
-	promptSnippet: "Read text files or images; text reads include hashline anchors and optional maps/symbol lookup, image reads include the attachment plus OCR text",
+	promptSnippet: "Read text files or images; text reads include hashline anchors and optional maps/symbol lookup, image reads include the attachment plus OCR text, an image caption, and detected objects",
 });
 
 interface ReadParams {
@@ -58,16 +58,16 @@ export interface ExecuteReadOptions {
 	onUpdate: any;
 	cwd: string;
 	onSuccessfulRead?: FileAnchoredCallback;
-	/** Whether the active model accepts image input natively. Used when OCR mode is auto. */
+	/** Whether the active model accepts image input natively. Used when imageMode is auto. */
 	modelSupportsImages?: boolean;
 }
 
 function hasReadAnchors(result: AgentToolResult<any>): boolean {
 	const details = (result as { details?: unknown }).details;
 	if (!details || typeof details !== "object") return false;
-	const readseekValue = (details as { readseekValue?: unknown }).readseekValue;
-	if (!readseekValue || typeof readseekValue !== "object") return false;
-	const lines = (readseekValue as { lines?: unknown }).lines;
+	const readSeekValue = (details as { readSeekValue?: unknown }).readSeekValue;
+	if (!readSeekValue || typeof readSeekValue !== "object") return false;
+	const lines = (readSeekValue as { lines?: unknown }).lines;
 	return Array.isArray(lines) && lines.length > 0;
 }
 
@@ -171,24 +171,18 @@ export async function executeRead(opts: ExecuteReadOptions): Promise<AgentToolRe
 	if (hasBinaryContent) {
 		let detection: ReadSeekDetection | undefined;
 		try {
-			detection = await readseekDetect(absolutePath, { signal });
+			detection = await readSeekDetect(absolutePath, { signal });
 		} catch {
 		}
 		if (detection?.kind === "image") {
 			const builtinRead = createReadTool(cwd);
 			const builtinResult = await builtinRead.execute(toolCallId, p, signal, onUpdate);
-			const ocrMode = resolveReadSeekOcrMode();
-			const shouldRunVision = ocrMode === "on" || (ocrMode === "auto" && !opts.modelSupportsImages);
+			const imageMode = resolveReadSeekImageMode();
+			const shouldRunVision = imageMode === "force" || (imageMode === "auto" && !opts.modelSupportsImages);
 			if (!shouldRunVision) return succeed(builtinResult);
 
-			let ocrFailed = false;
 			try {
-				const ocrDetection = await readseekDetect(absolutePath, {
-					ocr: true,
-					caption: true,
-					objects: true,
-					signal,
-				});
+				const ocrDetection = await readSeekImage(absolutePath, ["ocr", "caption", "objects"], { signal });
 				const imageAnalysis = formatImageAnalysis(ocrDetection);
 				if (imageAnalysis) {
 					return succeed({
@@ -200,14 +194,11 @@ export async function executeRead(opts: ExecuteReadOptions): Promise<AgentToolRe
 					});
 				}
 			} catch {
-				ocrFailed = true;
-			}
-			if (ocrFailed) {
 				return succeed({
 					...builtinResult,
 					content: [
 						...(builtinResult.content ?? []),
-						{ type: "text" as const, text: "[Warning: local image analysis (OCR) unavailable — showing image attachment only]" },
+						{ type: "text" as const, text: "[Warning: local image analysis unavailable — showing image attachment only]" },
 					],
 				});
 			}
@@ -356,33 +347,33 @@ export async function executeRead(opts: ExecuteReadOptions): Promise<AgentToolRe
 	}
 
 	throwIfAborted(signal);
-	let readseekOutput: Awaited<ReturnType<typeof readseekRead>>;
+	let readSeekOutput: Awaited<ReturnType<typeof readSeekRead>>;
 	try {
-		readseekOutput = total === 0
-			? await readseekRead(absolutePath, undefined, undefined, { signal })
-			: await readseekRead(absolutePath, startLine, endIdx, { signal });
+		readSeekOutput = total === 0
+			? await readSeekRead(absolutePath, undefined, undefined, { signal })
+			: await readSeekRead(absolutePath, startLine, endIdx, { signal });
 	} catch (err: any) {
 		const detail = err?.message ? ` — ${err.message}` : "";
 		const message = `readseek failed while reading ${rawPath}${detail}`;
 		return buildToolErrorResult("read", "readseek-error", message, { path: rawParams.path, hint: "Ensure @jarkkojs/readseek and its npm platform package are installed.", details: { message: err?.message } });
 	}
 	const expectedLineCount = Math.max(0, endIdx - startLine + 1);
-	const invalidLine = readseekOutput.hashlines.find((line, index) => line.line !== startLine + index);
-	if (readseekOutput.hashlines.length !== expectedLineCount || invalidLine) {
+	const invalidLine = readSeekOutput.hashlines.find((line, index) => line.line !== startLine + index);
+	if (readSeekOutput.hashlines.length !== expectedLineCount || invalidLine) {
 		const message = invalidLine
 			? `readseek returned non-sequential line ${invalidLine.line} for requested range ${startLine}-${endIdx}`
-			: `readseek returned ${readseekOutput.hashlines.length} lines for requested range ${startLine}-${endIdx} (${expectedLineCount} expected)`;
+			: `readseek returned ${readSeekOutput.hashlines.length} lines for requested range ${startLine}-${endIdx} (${expectedLineCount} expected)`;
 		return buildToolErrorResult("read", "readseek-output-mismatch", message, { path: rawParams.path });
 	}
-	const readseekLines: ReadSeekLine[] = readseekOutput.hashlines.map((line) => ({
+	const readSeekLines: ReadSeekLine[] = readSeekOutput.hashlines.map((line) => ({
 		line: line.line,
 		hash: line.hash,
 		anchor: `${line.line}:${line.hash}`,
 		raw: line.text,
 		display: escapeControlCharsForDisplay(line.text),
 	}));
-	const selected = readseekLines.map((line) => line.raw);
-	const formatted = renderReadSeekLines(readseekLines);
+	const selected = readSeekLines.map((line) => line.raw);
+	const formatted = renderReadSeekLines(readSeekLines);
 
 	const truncation = truncateHead(formatted, { maxLines: DEFAULT_MAX_LINES, maxBytes: DEFAULT_MAX_BYTES });
 
@@ -423,7 +414,7 @@ export async function executeRead(opts: ExecuteReadOptions): Promise<AgentToolRe
 		endLine: endIdx,
 		totalLines: total,
 		selectedLines: selected,
-		lines: readseekLines,
+		lines: readSeekLines,
 		warnings: structuredWarnings,
 		truncation: truncation.truncated
 			? {
@@ -456,7 +447,7 @@ export async function executeRead(opts: ExecuteReadOptions): Promise<AgentToolRe
 		content: [{ type: "text", text: readOutput.text }],
 		details: {
 			truncation: truncation.truncated ? truncation : undefined,
-			readseekValue: readOutput.readseekValue,
+			readSeekValue: readOutput.readSeekValue,
 		},
 	});
 }
@@ -469,11 +460,7 @@ function splitReadSeekLines(text: string): string[] {
 
 export function registerReadTool(pi: ExtensionAPI, options: ReadToolOptions = {}) {
 	const tool = registerReadSeekTool(pi, {
-		policy: "read-only",
-		pythonName: "read",
-		defaultExposure: "safe-by-default",
-	}, {
-		name: "read",
+		name: "readSeek_read",
 		label: "Read",
 		description: READ_PROMPT_METADATA.description,
 		promptSnippet: READ_PROMPT_METADATA.promptSnippet,
@@ -529,16 +516,16 @@ export function registerReadTool(pi: ExtensionAPI, options: ReadToolOptions = {}
 				return new Text(clampLinesToWidth([summaryLine(errorText)], width).join("\n"), 0, 0);
 			}
 
-			const readseekValue = (result.details as any)?.readseekValue as { range: { startLine: number; endLine: number; totalLines: number }; truncation: any; symbol: any; map: any; warnings: ReadSeekWarning[] } | undefined;
-			if (!readseekValue) {
+			const readSeekValue = (result.details as any)?.readSeekValue as { range: { startLine: number; endLine: number; totalLines: number }; truncation: any; symbol: any; map: any; warnings: ReadSeekWarning[] } | undefined;
+			if (!readSeekValue) {
 				const lines = textContent.split("\n").filter(Boolean).length || textContent.split("\n").length;
 				return new Text(summaryLine(`loaded ${lines} ${lines === 1 ? "line" : "lines"}`, { hidden: !!textContent && !expanded }), 0, 0);
 			}
 
-			const info = formatReadResultText({ range: readseekValue.range, truncation: readseekValue.truncation, symbol: readseekValue.symbol, map: readseekValue.map, warnings: readseekValue.warnings });
-			const visibleLines = info.truncated && readseekValue.truncation ? readseekValue.truncation.outputLines : readseekValue.range.endLine - readseekValue.range.startLine + 1;
+			const info = formatReadResultText({ range: readSeekValue.range, truncation: readSeekValue.truncation, symbol: readSeekValue.symbol, map: readSeekValue.map, warnings: readSeekValue.warnings });
+			const visibleLines = info.truncated && readSeekValue.truncation ? readSeekValue.truncation.outputLines : readSeekValue.range.endLine - readSeekValue.range.startLine + 1;
 			const loadedWord = visibleLines === 1 ? "line" : "lines";
-			const summaryParts: string[] = [info.truncated ? `loaded ${visibleLines} of ${readseekValue.truncation?.totalLines ?? readseekValue.range.totalLines} ${loadedWord} (truncated)` : `loaded ${visibleLines} ${loadedWord}`];
+			const summaryParts: string[] = [info.truncated ? `loaded ${visibleLines} of ${readSeekValue.truncation?.totalLines ?? readSeekValue.range.totalLines} ${loadedWord} (truncated)` : `loaded ${visibleLines} ${loadedWord}`];
 			if (info.symbolBadge) summaryParts.push(info.symbolBadge);
 			for (const badge of info.badges) summaryParts.push(badge);
 			const summary = summaryParts.join(" • ");

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" })),