pi-readseek 0.4.25 → 0.4.27

package/src/readseek-client.ts

@@ -118,6 +118,11 @@ export interface ReadSeekTranscript {
 	regions: ReadSeekTranscriptRegion[];
 }
 
+export interface ReadSeekDetectedObject {
+	label: string;
+	bbox: [number, number, number, number];
+}
+
 export type ReadSeekDetection =
 	| {
 			kind: "source";
@@ -139,6 +144,8 @@ export type ReadSeekDetection =
 			height: number;
 			animated: boolean;
 			transcribe?: ReadSeekTranscript;
+			caption?: string;
+			objects?: ReadSeekDetectedObject[];
 		}
 	| {
 			kind: "text";
@@ -155,6 +162,13 @@ interface ReadSeekSearchOptions {
 	signal?: AbortSignal;
 }
 
+interface ReadSeekDetectOptions {
+	transcribe?: boolean;
+	caption?: boolean;
+	objects?: boolean;
+	signal?: AbortSignal;
+}
+
 function normalizeLanguage(language: string): string {
 	return language === "java" ? "Java" : language;
 }
@@ -348,10 +362,11 @@ async function spawnReadSeekRaw(args: string[], options: RunReadSeekOptions = {}
 			});
 			childStdin.end(stdin, "utf-8");
 		}
-		child.on("close", (code) => {
+		child.on("close", (code, signal) => {
 			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, "")));
 		});
 	});
@@ -659,6 +674,21 @@ function parseTranscript(value: unknown): ReadSeekTranscript | undefined {
 	};
 }
 
+function parseDetectedObjects(value: unknown): ReadSeekDetectedObject[] | undefined {
+	if (value === undefined || value === null) return undefined;
+	if (!Array.isArray(value)) throw new Error("invalid readseek detect objects");
+	return value.map((object) => {
+		if (!object || typeof object !== "object") throw new Error("invalid readseek detect object");
+		const item = object as Record<string, unknown>;
+		const bbox = item.bbox;
+		if (!Array.isArray(bbox) || bbox.length !== 4) throw new Error("invalid readseek detect object.bbox");
+		return {
+			label: requireString(item.label, "object.label"),
+			bbox: bbox.map((n, i) => requireNumber(n, `object.bbox[${i}]`)) as ReadSeekDetectedObject["bbox"],
+		};
+	});
+}
+
 function parseDetectOutput(value: unknown): ReadSeekDetection {
 	if (!value || typeof value !== "object") throw new Error("invalid readseek detect output");
 	const output = value as Record<string, unknown>;
@@ -682,6 +712,8 @@ function parseDetectOutput(value: unknown): ReadSeekDetection {
 			height: requireNumber(output.height, "height"),
 			animated: requireBoolean(output.animated, "animated"),
 			transcribe: parseTranscript(output.transcribe),
+			caption: optionalString(output.caption, "caption"),
+			objects: parseDetectedObjects(output.objects),
 		};
 	}
 	if (output.language !== undefined) {
@@ -701,10 +733,279 @@ function parseDetectOutput(value: unknown): ReadSeekDetection {
 
 export async function readseekDetect(
 	filePath: string,
-	options: { transcribe?: boolean; signal?: AbortSignal } = {},
+	options: ReadSeekDetectOptions = {},
 ): Promise<ReadSeekDetection> {
 	const args = ["detect"];
 	if (options.transcribe) args.push("--transcribe");
+	if (options.caption) args.push("--caption");
+	if (options.objects) args.push("--objects");
 	args.push(filePath);
 	return parseDetectOutput(await runReadSeek(args, { signal: options.signal }));
 }
+
+// --- Rename ---
+
+export interface RenameConflict {
+	line: number;
+	column: number;
+	reason: string;
+}
+
+export interface RenameEdit {
+	line: number;
+	start_column: number;
+	end_column: number;
+	start_byte: number;
+	end_byte: number;
+	occurrence: string;
+	line_hash: string;
+	text: string;
+}
+
+export interface RenameFileOutput {
+	file: string;
+	language: string;
+	engine?: string;
+	file_hash: string;
+	conflicts: RenameConflict[];
+	edits: RenameEdit[];
+}
+
+export interface RenameOutput {
+	file: string;
+	language: string;
+	engine?: string;
+	file_hash: string;
+	old_name: string;
+	new_name: string;
+	applied: boolean;
+	conflicts: RenameConflict[];
+	edits: RenameEdit[];
+	others: RenameFileOutput[];
+}
+
+interface RenameOptions {
+	to: string;
+	line: number;
+	column?: number;
+	workspace?: string;
+	apply?: boolean;
+	language?: string;
+	cached?: boolean;
+	others?: boolean;
+	ignored?: boolean;
+	signal?: AbortSignal;
+}
+
+function parseRenameOutput(value: unknown): RenameOutput {
+	if (!value || typeof value !== "object") throw new Error("invalid readseek rename output");
+	const output = value as Record<string, unknown>;
+	return {
+		file: requireString(output.file, "file"),
+		language: requireString(output.language, "language"),
+		engine: optionalString(output.engine, "engine"),
+		file_hash: requireString(output.file_hash, "file_hash"),
+		old_name: requireString(output.old_name, "old_name"),
+		new_name: requireString(output.new_name, "new_name"),
+		applied: requireBoolean(output.applied, "applied"),
+		conflicts: (output.conflicts as any[] | undefined)?.map((c: Record<string, unknown>) => ({
+			line: requireNumber(c.line, "conflict.line"),
+			column: requireNumber(c.column, "conflict.column"),
+			reason: requireString(c.reason, "conflict.reason"),
+		})) ?? [],
+		edits: (output.edits as any[] | undefined)?.map((e: Record<string, unknown>) => ({
+			line: requireNumber(e.line, "edit.line"),
+			start_column: requireNumber(e.start_column, "edit.start_column"),
+			end_column: requireNumber(e.end_column, "edit.end_column"),
+			start_byte: requireNumber(e.start_byte, "edit.start_byte"),
+			end_byte: requireNumber(e.end_byte, "edit.end_byte"),
+			occurrence: requireString(e.occurrence, "edit.occurrence"),
+			line_hash: requireString(e.line_hash, "edit.line_hash"),
+			text: requireString(e.text, "edit.text"),
+		})) ?? [],
+		others: (output.others as any[] | undefined)?.map((o: Record<string, unknown>) => ({
+			file: requireString(o.file, "other.file"),
+			language: requireString(o.language, "other.language"),
+			engine: optionalString(o.engine, "other.engine"),
+			file_hash: requireString(o.file_hash, "other.file_hash"),
+			conflicts: (o.conflicts as any[] | undefined)?.map((c: Record<string, unknown>) => ({
+				line: requireNumber(c.line, "conflict.line"),
+				column: requireNumber(c.column, "conflict.column"),
+				reason: requireString(c.reason, "conflict.reason"),
+			})) ?? [],
+			edits: (o.edits as any[] | undefined)?.map((e: Record<string, unknown>) => ({
+				line: requireNumber(e.line, "edit.line"),
+				start_column: requireNumber(e.start_column, "edit.start_column"),
+				end_column: requireNumber(e.end_column, "edit.end_column"),
+				start_byte: requireNumber(e.start_byte, "edit.start_byte"),
+				end_byte: requireNumber(e.end_byte, "edit.end_byte"),
+				occurrence: requireString(e.occurrence, "edit.occurrence"),
+				line_hash: requireString(e.line_hash, "edit.line_hash"),
+				text: requireString(e.text, "edit.text"),
+			})) ?? [],
+		})) ?? [],
+	};
+}
+
+export async function readseekRename(
+	filePath: string,
+	options: RenameOptions,
+): Promise<RenameOutput> {
+	const args = ["rename", filePath, "--line", String(options.line)];
+	if (options.column !== undefined) args.push("--column", String(options.column));
+	args.push("--to", options.to);
+	if (options.apply) args.push("--apply");
+	if (options.workspace) args.push("--workspace", options.workspace);
+	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");
+	return parseRenameOutput(await runReadSeek(args, { signal: options.signal }));
+}
+
+// --- Identify ---
+
+export interface IdentifierOutput {
+	text: string;
+	start_column: number;
+	end_column: number;
+	start_byte: number;
+	end_byte: number;
+}
+
+export interface IdentifyOutput {
+	file: string;
+	language: string;
+	engine?: string;
+	line_count: number;
+	file_hash: string;
+	line: number;
+	column: number;
+	line_hash: string;
+	identifier?: IdentifierOutput;
+	symbol?: {
+		name: string;
+		kind: string;
+		qualified_name: string;
+		start_line: number;
+		end_line: number;
+	};
+}
+
+interface IdentifyOptions {
+	line?: number;
+	column?: number;
+	language?: string;
+	signal?: AbortSignal;
+}
+
+function parseIdentifyOutput(value: unknown): IdentifyOutput {
+	if (!value || typeof value !== "object") throw new Error("invalid readseek identify output");
+	const output = value as Record<string, unknown>;
+	const identifier = output.identifier;
+	const symbol = output.symbol;
+	return {
+		file: requireString(output.file, "file"),
+		language: requireString(output.language, "language"),
+		engine: optionalString(output.engine, "engine"),
+		line_count: requireNumber(output.line_count, "line_count"),
+		file_hash: requireString(output.file_hash, "file_hash"),
+		line: requireNumber(output.line, "line"),
+		column: requireNumber(output.column, "column"),
+		line_hash: requireString(output.line_hash, "line_hash"),
+		identifier: identifier && typeof identifier === "object"
+			? {
+				text: requireString((identifier as Record<string, unknown>).text, "identifier.text"),
+				start_column: requireNumber((identifier as Record<string, unknown>).start_column, "identifier.start_column"),
+				end_column: requireNumber((identifier as Record<string, unknown>).end_column, "identifier.end_column"),
+				start_byte: requireNumber((identifier as Record<string, unknown>).start_byte, "identifier.start_byte"),
+				end_byte: requireNumber((identifier as Record<string, unknown>).end_byte, "identifier.end_byte"),
+			}
+			: undefined,
+		symbol: symbol && typeof symbol === "object"
+			? {
+				name: requireString((symbol as Record<string, unknown>).name, "symbol.name"),
+				kind: requireString((symbol as Record<string, unknown>).kind, "symbol.kind"),
+				qualified_name: requireString((symbol as Record<string, unknown>).qualified_name, "symbol.qualified_name"),
+				start_line: requireNumber((symbol as Record<string, unknown>).start_line, "symbol.start_line"),
+				end_line: requireNumber((symbol as Record<string, unknown>).end_line, "symbol.end_line"),
+			}
+			: undefined,
+	};
+}
+
+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));
+	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 }));
+}
+
+// --- Def ---
+
+export interface DefLocation {
+	file: string;
+	line: number;
+	column: number;
+	line_hash: string;
+	text: string;
+	kind?: string;
+	name?: string;
+	qualified_name?: string;
+}
+
+interface DefOptions {
+	name?: string;
+	fromIdentify?: boolean;
+	identifyInput?: string;
+	language?: string;
+	cached?: boolean;
+	others?: boolean;
+	ignored?: boolean;
+	signal?: AbortSignal;
+}
+
+function parseDefCompact(value: unknown): DefLocation[] {
+	if (!value || typeof value !== "object") throw new Error("invalid readseek def output");
+	const output = value as Record<string, unknown>;
+	const locations = output.locations;
+	if (!Array.isArray(locations)) throw new Error("invalid readseek def locations");
+	return locations.map((loc) => {
+		if (!loc || typeof loc !== "object") throw new Error("invalid readseek def location");
+		const item = loc as Record<string, unknown>;
+		return {
+			file: requireString(item.file, "location.file"),
+			line: requireNumber(item.line, "location.line"),
+			column: requireNumber(item.column, "location.column"),
+			line_hash: requireString(item.line_hash, "location.line_hash"),
+			text: requireString(item.text, "location.text"),
+			kind: optionalString(item.kind, "location.kind"),
+			name: optionalString(item.name, "location.name"),
+			qualified_name: optionalString(item.qualified_name, "location.qualified_name"),
+		};
+	});
+}
+
+export async function readseekDef(
+	target: string,
+	options: DefOptions = {},
+): Promise<DefLocation[]> {
+	const args = ["def", target, "--format", "plain"];
+	if (options.fromIdentify) {
+		args.push("--from-identify");
+	}
+	if (options.name) {
+		args.push(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 }));
+}

package/src/readseek-settings.ts

@@ -5,6 +5,7 @@ import { join } from "node:path";
 interface ReadSeekJsonSettings {
   grep?: { maxLines?: number; maxBytes?: number };
   edit?: { diffDisplay?: "collapsed" | "expanded" };
+  read?: { ocrMode?: "on" | "off" | "auto" };
 }
 
 interface ReadSeekSettingsWarning {
@@ -75,6 +76,16 @@ function validateSettings(raw: unknown, source: string): ReadSeekSettingsResult
     if (Object.keys(edit).length > 0) settings.edit = edit;
   }
 
+  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"));
+    }
+    if (Object.keys(read).length > 0) settings.read = read;
+  }
+
   return { settings, warnings };
 }
 
@@ -96,6 +107,8 @@ function mergeSettings(base: ReadSeekJsonSettings, override: ReadSeekJsonSetting
   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;
 }
 
@@ -118,3 +131,14 @@ export function resolveEditDiffDisplay(env: NodeJS.ProcessEnv = process.env): "c
   if (json === "expanded" || json === "collapsed") return json;
   return "collapsed";
 }
+
+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";
+}

package/src/rename.ts

@@ -0,0 +1,167 @@
+import type { ExtensionAPI, ToolRenderResultOptions } from "@earendil-works/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import path from "node:path";
+import { Text } from "@earendil-works/pi-tui";
+
+import { defineToolPromptMetadata } from "./tool-prompt-metadata.js";
+import { buildToolErrorResult } from "./readseek-value.js";
+import { resolveToCwd } from "./path-utils.js";
+import { classifyReadSeekFailure, readseekRename, type RenameOutput } from "./readseek-client.js";
+import { filePathParam, registerReadSeekTool } from "./register-tool.js";
+
+import { clampLinesToWidth, linkToolPath, renderPendingResult, resolveRenderResultContext, summaryLine } from "./tui-render-utils.js";
+
+const RENAME_PROMPT_METADATA = defineToolPromptMetadata({
+	promptUrl: new URL("../prompts/rename.md", import.meta.url),
+	promptSnippet: "Rename an identifier with binding-accurate readseek rename",
+});
+
+const renameSchema = Type.Object({
+	path: filePathParam(),
+	line: Type.Number({ description: "One-based cursor line of the binding to rename" }),
+	column: Type.Optional(Type.Number({ description: "One-based cursor byte column of the binding to rename" })),
+	to: Type.String({ description: "New name for the binding" }),
+	workspace: Type.Optional(Type.Boolean({ description: "Expand rename across project root (name-based outside cursor file)" })),
+	apply: Type.Optional(Type.Boolean({ description: "Write the planned edits to disk after verifying line hashes" })),
+});
+
+interface RenameParams {
+	path: string;
+	line: number;
+	column?: number;
+	to: string;
+	workspace?: boolean;
+	apply?: boolean;
+}
+
+export interface ExecuteRenameOptions {
+	params: unknown;
+	signal: AbortSignal | undefined;
+	cwd: string;
+}
+
+export async function executeRename(opts: ExecuteRenameOptions): Promise<any> {
+	const { params, signal, cwd } = opts;
+	const p = params as RenameParams;
+
+	if (!p.to.trim()) {
+		return buildToolErrorResult("rename", "invalid-parameter", "rename parameter 'to' must not be empty");
+	}
+	if (!Number.isSafeInteger(p.line) || p.line < 1) {
+		return buildToolErrorResult("rename", "invalid-parameter", "rename parameter 'line' must be a positive integer");
+	}
+
+	const filePath = resolveToCwd(p.path, cwd);
+
+	try {
+		const output = await readseekRename(filePath, {
+			to: p.to,
+			line: p.line,
+			column: p.column,
+			workspace: p.workspace ? cwd : undefined,
+			apply: p.apply ?? true,
+			signal,
+		});
+
+		const files: string[] = [output.file];
+		for (const other of output.others) {
+			const abs = path.isAbsolute(other.file) ? other.file : path.resolve(cwd, other.file);
+			if (!files.includes(abs)) files.push(abs);
+		}
+
+		const totalEdits = output.edits.length + output.others.reduce((sum, o) => sum + o.edits.length, 0);
+		const totalConflicts = output.conflicts.length + output.others.reduce((sum, o) => sum + o.conflicts.length, 0);
+
+		const parts: string[] = [];
+		if (totalConflicts > 0) {
+			parts.push(`${totalConflicts} naming conflict(s)`);
+		}
+		parts.push(`renamed ${output.old_name} to ${output.new_name} in ${totalEdits} location(s) across ${files.length} file(s)`);
+
+		let text = parts.join("; ");
+		if (output.applied) text += " (applied)";
+		else text += " (dry-run)";
+
+		// Surface first conflict reason for visibility
+		const firstConflict = output.conflicts[0]
+			?? output.others.find((o) => o.conflicts.length > 0)?.conflicts[0];
+		if (firstConflict) {
+			text += `\nFirst conflict at ${firstConflict.line}:${firstConflict.column}: ${firstConflict.reason}`;
+		}
+
+		return {
+			content: [{ type: "text", text }],
+			details: {
+				readseekValue: {
+					tool: "rename",
+					ok: true,
+					path: filePath,
+					output,
+				},
+			},
+		};
+	} catch (err: any) {
+		const failure = classifyReadSeekFailure(err);
+		return buildToolErrorResult("rename", failure.code, failure.message, failure.hint ? { hint: failure.hint } : {});
+	}
+}
+
+export function registerRenameTool(pi: ExtensionAPI) {
+	registerReadSeekTool(pi, {
+		policy: "mutating",
+		pythonName: "rename",
+		defaultExposure: "not-safe-by-default",
+	}, {
+		name: "rename",
+		label: "Rename",
+		description: RENAME_PROMPT_METADATA.description,
+		promptSnippet: RENAME_PROMPT_METADATA.promptSnippet,
+		promptGuidelines: RENAME_PROMPT_METADATA.promptGuidelines,
+		parameters: renameSchema,
+		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+			return executeRename({ params, signal, cwd: ctx.cwd });
+		},
+		renderCall(args: any, theme: any, ...rest: any[]) {
+			const context = rest[0] ?? {};
+			const cwd = context.cwd ?? process.cwd();
+			const displayPath = typeof args?.path === "string" ? args.path : "?";
+			const oldName = typeof args?.to === "string" ? "" : "";
+			let text = theme.fg("toolTitle", theme.bold("rename"));
+			text += ` ${linkToolPath(theme.fg("accent", displayPath), displayPath, cwd)}`;
+			if (args?.to) text += theme.fg("dim", ` → ${args.to}`);
+			return text;
+		},
+		renderResult(result: any, options: ToolRenderResultOptions, theme: any, ...rest: any[]) {
+			const { isPartial, isError, expanded, width } = resolveRenderResultContext(options, rest);
+
+			if (isPartial) return renderPendingResult("pending rename", width);
+
+			const content = result.content?.[0];
+			const textContent = content?.type === "text" ? content.text : "";
+			const readseekValue = (result.details as any)?.readseekValue;
+			const output = readseekValue?.output as RenameOutput | undefined;
+
+			if (isError || result.isError) {
+			return new Text(textContent || "rename failed", 0, 0);
+			}
+
+		let text = summaryLine(
+			output?.applied
+				? `renamed ${output.old_name} → ${output.new_name}`
+				: `rename plan for ${output?.old_name ?? "?"} → ${output?.new_name ?? "?"} (dry-run)`,
+		);
+
+			if (expanded && output) {
+				const files = new Set<string>();
+				files.add(output.file);
+				for (const o of output.others) files.add(o.file);
+				for (const f of files) {
+					text += `\n  ${f}`;
+				}
+			}
+
+			const lines = clampLinesToWidth(text.split("\n"), width);
+			return new Text(lines.join("\n"), 0, 0);
+		},
+	});
+}

package/src/stat-search-path.ts

@@ -2,6 +2,7 @@ import { stat as fsStat } from "node:fs/promises";
 import type { Stats } from "node:fs";
 
 import { buildToolErrorResult, type ToolErrorResult } from "./readseek-value.js";
+import { formatFsError } from "./fs-error.js";
 
 export type StatSearchPathResult =
   | { ok: true; stats: Stats }
@@ -22,13 +23,7 @@ export async function statSearchPathOrError(
   } catch (err: any) {
     const display = rawPath ?? ".";
     const path = rawPath ?? searchPath;
-    if (err?.code === "ENOENT") {
-      return { ok: false, error: buildToolErrorResult(tool, "path-not-found", `Path '${display}' does not exist`, { path }) };
-    }
-    if (err?.code === "EACCES" || err?.code === "EPERM") {
-      return { ok: false, error: buildToolErrorResult(tool, "permission-denied", `Permission denied for path '${display}'`, { path }) };
-    }
-    const message = `Could not access path '${display}': ${err?.message ?? String(err)}`;
-    return { ok: false, error: buildToolErrorResult(tool, "fs-error", message, { path, details: { fsCode: err?.code, fsMessage: err?.message } }) };
+    const { code, message } = formatFsError(err, "stat-error");
+    return { ok: false, error: buildToolErrorResult(tool, code, message, { path }) };
   }
 }

package/src/write.ts

@@ -9,7 +9,7 @@ import { resolveToCwd } from "./path-utils.js";
 import { ensureHashInit, formatHashlineDisplay } from "./hashline.js";
 import { buildReadSeekError, buildReadSeekLine, buildReadSeekWarning, buildToolErrorResult, type ReadSeekLine, type ReadSeekWarning } from "./readseek-value.js";
 import { looksLikeBinary } from "./binary-detect.js";
-import { classifyFsError, type FsErrorCode } from "./fs-error.js";
+import { formatFsError } from "./fs-error.js";
 import { getOrGenerateMap } from "./file-map.js";
 import { formatFileMapWithBudget } from "./readseek/formatter.js";
 
@@ -120,57 +120,12 @@ export interface WriteToolOptions {
   onFileAnchored?: FileAnchoredCallback;
 }
 
-type MappedFsError = {
-  code: FsErrorCode | "fs-error";
-  message: string;
-  hint?: string;
-  includeMeta: boolean;
-};
-
-function mapFsWriteError(err: any, path: string): MappedFsError {
-  const phase: "mkdir" | "write" | undefined = err?.__phase;
-  const fsCode = err?.code as string | undefined;
-
-  if (fsCode === "ENOENT" && phase === "mkdir") {
-    return {
-      code: "fs-error",
-      message: `Cannot create parent directories for ${path}: ${err?.message ?? String(err)}`,
-      includeMeta: true,
-    };
-  }
-  if (fsCode === "ENOSPC") {
-    return {
-      code: "fs-error",
-      message: `No space left on device — cannot write: ${path}`,
-      includeMeta: true,
-    };
-  }
-  if (fsCode === "EROFS") {
-    return {
-      code: "fs-error",
-      message: `Read-only filesystem — cannot write: ${path}`,
-      includeMeta: true,
-    };
-  }
-  const fsError = classifyFsError(err, path);
-  if (fsError) {
-    return { code: fsError.code, message: fsError.message, hint: fsError.hint, includeMeta: false };
-  }
-  return {
-    code: "fs-error",
-    message: `Error writing ${path}: ${err?.message ?? String(err)}`,
-    includeMeta: true,
-  };
-}
-
 function buildWriteFsErrorResult(err: any, absolutePath: string) {
-  const mapped = mapFsWriteError(err, absolutePath);
-  return buildToolErrorResult("write", mapped.code, mapped.message, {
-    path: absolutePath,
-    hint: mapped.hint,
-    extra: { lines: [], warnings: [] },
-    details: mapped.includeMeta ? { fsCode: err?.code, fsMessage: err?.message } : undefined,
-  });
+	const { code, message } = formatFsError(err, "write-error");
+	return buildToolErrorResult("write", code, message, {
+		path: absolutePath,
+		extra: { lines: [], warnings: [] },
+	});
 }
 
 export async function executeWrite(opts: {
@@ -218,21 +173,10 @@ export async function executeWrite(opts: {
   const previousContent = await readPreviousTextForDiff(filePath);
   const existedBeforeWrite = await access(filePath).then(() => true, () => false);
 
-  // Create parent directories
-  try {
-    await mkdir(dirname(filePath), { recursive: true });
-  } catch (err: any) {
-    err.__phase = "mkdir";
-    throw err;
-  }
-  // Write file
-  try {
-    await writeFile(filePath, content, "utf-8");
-  } catch (err: any) {
-    err.__phase = "write";
-    throw err;
-  }
-
+	// Create parent directories
+	await mkdir(dirname(filePath), { recursive: true });
+	// Write file
+	await writeFile(filePath, content, "utf-8");
   // Compute hashlines
   const rawLines = content.split("\n");
   const readseekLines: ReadSeekLine[] = [];