@nghyane/arcane 0.1.12 → 0.1.14

package/src/patch/index.ts

@@ -8,48 +8,6 @@
  *
  * The mode is determined by the `edit.mode` setting.
  */
-import * as fs from "node:fs/promises";
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@nghyane/arcane-agent";
-import { StringEnum } from "@nghyane/arcane-ai";
-import { type Static, Type } from "@sinclair/typebox";
-import { renderPromptTemplate } from "../config/prompt-templates";
-import {
-	createLspWritethrough,
-	type FileDiagnosticsResult,
-	flushLspWritethroughBatch,
-	type WritethroughCallback,
-	writethroughNoop,
-} from "../lsp";
-import hashlineDescription from "../prompts/tools/hashline.md" with { type: "text" };
-import patchDescription from "../prompts/tools/patch.md" with { type: "text" };
-import replaceDescription from "../prompts/tools/replace.md" with { type: "text" };
-import type { ToolSession } from "../tools";
-import {
-	invalidateFsScanAfterDelete,
-	invalidateFsScanAfterRename,
-	invalidateFsScanAfterWrite,
-} from "../tools/fs-cache-invalidation";
-import { outputMeta } from "../tools/output-meta";
-import { resolveToCwd } from "../tools/path-utils";
-import { saveForUndo } from "../tools/undo-history";
-import { applyPatch } from "./applicator";
-import { generateDiffString, generateUnifiedDiffString, replaceText } from "./diff";
-import { findMatch } from "./fuzzy";
-import {
-	applyHashlineEdits,
-	computeLineHash,
-	type HashlineEdit,
-	type LineTag,
-	parseTag,
-	type ReplaceTextEdit,
-} from "./hashline";
-import { detectLineEnding, normalizeToLF, restoreLineEndings, stripBom } from "./normalize";
-import { buildNormativeUpdateInput } from "./normative";
-import { type EditToolDetails, getLspBatchRequest } from "./shared";
-// Internal imports
-import type { FileSystem, Operation, PatchInput } from "./types";
-import { EditMatchError } from "./types";
-
 // ═══════════════════════════════════════════════════════════════════════════
 // Re-exports
 // ═══════════════════════════════════════════════════════════════════════════
@@ -65,9 +23,16 @@ export {
 	generateUnifiedDiffString,
 	replaceText,
 } from "./diff";
-
+// Edit tool
+export { EditTool } from "./edit-tool";
 // Fuzzy matching
-export { DEFAULT_FUZZY_THRESHOLD, findContextLine, findMatch as findEditMatch, findMatch, seekSequence } from "./fuzzy";
+export {
+	DEFAULT_FUZZY_THRESHOLD,
+	findContextLine,
+	findMatch as findEditMatch,
+	findMatch,
+	seekSequence,
+} from "./fuzzy";
 // Hashline
 export {
 	applyHashlineEdits,
@@ -80,12 +45,32 @@ export {
 	validateLineRef,
 } from "./hashline";
 // Normalization
-export { adjustIndentation, detectLineEnding, normalizeToLF, restoreLineEndings, stripBom } from "./normalize";
+export {
+	adjustIndentation,
+	detectLineEnding,
+	normalizeToLF,
+	restoreLineEndings,
+	stripBom,
+} from "./normalize";
 // Parsing
-export { normalizeCreateContent, normalizeDiff, parseHunks as parseDiffHunks } from "./parser";
+export {
+	normalizeCreateContent,
+	normalizeDiff,
+	parseHunks as parseDiffHunks,
+} from "./parser";
+// Schemas & types
+export {
+	DEFAULT_EDIT_MODE,
+	type EditMode,
+	type HashlineParams,
+	type HashlineToolEdit,
+	normalizeEditMode,
+	type PatchParams,
+	type ReplaceParams,
+} from "./schemas";
 export type { EditRenderContext, EditToolDetails } from "./shared";
 // Rendering
-export { editToolRenderer, getLspBatchRequest } from "./shared";
+export { getLspBatchRequest } from "./shared";
 export type {
 	ApplyPatchOptions,
 	ApplyPatchResult,
@@ -111,854 +96,3 @@ export type {
 // Types
 // Legacy aliases for backwards compatibility
 export { ApplyPatchError, EditMatchError, ParseError } from "./types";
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Schemas
-// ═══════════════════════════════════════════════════════════════════════════
-
-const replaceEditSchema = Type.Object({
-	path: Type.String({ description: "File path (relative or absolute)" }),
-	old_text: Type.String({ description: "Text to find (fuzzy whitespace matching enabled)" }),
-	new_text: Type.String({ description: "Replacement text" }),
-	all: Type.Optional(Type.Boolean({ description: "Replace all occurrences (default: unique match required)" })),
-});
-
-const patchEditSchema = Type.Object({
-	path: Type.String({ description: "File path" }),
-	op: Type.Optional(
-		StringEnum(["create", "delete", "update"], {
-			description: "Operation (default: update)",
-		}),
-	),
-	rename: Type.Optional(Type.String({ description: "New path for move" })),
-	diff: Type.Optional(Type.String({ description: "Diff hunks (update) or full content (create)" })),
-});
-
-export type ReplaceParams = Static<typeof replaceEditSchema>;
-export type PatchParams = Static<typeof patchEditSchema>;
-
-/** Pattern matching hashline display format: `LINE#ID:CONTENT` */
-const HASHLINE_PREFIX_RE = /^\s*(?:>>>|>>)?\s*\d+#[0-9a-zA-Z]{1,16}:/;
-
-/** Pattern matching a unified-diff `+` prefix (but not `++`) */
-const DIFF_PLUS_RE = /^[+-](?![+-])/;
-
-/**
- * Strip hashline display prefixes and diff `+` markers from replacement lines.
- *
- * Models frequently copy the `LINE#ID  ` prefix from read output into their
- * replacement content, or include unified-diff `+` prefixes. Both corrupt the
- * output file. This strips them heuristically before application.
- */
-function stripNewLinePrefixes(lines: string[]): string[] {
-	// Detect whether the *majority* of non-empty lines carry a prefix —
-	// if only one line out of many has a match it's likely real content.
-	let hashPrefixCount = 0;
-	let diffPlusCount = 0;
-	let nonEmpty = 0;
-	for (const l of lines) {
-		if (l.length === 0) continue;
-		nonEmpty++;
-		if (HASHLINE_PREFIX_RE.test(l)) hashPrefixCount++;
-		if (DIFF_PLUS_RE.test(l)) diffPlusCount++;
-	}
-	if (nonEmpty === 0) return lines;
-
-	const stripHash = hashPrefixCount > 0 && hashPrefixCount >= nonEmpty * 0.5;
-	const stripPlus = !stripHash && nonEmpty >= 2 && diffPlusCount > 0 && diffPlusCount >= nonEmpty * 0.5;
-
-	if (!stripHash && !stripPlus) return lines;
-
-	return lines.map(l => {
-		if (stripHash) return l.replace(HASHLINE_PREFIX_RE, "");
-		if (stripPlus) return l.replace(DIFF_PLUS_RE, "");
-		return l;
-	});
-}
-
-const hashlineReplaceContentFormat = (kind: string) =>
-	Type.Union([
-		Type.Null(),
-		Type.Array(Type.String(), { description: `${kind} lines` }),
-		Type.String({ description: `${kind} line` }),
-	]);
-
-const hashlineInsertContentFormat = (kind: string) =>
-	Type.Union([
-		Type.Array(Type.String(), { description: `${kind} lines`, minItems: 1 }),
-		Type.String({ description: `${kind} line`, minLength: 1 }),
-	]);
-
-const hashlineTagFormat = (what: string) =>
-	Type.String({
-		description: `Tag identifying the ${what} — format "N#XX" (e.g. "5#PM"), copied verbatim from read output`,
-	});
-
-function hashlineParseContent(edit: string | string[] | null): string[] {
-	if (edit === null) return [];
-	if (Array.isArray(edit)) return edit;
-	const lines = stripNewLinePrefixes(edit.split("\n"));
-	if (lines.length === 0) return [];
-	if (lines.length > 1 && lines[lines.length - 1].trim() === "") return lines.slice(0, -1);
-	return lines;
-}
-
-function hashlineParseContentString(edit: string | string[] | null): string {
-	if (edit === null) return "";
-	if (Array.isArray(edit)) return edit.join("\n");
-	return edit;
-}
-
-const hashlineTargetEditSchema = Type.Object(
-	{
-		op: Type.Literal("set"),
-		tag: hashlineTagFormat("line being replaced"),
-		content: hashlineReplaceContentFormat("Replacement"),
-	},
-	{ additionalProperties: false },
-);
-
-const hashlineAppendEditSchema = Type.Object(
-	{
-		op: Type.Literal("append"),
-		after: Type.Optional(hashlineTagFormat("line after which to append")),
-		content: hashlineInsertContentFormat("Appended"),
-	},
-	{ additionalProperties: false },
-);
-
-const hashlinePrependEditSchema = Type.Object(
-	{
-		op: Type.Literal("prepend"),
-		before: Type.Optional(hashlineTagFormat("line before which to prepend")),
-		content: hashlineInsertContentFormat("Prepended"),
-	},
-	{ additionalProperties: false },
-);
-
-const hashlineRangeEditSchema = Type.Object(
-	{
-		op: Type.Literal("replace"),
-		first: hashlineTagFormat("first line"),
-		last: hashlineTagFormat("last line"),
-		content: hashlineReplaceContentFormat("Replacement"),
-	},
-	{ additionalProperties: false },
-);
-
-const hashlineInsertEditSchema = Type.Object(
-	{
-		op: Type.Literal("insert"),
-		before: Type.Optional(hashlineTagFormat("line before which to insert")),
-		after: Type.Optional(hashlineTagFormat("line after which to insert")),
-		content: hashlineInsertContentFormat("Inserted"),
-	},
-	{ additionalProperties: false },
-);
-
-const hashlineReplaceTextEditSchema = Type.Object(
-	{
-		op: Type.Literal("replaceText"),
-		old_text: Type.String({ description: "Text to find", minLength: 1 }),
-		new_text: hashlineReplaceContentFormat("Replacement"),
-		all: Type.Optional(Type.Boolean({ description: "Replace all occurrences" })),
-	},
-	{ additionalProperties: false },
-);
-
-const HL_REPLACE_ENABLED = Bun.env.ARCANE_HL_REPLACETXT === "1";
-
-const hashlineEditSpecSchema = Type.Union([
-	hashlineTargetEditSchema,
-	hashlineRangeEditSchema,
-	hashlineAppendEditSchema,
-	hashlinePrependEditSchema,
-	hashlineInsertEditSchema,
-	...(HL_REPLACE_ENABLED ? [hashlineReplaceTextEditSchema] : []),
-]);
-
-const hashlineEditSchema = Type.Object(
-	{
-		path: Type.String({ description: "File path (relative or absolute)" }),
-		edits: Type.Array(hashlineEditSpecSchema, {
-			description: "Changes to apply to the file at `path`",
-			minItems: 0,
-		}),
-		delete: Type.Optional(Type.Boolean({ description: "Delete the file when true" })),
-		rename: Type.Optional(Type.String({ description: "New path if moving" })),
-	},
-	{ additionalProperties: false },
-);
-
-export type HashlineToolEdit = Static<typeof hashlineEditSpecSchema>;
-export type HashlineParams = Static<typeof hashlineEditSchema>;
-
-// ═══════════════════════════════════════════════════════════════════════════
-// LSP FileSystem for patch mode
-// ═══════════════════════════════════════════════════════════════════════════
-
-class LspFileSystem implements FileSystem {
-	#lastDiagnostics: FileDiagnosticsResult | undefined;
-	#fileCache: Record<string, Bun.BunFile> = {};
-
-	constructor(
-		private readonly writethrough: (
-			dst: string,
-			content: string,
-			signal?: AbortSignal,
-			file?: import("bun").BunFile,
-			batch?: { id: string; flush: boolean },
-		) => Promise<FileDiagnosticsResult | undefined>,
-		private readonly signal?: AbortSignal,
-		private readonly batchRequest?: { id: string; flush: boolean },
-	) {}
-
-	#getFile(path: string): Bun.BunFile {
-		if (this.#fileCache[path]) {
-			return this.#fileCache[path];
-		}
-		const file = Bun.file(path);
-		this.#fileCache[path] = file;
-		return file;
-	}
-
-	async exists(path: string): Promise<boolean> {
-		return this.#getFile(path).exists();
-	}
-
-	async read(path: string): Promise<string> {
-		return this.#getFile(path).text();
-	}
-
-	async readBinary(path: string): Promise<Uint8Array> {
-		const buffer = await this.#getFile(path).arrayBuffer();
-		return new Uint8Array(buffer);
-	}
-
-	async write(path: string, content: string): Promise<void> {
-		const file = this.#getFile(path);
-		const result = await this.writethrough(path, content, this.signal, file, this.batchRequest);
-		if (result) {
-			this.#lastDiagnostics = result;
-		}
-	}
-
-	async delete(path: string): Promise<void> {
-		await this.#getFile(path).unlink();
-	}
-
-	async mkdir(path: string): Promise<void> {
-		await fs.mkdir(path, { recursive: true });
-	}
-
-	getDiagnostics(): FileDiagnosticsResult | undefined {
-		return this.#lastDiagnostics;
-	}
-}
-
-function mergeDiagnosticsWithWarnings(
-	diagnostics: FileDiagnosticsResult | undefined,
-	warnings: string[],
-): FileDiagnosticsResult | undefined {
-	if (warnings.length === 0) return diagnostics;
-	const warningMessages = warnings.map(warning => `patch: ${warning}`);
-	if (!diagnostics) {
-		return {
-			server: "patch",
-			messages: warningMessages,
-			summary: `Patch warnings: ${warnings.length}`,
-			errored: false,
-		};
-	}
-	return {
-		...diagnostics,
-		messages: [...warningMessages, ...diagnostics.messages],
-		summary: `${diagnostics.summary}; Patch warnings: ${warnings.length}`,
-	};
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Tool Class
-// ═══════════════════════════════════════════════════════════════════════════
-
-type TInput = typeof replaceEditSchema | typeof patchEditSchema | typeof hashlineEditSchema;
-
-export type EditMode = "replace" | "patch" | "hashline";
-
-export const DEFAULT_EDIT_MODE: EditMode = "patch";
-
-export function normalizeEditMode(mode?: string | null): EditMode | null {
-	switch (mode) {
-		case "replace":
-			return "replace";
-		case "patch":
-			return "patch";
-		case "hashline":
-			return "hashline";
-		default:
-			return null;
-	}
-}
-
-/**
- * Edit tool implementation.
- *
- * Creates replace-mode, patch-mode, or hashline-mode behavior based on session settings.
- */
-export class EditTool implements AgentTool<TInput> {
-	readonly name = "edit";
-	readonly label = "Edit";
-	readonly nonAbortable = true;
-	readonly concurrency = "exclusive";
-
-	readonly #allowFuzzy: boolean;
-	readonly #fuzzyThreshold: number;
-	readonly #writethrough: WritethroughCallback;
-	readonly #editMode?: EditMode | null;
-
-	constructor(private readonly session: ToolSession) {
-		const {
-			ARCANE_EDIT_FUZZY: editFuzzy = "auto",
-			ARCANE_EDIT_FUZZY_THRESHOLD: editFuzzyThreshold = "auto",
-			ARCANE_EDIT_VARIANT: envEditVariant = "auto",
-		} = Bun.env;
-
-		if (envEditVariant && envEditVariant !== "auto") {
-			const editMode = normalizeEditMode(envEditVariant);
-			if (!editMode) {
-				throw new Error(`Invalid ARCANE_EDIT_VARIANT: ${envEditVariant}`);
-			}
-			this.#editMode = editMode;
-		}
-
-		switch (editFuzzy) {
-			case "true":
-			case "1":
-				this.#allowFuzzy = true;
-				break;
-			case "false":
-			case "0":
-				this.#allowFuzzy = false;
-				break;
-			case "auto":
-				this.#allowFuzzy = session.settings.get("edit.fuzzyMatch");
-				break;
-			default:
-				throw new Error(`Invalid ARCANE_EDIT_FUZZY: ${editFuzzy}`);
-		}
-		switch (editFuzzyThreshold) {
-			case "auto":
-				this.#fuzzyThreshold = session.settings.get("edit.fuzzyThreshold");
-				break;
-			default:
-				this.#fuzzyThreshold = parseFloat(editFuzzyThreshold);
-				if (Number.isNaN(this.#fuzzyThreshold) || this.#fuzzyThreshold < 0 || this.#fuzzyThreshold > 1) {
-					throw new Error(`Invalid ARCANE_EDIT_FUZZY_THRESHOLD: ${editFuzzyThreshold}`);
-				}
-				break;
-		}
-
-		const enableLsp = session.enableLsp ?? true;
-		const enableDiagnostics = enableLsp && session.settings.get("lsp.diagnosticsOnEdit");
-		const enableFormat = enableLsp && session.settings.get("lsp.formatOnWrite");
-		this.#writethrough = enableLsp
-			? createLspWritethrough(session.cwd, { enableFormat, enableDiagnostics })
-			: writethroughNoop;
-	}
-
-	/**
-	 * Determine edit mode dynamically based on current model.
-	 * This is re-evaluated on each access so tool definitions stay current when model changes.
-	 */
-	get mode(): EditMode {
-		if (this.#editMode) return this.#editMode;
-		const activeModel = this.session.getActiveModelString?.();
-		const editVariant =
-			this.session.settings.getEditVariantForModel(activeModel) ??
-			normalizeEditMode(this.session.settings.get("edit.mode"));
-		return editVariant ?? DEFAULT_EDIT_MODE;
-	}
-
-	/**
-	 * Dynamic description based on current edit mode (which depends on current model).
-	 */
-	get description(): string {
-		switch (this.mode) {
-			case "patch":
-				return renderPromptTemplate(patchDescription);
-			case "hashline":
-				return renderPromptTemplate(hashlineDescription, { allowReplaceText: HL_REPLACE_ENABLED });
-			default:
-				return renderPromptTemplate(replaceDescription);
-		}
-	}
-
-	/**
-	 * Dynamic parameters schema based on current edit mode (which depends on current model).
-	 */
-	get parameters(): TInput {
-		switch (this.mode) {
-			case "patch":
-				return patchEditSchema;
-			case "hashline":
-				return hashlineEditSchema;
-			default:
-				return replaceEditSchema;
-		}
-	}
-
-	async execute(
-		_toolCallId: string,
-		params: ReplaceParams | PatchParams | HashlineParams,
-		signal?: AbortSignal,
-		_onUpdate?: AgentToolUpdateCallback<EditToolDetails, TInput>,
-		context?: AgentToolContext,
-	): Promise<AgentToolResult<EditToolDetails, TInput>> {
-		const batchRequest = getLspBatchRequest(context?.toolCall);
-
-		// ─────────────────────────────────────────────────────────────────
-		// Hashline mode execution
-		// ─────────────────────────────────────────────────────────────────
-		if (this.mode === "hashline") {
-			const { path, edits, delete: deleteFile, rename } = params as HashlineParams;
-
-			if (path.endsWith(".ipynb") && edits?.length > 0) {
-				throw new Error("Cannot edit Jupyter notebooks with the Edit tool. Use the NotebookEdit tool instead.");
-			}
-
-			const absolutePath = resolveToCwd(path, this.session.cwd);
-			const resolvedRename = rename ? resolveToCwd(rename, this.session.cwd) : undefined;
-			const file = Bun.file(absolutePath);
-
-			if (deleteFile) {
-				if (await file.exists()) {
-					await file.unlink();
-				}
-				invalidateFsScanAfterDelete(absolutePath);
-				return {
-					content: [{ type: "text", text: `Deleted ${path}` }],
-					details: {
-						diff: "",
-						op: "delete",
-						meta: outputMeta().get(),
-					},
-				};
-			}
-
-			if (!(await file.exists())) {
-				const content: string[] = [];
-				for (const edit of edits) {
-					switch (edit.op) {
-						case "append": {
-							if (edit.after) {
-								throw new Error(`File not found: ${path}`);
-							}
-							content.push(...hashlineParseContent(edit.content));
-							break;
-						}
-						case "prepend": {
-							if (edit.before) {
-								throw new Error(`File not found: ${path}`);
-							}
-							content.unshift(...hashlineParseContent(edit.content));
-							break;
-						}
-						default: {
-							throw new Error(`File not found: ${path}`);
-						}
-					}
-				}
-				await file.write(content.join("\n"));
-				return {
-					content: [{ type: "text", text: `Created ${path}` }],
-					details: {
-						diff: "",
-						op: "create",
-						meta: outputMeta().get(),
-					},
-				};
-			}
-
-			const anchorEdits: HashlineEdit[] = [];
-			const replaceEdits: ReplaceTextEdit[] = [];
-			for (const edit of edits) {
-				switch (edit.op) {
-					case "set": {
-						const { tag, content } = edit;
-						anchorEdits.push({ op: "set", tag: parseTag(tag), content: hashlineParseContent(content) });
-						break;
-					}
-					case "replace": {
-						const { first, last, content } = edit;
-						anchorEdits.push({
-							op: "replace",
-							first: parseTag(first),
-							last: parseTag(last),
-							content: hashlineParseContent(content),
-						});
-						break;
-					}
-					case "append": {
-						const { after, content } = edit;
-						anchorEdits.push({
-							op: "append",
-							...(after ? { after: parseTag(after) } : {}),
-							content: hashlineParseContent(content),
-						});
-						break;
-					}
-					case "prepend": {
-						const { before, content } = edit;
-						anchorEdits.push({
-							op: "prepend",
-							...(before ? { before: parseTag(before) } : {}),
-							content: hashlineParseContent(content),
-						});
-						break;
-					}
-					case "insert": {
-						const { before, after, content } = edit;
-						if (before && !after) {
-							anchorEdits.push({
-								op: "prepend",
-								before: parseTag(before),
-								content: hashlineParseContent(content),
-							});
-						} else if (after && !before) {
-							anchorEdits.push({
-								op: "append",
-								after: parseTag(after),
-								content: hashlineParseContent(content),
-							});
-						} else if (before && after) {
-							anchorEdits.push({
-								op: "insert",
-								before: parseTag(before),
-								after: parseTag(after),
-								content: hashlineParseContent(content),
-							});
-						} else {
-							throw new Error(`Insert must have both before and after tags.`);
-						}
-						break;
-					}
-					case "replaceText": {
-						const { old_text, new_text, all } = edit;
-						replaceEdits.push({
-							op: "replaceText",
-							old_text: old_text,
-							new_text: hashlineParseContentString(new_text),
-							all: all ?? false,
-						});
-						break;
-					}
-					default:
-						throw new Error(`Invalid edit operation: ${JSON.stringify(edit)}`);
-				}
-			}
-
-			const rawContent = await file.text();
-			const { bom, text: content } = stripBom(rawContent);
-			const originalEnding = detectLineEnding(content);
-			const originalNormalized = normalizeToLF(content);
-			let normalizedContent = originalNormalized;
-
-			// Apply anchor-based edits first (set, set_range, insert)
-			const anchorResult = applyHashlineEdits(normalizedContent, anchorEdits);
-			normalizedContent = anchorResult.content;
-
-			// Apply content-replace edits (substr-style fuzzy replace)
-			for (const r of replaceEdits) {
-				if (r.old_text.length === 0) {
-					throw new Error("old_text must not be empty.");
-				}
-				const rep = replaceText(normalizedContent, r.old_text, r.new_text, {
-					fuzzy: this.#allowFuzzy,
-					all: r.all ?? false,
-					threshold: this.#fuzzyThreshold,
-				});
-				normalizedContent = rep.content;
-			}
-
-			const result = {
-				content: normalizedContent,
-				firstChangedLine: anchorResult.firstChangedLine,
-				warnings: anchorResult.warnings,
-				noopEdits: anchorResult.noopEdits,
-			};
-			if (originalNormalized === result.content && !rename) {
-				let diagnostic = `No changes made to ${path}. The edits produced identical content.`;
-				if (result.noopEdits && result.noopEdits.length > 0) {
-					const details = result.noopEdits
-						.map(
-							e =>
-								`Edit ${e.editIndex}: replacement for ${e.loc} is identical to current content:\n  ${e.loc}| ${e.currentContent}`,
-						)
-						.join("\n");
-					diagnostic += `\n${details}`;
-					diagnostic +=
-						"\nYour content must differ from what the file already contains. Re-read the file to see the current state.";
-				} else {
-					// Edits were not literally identical but heuristics normalized them back
-					const lines = result.content.split("\n");
-					const targetLines: string[] = [];
-					const refs: LineTag[] = [];
-					for (const edit of anchorEdits) {
-						refs.length = 0;
-						switch (edit.op) {
-							case "set":
-								refs.push(edit.tag);
-								break;
-							case "replace":
-								refs.push(edit.first, edit.last);
-								break;
-							case "append":
-								if (edit.after) refs.push(edit.after);
-								break;
-							case "prepend":
-								if (edit.before) refs.push(edit.before);
-								break;
-							case "insert":
-								refs.push(edit.after, edit.before);
-								break;
-							default:
-								break;
-						}
-
-						for (const ref of refs) {
-							try {
-								if (ref.line >= 1 && ref.line <= lines.length) {
-									const lineContent = lines[ref.line - 1];
-									const hash = computeLineHash(ref.line, lineContent);
-									targetLines.push(`${ref.line}#${hash}:${lineContent}`);
-								}
-							} catch {
-								/* skip malformed refs */
-							}
-						}
-					}
-					if (targetLines.length > 0) {
-						const preview = [...new Set(targetLines)].slice(0, 5).join("\n");
-						diagnostic += `\nThe file currently contains these lines:\n${preview}\nYour edits were normalized back to the original content (whitespace-only differences are preserved as-is). Ensure your replacement changes actual code, not just formatting.`;
-					}
-				}
-				throw new Error(diagnostic);
-			}
-
-			const finalContent = bom + restoreLineEndings(result.content, originalEnding);
-			const writePath = resolvedRename ?? absolutePath;
-			saveForUndo(absolutePath, rawContent);
-			const diagnostics = await this.#writethrough(
-				writePath,
-				finalContent,
-				signal,
-				Bun.file(writePath),
-				batchRequest,
-			);
-			if (resolvedRename && resolvedRename !== absolutePath) {
-				await file.unlink();
-				invalidateFsScanAfterRename(absolutePath, resolvedRename);
-			} else {
-				invalidateFsScanAfterWrite(absolutePath);
-			}
-			const diffResult = generateDiffString(originalNormalized, result.content);
-
-			const normative = buildNormativeUpdateInput({
-				path,
-				...(rename ? { rename } : {}),
-				oldContent: rawContent,
-				newContent: finalContent,
-			});
-
-			const meta = outputMeta()
-				.diagnostics(diagnostics?.summary ?? "", diagnostics?.messages ?? [])
-				.get();
-
-			const resultText = rename ? `Updated and moved ${path} to ${rename}` : `Updated ${path}`;
-			return {
-				content: [
-					{
-						type: "text",
-						text: `${resultText}${result.warnings?.length ? `\n\nWarnings:\n${result.warnings.join("\n")}` : ""}`,
-					},
-				],
-				details: {
-					diff: diffResult.diff,
-					firstChangedLine: result.firstChangedLine ?? diffResult.firstChangedLine,
-					diagnostics,
-					op: "update",
-					rename,
-					meta,
-				},
-				$normative: normative,
-			};
-		}
-
-		// ─────────────────────────────────────────────────────────────────
-		// Patch mode execution
-		// ─────────────────────────────────────────────────────────────────
-		if (this.mode === "patch") {
-			const { path, op: rawOp, rename, diff } = params as PatchParams;
-
-			// Normalize unrecognized operations to "update"
-			const op: Operation = rawOp === "create" || rawOp === "delete" ? rawOp : "update";
-
-			const resolvedPath = resolveToCwd(path, this.session.cwd);
-			const resolvedRename = rename ? resolveToCwd(rename, this.session.cwd) : undefined;
-
-			if (path.endsWith(".ipynb")) {
-				throw new Error("Cannot edit Jupyter notebooks with the Edit tool. Use the NotebookEdit tool instead.");
-			}
-			if (rename?.endsWith(".ipynb")) {
-				throw new Error("Cannot edit Jupyter notebooks with the Edit tool. Use the NotebookEdit tool instead.");
-			}
-
-			const input: PatchInput = { path: resolvedPath, op, rename: resolvedRename, diff };
-			const fs = new LspFileSystem(this.#writethrough, signal, batchRequest);
-			const result = await applyPatch(input, {
-				cwd: this.session.cwd,
-				fs,
-				fuzzyThreshold: this.#fuzzyThreshold,
-				allowFuzzy: this.#allowFuzzy,
-			});
-			if (result.change.oldContent !== undefined) {
-				saveForUndo(resolvedPath, result.change.oldContent);
-			}
-			if (resolvedRename) {
-				invalidateFsScanAfterRename(resolvedPath, resolvedRename);
-			} else if (result.change.type === "delete") {
-				invalidateFsScanAfterDelete(resolvedPath);
-			} else {
-				invalidateFsScanAfterWrite(resolvedPath);
-			}
-			const effRename = result.change.newPath ? rename : undefined;
-
-			// Generate diff for display
-			let diffResult = { diff: "", firstChangedLine: undefined as number | undefined };
-			if (result.change.type === "update" && result.change.oldContent && result.change.newContent) {
-				const normalizedOld = normalizeToLF(stripBom(result.change.oldContent).text);
-				const normalizedNew = normalizeToLF(stripBom(result.change.newContent).text);
-				diffResult = generateUnifiedDiffString(normalizedOld, normalizedNew);
-			}
-
-			let resultText: string;
-			switch (result.change.type) {
-				case "create":
-					resultText = `Created ${path}`;
-					break;
-				case "delete":
-					resultText = `Deleted ${path}`;
-					break;
-				case "update":
-					resultText = effRename ? `Updated and moved ${path} to ${effRename}` : `Updated ${path}`;
-					break;
-			}
-
-			let diagnostics = fs.getDiagnostics();
-			if (op === "delete" && batchRequest?.flush) {
-				const flushedDiagnostics = await flushLspWritethroughBatch(batchRequest.id, this.session.cwd, signal);
-				diagnostics ??= flushedDiagnostics;
-			}
-			const patchWarnings = result.warnings ?? [];
-			const mergedDiagnostics = mergeDiagnosticsWithWarnings(diagnostics, patchWarnings);
-
-			const meta = outputMeta()
-				.diagnostics(mergedDiagnostics?.summary ?? "", mergedDiagnostics?.messages ?? [])
-				.get();
-
-			return {
-				content: [{ type: "text", text: resultText }],
-				details: {
-					diff: diffResult.diff,
-					firstChangedLine: diffResult.firstChangedLine,
-					diagnostics: mergedDiagnostics,
-					op,
-					rename: effRename,
-					meta,
-				},
-			};
-		}
-
-		// ─────────────────────────────────────────────────────────────────
-		// Replace mode execution
-		// ─────────────────────────────────────────────────────────────────
-		const { path, old_text, new_text, all } = params as ReplaceParams;
-
-		if (path.endsWith(".ipynb")) {
-			throw new Error("Cannot edit Jupyter notebooks with the Edit tool. Use the NotebookEdit tool instead.");
-		}
-
-		if (old_text.length === 0) {
-			throw new Error("old_text must not be empty.");
-		}
-
-		const absolutePath = resolveToCwd(path, this.session.cwd);
-		const file = Bun.file(absolutePath);
-
-		if (!(await file.exists())) {
-			throw new Error(`File not found: ${path}`);
-		}
-
-		const rawContent = await file.text();
-		const { bom, text: content } = stripBom(rawContent);
-		const originalEnding = detectLineEnding(content);
-		const normalizedContent = normalizeToLF(content);
-		const normalizedOldText = normalizeToLF(old_text);
-		const normalizedNewText = normalizeToLF(new_text);
-
-		const result = replaceText(normalizedContent, normalizedOldText, normalizedNewText, {
-			fuzzy: this.#allowFuzzy,
-			all: all ?? false,
-			threshold: this.#fuzzyThreshold,
-		});
-
-		if (result.count === 0) {
-			// Get error details
-			const matchOutcome = findMatch(normalizedContent, normalizedOldText, {
-				allowFuzzy: this.#allowFuzzy,
-				threshold: this.#fuzzyThreshold,
-			});
-
-			if (matchOutcome.occurrences && matchOutcome.occurrences > 1) {
-				const previews = matchOutcome.occurrencePreviews?.join("\n\n") ?? "";
-				const moreMsg = matchOutcome.occurrences > 5 ? ` (showing first 5 of ${matchOutcome.occurrences})` : "";
-				throw new Error(
-					`Found ${matchOutcome.occurrences} occurrences in ${path}${moreMsg}:\n\n${previews}\n\n` +
-						`Add more context lines to disambiguate.`,
-				);
-			}
-
-			throw new EditMatchError(path, normalizedOldText, matchOutcome.closest, {
-				allowFuzzy: this.#allowFuzzy,
-				threshold: this.#fuzzyThreshold,
-				fuzzyMatches: matchOutcome.fuzzyMatches,
-			});
-		}
-
-		if (normalizedContent === result.content) {
-			throw new Error(
-				`No changes made to ${path}. The replacement produced identical content. This might indicate an issue with special characters or the text not existing as expected.`,
-			);
-		}
-
-		const finalContent = bom + restoreLineEndings(result.content, originalEnding);
-		saveForUndo(absolutePath, rawContent);
-		const diagnostics = await this.#writethrough(absolutePath, finalContent, signal, file, batchRequest);
-		invalidateFsScanAfterWrite(absolutePath);
-		const diffResult = generateDiffString(normalizedContent, result.content);
-
-		const resultText =
-			result.count > 1
-				? `Successfully replaced ${result.count} occurrences in ${path}.`
-				: `Successfully replaced text in ${path}.`;
-
-		const meta = outputMeta()
-			.diagnostics(diagnostics?.summary ?? "", diagnostics?.messages ?? [])
-			.get();
-
-		return {
-			content: [{ type: "text", text: resultText }],
-			details: { diff: diffResult.diff, firstChangedLine: diffResult.firstChangedLine, diagnostics, meta },
-		};
-	}
-}