@oh-my-pi/pi-coding-agent 13.18.0 → 14.0.2

package/src/{patch/applicator.ts → edit/modes/patch.ts}

@@ -7,8 +7,33 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { resolveToCwd } from "../tools/path-utils";
-import { DEFAULT_FUZZY_THRESHOLD, findClosestSequenceMatch, findContextLine, findMatch, seekSequence } from "./fuzzy";
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import { StringEnum } from "@oh-my-pi/pi-ai";
+import { isEnoent } from "@oh-my-pi/pi-utils";
+import { type Static, Type } from "@sinclair/typebox";
+import {
+	type FileDiagnosticsResult,
+	flushLspWritethroughBatch,
+	type WritethroughCallback,
+	type WritethroughDeferredHandle,
+} from "../../lsp";
+import type { ToolSession } from "../../tools";
+import { assertEditableFile } from "../../tools/auto-generated-guard";
+import {
+	invalidateFsScanAfterDelete,
+	invalidateFsScanAfterRename,
+	invalidateFsScanAfterWrite,
+} from "../../tools/fs-cache-invalidation";
+import { outputMeta } from "../../tools/output-meta";
+import { resolveToCwd } from "../../tools/path-utils";
+import { enforcePlanModeWrite, resolvePlanPath } from "../../tools/plan-mode-guard";
+import {
+	ApplyPatchError,
+	type DiffHunk,
+	generateUnifiedDiffString,
+	normalizeCreateContent,
+	parseDiffHunks,
+} from "../diff";
 import {
 	adjustIndentation,
 	convertLeadingTabsToSpaces,
@@ -18,18 +43,56 @@ import {
 	normalizeToLF,
 	restoreLineEndings,
 	stripBom,
-} from "./normalize";
-import { normalizeCreateContent, parseHunks } from "./parser";
-import type {
-	ApplyPatchOptions,
-	ApplyPatchResult,
-	ContextLineResult,
-	DiffHunk,
-	FileSystem,
-	NormalizedPatchInput,
-	PatchInput,
-} from "./types";
-import { ApplyPatchError, normalizePatchInput } from "./types";
+} from "../normalize";
+import type { EditToolDetails, LspBatchRequest } from "../renderer";
+import {
+	type ContextLineResult,
+	DEFAULT_FUZZY_THRESHOLD,
+	findClosestSequenceMatch,
+	findContextLine,
+	findMatch,
+	type SequenceSearchResult,
+	seekSequence,
+} from "./replace";
+
+export type Operation = "create" | "delete" | "update";
+
+export interface PatchInput {
+	path: string;
+	op: Operation;
+	rename?: string;
+	diff?: string;
+}
+
+export interface FileSystem {
+	exists(path: string): Promise<boolean>;
+	read(path: string): Promise<string>;
+	readBinary?: (path: string) => Promise<Uint8Array>;
+	write(path: string, content: string): Promise<void>;
+	delete(path: string): Promise<void>;
+	mkdir(path: string): Promise<void>;
+}
+
+interface FileChange {
+	type: Operation;
+	path: string;
+	newPath?: string;
+	oldContent?: string;
+	newContent?: string;
+}
+
+export interface ApplyPatchResult {
+	change: FileChange;
+	warnings?: string[];
+}
+
+export interface ApplyPatchOptions {
+	cwd: string;
+	dryRun?: boolean;
+	fuzzyThreshold?: number;
+	allowFuzzy?: boolean;
+	fs?: FileSystem;
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Default File System
@@ -38,14 +101,13 @@ import { ApplyPatchError, normalizePatchInput } from "./types";
 /** Default filesystem implementation using Bun APIs */
 export const defaultFileSystem: FileSystem = {
 	async exists(path: string): Promise<boolean> {
-		return fs.existsSync(path);
+		return Bun.file(path).exists();
 	},
 	async read(path: string): Promise<string> {
 		return Bun.file(path).text();
 	},
 	async readBinary(path: string): Promise<Uint8Array> {
-		const buffer = await Bun.file(path).arrayBuffer();
-		return new Uint8Array(buffer);
+		return fs.promises.readFile(path);
 	},
 	async write(path: string, content: string): Promise<void> {
 		await Bun.write(path, content);
@@ -76,6 +138,71 @@ interface HunkVariant {
 	kind: HunkVariantKind;
 }
 
+function isBlankLine(line: string): boolean {
+	return line.trim().length === 0;
+}
+
+function areEqualLines(left: string[], right: string[]): boolean {
+	if (left.length !== right.length) return false;
+	for (let i = 0; i < left.length; i++) {
+		if (left[i] !== right[i]) return false;
+	}
+	return true;
+}
+
+function areEqualTrimmedLines(left: string[], right: string[]): boolean {
+	if (left.length !== right.length) return false;
+	for (let i = 0; i < left.length; i++) {
+		if (left[i].trim() !== right[i].trim()) return false;
+	}
+	return true;
+}
+
+function getIndentChar(lines: string[]): string {
+	for (const line of lines) {
+		const ws = getLeadingWhitespace(line);
+		if (ws.length > 0) return ws[0];
+	}
+	return " ";
+}
+
+function collectIndentDeltas(oldLines: string[], actualLines: string[]): number[] {
+	const deltas: number[] = [];
+	const lineCount = Math.min(oldLines.length, actualLines.length);
+	for (let i = 0; i < lineCount; i++) {
+		const oldLine = oldLines[i];
+		const actualLine = actualLines[i];
+		if (isBlankLine(oldLine) || isBlankLine(actualLine)) continue;
+		deltas.push(countLeadingWhitespace(actualLine) - countLeadingWhitespace(oldLine));
+	}
+	return deltas;
+}
+
+function applyIndentDelta(lines: string[], delta: number, indentChar: string): string[] {
+	return lines.map(line => {
+		if (isBlankLine(line)) return line;
+		if (delta > 0) return indentChar.repeat(delta) + line;
+		const toRemove = Math.min(-delta, countLeadingWhitespace(line));
+		return line.slice(toRemove);
+	});
+}
+
+function canConvertTabsToSpaces(oldLines: string[], actualLines: string[], spacesPerTab: number): boolean {
+	const lineCount = Math.min(oldLines.length, actualLines.length);
+	for (let i = 0; i < lineCount; i++) {
+		const oldLine = oldLines[i];
+		const actualLine = actualLines[i];
+		if (isBlankLine(oldLine) || isBlankLine(actualLine)) continue;
+		const oldIndent = getLeadingWhitespace(oldLine);
+		const actualIndent = getLeadingWhitespace(actualLine);
+		if (oldIndent.length === 0) continue;
+		if (actualIndent.length !== oldIndent.length * spacesPerTab) {
+			return false;
+		}
+	}
+	return true;
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Replacement Computation
 // ═══════════════════════════════════════════════════════════════════════════
@@ -87,42 +214,17 @@ function adjustLinesIndentation(patternLines: string[], actualLines: string[], n
 	}
 
 	// If pattern already matches actual exactly (including indentation), preserve agent's intended changes
-	if (patternLines.length === actualLines.length) {
-		let exactMatch = true;
-		for (let i = 0; i < patternLines.length; i++) {
-			if (patternLines[i] !== actualLines[i]) {
-				exactMatch = false;
-				break;
-			}
-		}
-		if (exactMatch) {
-			return newLines;
-		}
+	if (areEqualLines(patternLines, actualLines)) {
+		return newLines;
 	}
 
 	// If the patch is purely an indentation change (same trimmed content), apply exactly as specified
-	if (patternLines.length === newLines.length) {
-		let indentationOnly = true;
-		for (let i = 0; i < patternLines.length; i++) {
-			if (patternLines[i].trim() !== newLines[i].trim()) {
-				indentationOnly = false;
-				break;
-			}
-		}
-		if (indentationOnly) {
-			return newLines;
-		}
+	if (areEqualTrimmedLines(patternLines, newLines)) {
+		return newLines;
 	}
 
 	// Detect indent character from actual content
-	let indentChar = " ";
-	for (const line of actualLines) {
-		const ws = getLeadingWhitespace(line);
-		if (ws.length > 0) {
-			indentChar = ws[0];
-			break;
-		}
-	}
+	const indentChar = getIndentChar(actualLines);
 
 	let patternTabOnly = true;
 	let actualSpaceOnly = true;
@@ -171,9 +273,8 @@ function adjustLinesIndentation(patternLines: string[], actualLines: string[], n
 			}
 		}
 
-		if (consistent && ratio) {
-			const converted = convertLeadingTabsToSpaces(newLines.join("\n"), ratio).split("\n");
-			return converted;
+		if (consistent && ratio && canConvertTabsToSpaces(patternLines, actualLines, ratio)) {
+			return convertLeadingTabsToSpaces(newLines.join("\n"), ratio).split("\n");
 		}
 	}
 
@@ -282,20 +383,8 @@ function adjustLinesIndentation(patternLines: string[], actualLines: string[], n
 		patternMin = 0;
 	}
 
-	let delta: number | undefined;
-	const deltas: number[] = [];
-	for (let i = 0; i < Math.min(patternLines.length, actualLines.length); i++) {
-		const patternLine = patternLines[i];
-		const actualLine = actualLines[i];
-		if (patternLine.trim().length === 0 || actualLine.trim().length === 0) continue;
-		const pIndent = countLeadingWhitespace(patternLine);
-		const aIndent = countLeadingWhitespace(actualLine);
-		deltas.push(aIndent - pIndent);
-	}
-
-	if (deltas.length > 0 && deltas.every(value => value === deltas[0])) {
-		delta = deltas[0];
-	}
+	const deltas = collectIndentDeltas(patternLines, actualLines);
+	const delta = deltas.length > 0 && deltas.every(value => value === deltas[0]) ? deltas[0] : undefined;
 
 	// Track which actual lines we've used to handle duplicate content correctly
 	const usedActualLines = new Map<string, number>(); // trimmed content -> count used
@@ -328,11 +417,7 @@ function adjustLinesIndentation(patternLines: string[], actualLines: string[], n
 		if (delta && delta !== 0) {
 			const newIndent = countLeadingWhitespace(newLine);
 			if (newIndent === patternMin) {
-				if (delta > 0) {
-					return indentChar.repeat(delta) + newLine;
-				}
-				const toRemove = Math.min(-delta, newIndent);
-				return newLine.slice(toRemove);
+				return applyIndentDelta([newLine], delta, indentChar)[0];
 			}
 		}
 		return newLine;
@@ -737,7 +822,7 @@ function findSequenceWithHint(
 	hintIndex: number | undefined,
 	eof: boolean,
 	allowFuzzy: boolean,
-): import("./types").SequenceSearchResult {
+): SequenceSearchResult {
 	// Prefer content-based search starting from currentIndex
 	const primaryResult = seekSequence(lines, pattern, currentIndex, eof, { allowFuzzy });
 	if (
@@ -910,6 +995,17 @@ function applyTrailingNewlinePolicy(content: string, hadFinalNewline: boolean):
 	return content.replace(/\n+$/u, "");
 }
 
+async function readExistingPatchFile(fileSystem: FileSystem, absolutePath: string, path: string): Promise<string> {
+	try {
+		return await fileSystem.read(absolutePath);
+	} catch (error) {
+		if (isEnoent(error)) {
+			throw new ApplyPatchError(`File not found: ${path}`);
+		}
+		throw error;
+	}
+}
+
 /**
  * Compute replacements needed to transform originalLines using the diff hunks.
  */
@@ -937,6 +1033,7 @@ function computeReplacements(
 		}
 		const lineHint = hunk.oldStartLine;
 		const allowAggressiveFallbacks = hunk.changeContext !== undefined || lineHint !== undefined || hunk.isEndOfFile;
+		const fallbackVariants = filterFallbackVariants(buildFallbackVariants(hunk), allowAggressiveFallbacks);
 		if (lineHint !== undefined && hunk.changeContext === undefined && !hunk.hasContextLines) {
 			lineIndex = Math.max(0, Math.min(lineHint - 1, originalLines.length - 1));
 		}
@@ -1059,7 +1156,7 @@ function computeReplacements(
 		}
 
 		if (searchResult.index === undefined || (searchResult.matchCount ?? 0) > 1) {
-			for (const variant of filterFallbackVariants(buildFallbackVariants(hunk), allowAggressiveFallbacks)) {
+			for (const variant of fallbackVariants) {
 				if (variant.oldLines.length === 0) continue;
 				const variantResult = findSequenceWithHint(
 					originalLines,
@@ -1079,7 +1176,7 @@ function computeReplacements(
 		}
 
 		if (searchResult.index === undefined && contextIndex !== undefined) {
-			for (const variant of filterFallbackVariants(buildFallbackVariants(hunk), allowAggressiveFallbacks)) {
+			for (const variant of fallbackVariants) {
 				if (variant.oldLines.length !== 1 || variant.newLines.length !== 1) continue;
 				const removedLine = variant.oldLines[0];
 				const hasSharedDuplicate = hunk.newLines.some(line => line.trim() === removedLine.trim());
@@ -1178,23 +1275,8 @@ function computeReplacements(
 		if (hunk.changeContext === undefined && !hunk.hasContextLines && !hunk.isEndOfFile && lineHint === undefined) {
 			const secondMatch = seekSequence(originalLines, pattern, found + 1, false, { allowFuzzy });
 			if (secondMatch.index !== undefined) {
-				// Extract 3-line previews for each match
-				const formatPreview = (startIdx: number) => {
-					const contextLines = 2;
-					const maxLineLength = 80;
-					const start = Math.max(0, startIdx - contextLines);
-					const end = Math.min(originalLines.length, startIdx + contextLines + 1);
-					const lines = originalLines.slice(start, end);
-					return lines
-						.map((line, i) => {
-							const num = start + i + 1;
-							const truncated = line.length > maxLineLength ? `${line.slice(0, maxLineLength - 1)}…` : line;
-							return `  ${num} | ${truncated}`;
-						})
-						.join("\n");
-				};
-				const preview1 = formatPreview(found);
-				const preview2 = formatPreview(secondMatch.index);
+				const preview1 = formatSequenceMatchPreview(originalLines, found);
+				const preview2 = formatSequenceMatchPreview(originalLines, secondMatch.index);
 				throw new ApplyPatchError(
 					`Found 2 occurrences in ${path}:\n\n${preview1}\n\n${preview2}\n\n` +
 						`Add more context lines to disambiguate.`,
@@ -1317,15 +1399,7 @@ function applyHunksToContent(
 	}
 
 	const content = newLines.join("\n");
-
-	// Preserve original trailing newline behavior
-	if (hadFinalNewline && !content.endsWith("\n")) {
-		return { content: `${content}\n`, warnings };
-	}
-	if (!hadFinalNewline && content.endsWith("\n")) {
-		return { content: content.slice(0, -1), warnings };
-	}
-	return { content, warnings };
+	return { content: applyTrailingNewlinePolicy(content, hadFinalNewline), warnings };
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -1336,18 +1410,14 @@ function applyHunksToContent(
  * Apply a patch operation to the filesystem.
  */
 export async function applyPatch(input: PatchInput, options: ApplyPatchOptions): Promise<ApplyPatchResult> {
-	const normalized = normalizePatchInput(input);
-	return applyNormalizedPatch(normalized, options);
+	return applyNormalizedPatch(input, options);
 }
 
 /**
  * Apply a normalized patch operation to the filesystem.
  * @internal
  */
-async function applyNormalizedPatch(
-	input: NormalizedPatchInput,
-	options: ApplyPatchOptions,
-): Promise<ApplyPatchResult> {
+async function applyNormalizedPatch(input: PatchInput, options: ApplyPatchOptions): Promise<ApplyPatchResult> {
 	const {
 		cwd,
 		dryRun = false,
@@ -1358,6 +1428,7 @@ async function applyNormalizedPatch(
 
 	const resolvePath = (p: string): string => resolveToCwd(p, cwd);
 	const absolutePath = resolvePath(input.path);
+	const op = input.op ?? "update";
 
 	if (input.rename) {
 		const destPath = resolvePath(input.rename);
@@ -1367,7 +1438,7 @@ async function applyNormalizedPatch(
 	}
 
 	// Handle CREATE operation
-	if (input.op === "create") {
+	if (op === "create") {
 		if (!input.diff) {
 			throw new ApplyPatchError("Create operation requires diff (file content)");
 		}
@@ -1393,12 +1464,8 @@ async function applyNormalizedPatch(
 	}
 
 	// Handle DELETE operation
-	if (input.op === "delete") {
-		if (!(await fs.exists(absolutePath))) {
-			throw new ApplyPatchError(`File not found: ${input.path}`);
-		}
-
-		const oldContent = await fs.read(absolutePath);
+	if (op === "delete") {
+		const oldContent = await readExistingPatchFile(fs, absolutePath, input.path);
 		if (!dryRun) {
 			await fs.delete(absolutePath);
 		}
@@ -1417,11 +1484,7 @@ async function applyNormalizedPatch(
 		throw new ApplyPatchError("Update operation requires diff (hunks)");
 	}
 
-	if (!(await fs.exists(absolutePath))) {
-		throw new ApplyPatchError(`File not found: ${input.path}`);
-	}
-
-	const originalContent = await fs.read(absolutePath);
+	const originalContent = await readExistingPatchFile(fs, absolutePath, input.path);
 	const { bom: bomFromText, text: strippedContent } = stripBom(originalContent);
 	let bom = bomFromText;
 	if (!bom && fs.readBinary) {
@@ -1432,7 +1495,7 @@ async function applyNormalizedPatch(
 	}
 	const lineEnding = detectLineEnding(strippedContent);
 	const normalizedContent = normalizeToLF(strippedContent);
-	const hunks = parseHunks(input.diff);
+	const hunks = parseDiffHunks(input.diff);
 
 	if (hunks.length === 0) {
 		throw new ApplyPatchError("Diff contains no hunks");
@@ -1480,3 +1543,243 @@ async function applyNormalizedPatch(
 export async function previewPatch(input: PatchInput, options: ApplyPatchOptions): Promise<ApplyPatchResult> {
 	return applyPatch(input, { ...options, dryRun: true });
 }
+
+export async function computePatchDiff(
+	input: PatchInput,
+	cwd: string,
+	options?: { fuzzyThreshold?: number; allowFuzzy?: boolean },
+): Promise<
+	| {
+			diff: string;
+			firstChangedLine: number | undefined;
+	  }
+	| {
+			error: string;
+	  }
+> {
+	try {
+		const result = await previewPatch(input, {
+			cwd,
+			fuzzyThreshold: options?.fuzzyThreshold,
+			allowFuzzy: options?.allowFuzzy,
+		});
+		const oldContent = result.change.oldContent ?? "";
+		const newContent = result.change.newContent ?? "";
+		const normalizedOld = normalizeToLF(stripBom(oldContent).text);
+		const normalizedNew = normalizeToLF(stripBom(newContent).text);
+		if (!normalizedOld && !normalizedNew) {
+			return { diff: "", firstChangedLine: undefined };
+		}
+		return generateUnifiedDiffString(normalizedOld, normalizedNew);
+	} catch (err) {
+		return { error: err instanceof Error ? err.message : String(err) };
+	}
+}
+
+export 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 PatchParams = Static<typeof patchEditSchema>;
+
+interface ExecutePatchModeOptions {
+	session: ToolSession;
+	params: PatchParams;
+	signal?: AbortSignal;
+	batchRequest?: LspBatchRequest;
+	allowFuzzy: boolean;
+	fuzzyThreshold: number;
+	writethrough: WritethroughCallback;
+	beginDeferredDiagnosticsForPath: (path: string) => WritethroughDeferredHandle;
+}
+
+export function isPatchParams(params: unknown): params is PatchParams {
+	if (typeof params !== "object" || params === null || !("path" in params)) {
+		return false;
+	}
+	return !("old_text" in params) && !("new_text" in params) && !("edits" in params);
+}
+
+class LspFileSystem implements FileSystem {
+	#lastDiagnostics: FileDiagnosticsResult | undefined;
+	#fileCache: Record<string, Bun.BunFile> = {};
+
+	constructor(
+		private readonly writethrough: WritethroughCallback,
+		private readonly signal?: AbortSignal,
+		private readonly batchRequest?: LspBatchRequest,
+		private readonly deferredForPath?: (path: string) => WritethroughDeferredHandle,
+	) {}
+
+	#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 bytes = await fs.promises.readFile(path);
+		return bytes;
+	}
+
+	async write(path: string, content: string): Promise<void> {
+		const file = this.#getFile(path);
+		const deferredForPath = this.deferredForPath;
+		const result = await this.writethrough(
+			path,
+			content,
+			this.signal,
+			file,
+			this.batchRequest,
+			deferredForPath ? (dst: string) => deferredForPath(dst) : undefined,
+		);
+		if (result) {
+			this.#lastDiagnostics = result;
+		}
+	}
+
+	async delete(path: string): Promise<void> {
+		await this.#getFile(path).unlink();
+	}
+
+	async mkdir(path: string): Promise<void> {
+		await fs.promises.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}`,
+	};
+}
+
+export async function executePatchMode(
+	options: ExecutePatchModeOptions,
+): Promise<AgentToolResult<EditToolDetails, typeof patchEditSchema>> {
+	const {
+		session,
+		params,
+		signal,
+		batchRequest,
+		allowFuzzy,
+		fuzzyThreshold,
+		writethrough,
+		beginDeferredDiagnosticsForPath,
+	} = options;
+	const { path, op: rawOp, rename, diff } = params;
+
+	const op: Operation = rawOp === "create" || rawOp === "delete" ? rawOp : "update";
+
+	enforcePlanModeWrite(session, path, { op, move: rename });
+	const resolvedPath = resolvePlanPath(session, path);
+	const resolvedRename = rename ? resolvePlanPath(session, rename) : 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.");
+	}
+
+	await assertEditableFile(resolvedPath, path);
+
+	const input: PatchInput = { path: resolvedPath, op, rename: resolvedRename, diff };
+	const patchFileSystem = new LspFileSystem(writethrough, signal, batchRequest, beginDeferredDiagnosticsForPath);
+	const result = await applyPatch(input, {
+		cwd: session.cwd,
+		fs: patchFileSystem,
+		fuzzyThreshold,
+		allowFuzzy,
+	});
+
+	if (resolvedRename) {
+		invalidateFsScanAfterRename(resolvedPath, resolvedRename);
+	} else if (result.change.type === "delete") {
+		invalidateFsScanAfterDelete(resolvedPath);
+	} else {
+		invalidateFsScanAfterWrite(resolvedPath);
+	}
+	const effectiveRename = result.change.newPath ? rename : undefined;
+
+	let diffResult: { diff: string; firstChangedLine: number | undefined } = {
+		diff: "",
+		firstChangedLine: 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 = effectiveRename ? `Updated and moved ${path} to ${effectiveRename}` : `Updated ${path}`;
+			break;
+	}
+
+	let diagnostics = patchFileSystem.getDiagnostics();
+	if (op === "delete" && batchRequest?.flush) {
+		const flushedDiagnostics = await flushLspWritethroughBatch(batchRequest.id, session.cwd, signal);
+		diagnostics ??= flushedDiagnostics;
+	}
+	const mergedDiagnostics = mergeDiagnosticsWithWarnings(diagnostics, result.warnings ?? []);
+	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,
+			move: effectiveRename,
+			meta,
+		},
+	};
+}