@oh-my-pi/pi-coding-agent 14.2.1 → 14.3.0

package/src/edit/renderer.ts

@@ -24,12 +24,12 @@ import {
 } from "../tools/render-utils";
 import { type VimRenderArgs, vimToolRenderer } from "../tools/vim";
 import { Hasher, type RenderCache, renderStatusLine, truncateToWidth } from "../tui";
+import type { EditMode } from "../utils/edit-mode";
 import type { VimToolDetails } from "../vim/types";
 import type { DiffError, DiffResult } from "./diff";
 import { expandApplyPatchToEntries, expandApplyPatchToPreviewEntries } from "./modes/apply-patch";
-import { type ChunkToolEdit, parseChunkEditPath } from "./modes/chunk";
-import type { HashlineToolEdit } from "./modes/hashline";
 import type { Operation, PatchEditEntry } from "./modes/patch";
+import type { PerFileDiffPreview } from "./streaming";
 
 // ═══════════════════════════════════════════════════════════════════════════
 // LSP Batching
@@ -90,6 +90,7 @@ interface EditRenderArgs {
 	 * Computed preview diff (used when tool args don't include a diff, e.g. hashline mode).
 	 */
 	previewDiff?: string;
+	__partialJson?: string;
 	// Hashline / chunk mode fields
 	edits?: EditRenderEntry[];
 }
@@ -133,8 +134,12 @@ function isVimToolDetails(details: unknown): details is VimToolDetails {
 
 /** Extended context for edit tool rendering */
 export interface EditRenderContext {
+	/** Edit mode resolved by the caller; lets the renderer dispatch without shape-sniffing */
+	editMode?: EditMode;
 	/** Pre-computed diff preview (computed before tool executes) */
 	editDiffPreview?: DiffResult | DiffError;
+	/** Multi-file streaming diff preview (chunk edits spanning several files) */
+	perFileDiffPreview?: PerFileDiffPreview[];
 	/** Function to render diff text with syntax highlighting */
 	renderDiff?: (diffText: string, options?: { filePath?: string }) => string;
 }
@@ -142,14 +147,6 @@ export interface EditRenderContext {
 const EDIT_STREAMING_PREVIEW_LINES = 12;
 const CALL_TEXT_PREVIEW_LINES = 6;
 const CALL_TEXT_PREVIEW_WIDTH = 80;
-const STREAMING_EDIT_PREVIEW_WIDTH = 120;
-const STREAMING_EDIT_PREVIEW_LIMIT = 4;
-const STREAMING_EDIT_PREVIEW_DST_LINE_LIMIT = 8;
-
-interface FormattedStreamingEdit {
-	srcLabel: string;
-	dst: string;
-}
 
 /** Extract file path from an edit entry's path (handles chunk's file:selector format). */
 function filePathFromEditEntry(p: string | undefined): string | undefined {
@@ -158,6 +155,48 @@ function filePathFromEditEntry(p: string | undefined): string | undefined {
 	return ci === -1 ? p : p.slice(0, ci);
 }
 
+function decodePartialJsonStringFragment(fragment: string): string {
+	let text = fragment;
+	const trailingBackslashes = text.match(/\\+$/)?.[0].length ?? 0;
+	if (trailingBackslashes % 2 === 1) {
+		text = text.slice(0, -1);
+	}
+	try {
+		return JSON.parse(`"${text}"`) as string;
+	} catch {
+		return text
+			.replace(/\\u([0-9a-fA-F]{4})/g, (_, hex: string) => String.fromCharCode(Number.parseInt(hex, 16)))
+			.replace(/\\(["\\/bfnrt])/g, (_, ch: string) => {
+				switch (ch) {
+					case "b":
+						return "\b";
+					case "f":
+						return "\f";
+					case "n":
+						return "\n";
+					case "r":
+						return "\r";
+					case "t":
+						return "\t";
+					default:
+						return ch;
+				}
+			});
+	}
+}
+
+function extractPartialJsonString(partialJson: string | undefined, key: string): string | undefined {
+	if (!partialJson) return undefined;
+	const pattern = new RegExp(`"${key}"\\s*:\\s*"((?:\\\\.|[^"\\\\])*)`, "u");
+	const match = pattern.exec(partialJson);
+	if (!match) return undefined;
+	return decodePartialJsonStringFragment(match[1]);
+}
+
+function getPartialJsonEditPath(args: EditRenderArgs): string | undefined {
+	return filePathFromEditEntry(extractPartialJsonString(args.__partialJson, "path"));
+}
+
 /** Count distinct file paths in an edits array. */
 function countEditFiles(edits: EditRenderEntry[]): number {
 	return new Set(edits.map(edit => filePathFromEditEntry(edit.path)).filter(Boolean)).size;
@@ -230,133 +269,46 @@ function formatStreamingDiff(diff: string, rawPath: string, uiTheme: Theme, labe
 	return text;
 }
 
-function isChunkStreamingEdit(edit: Partial<HashlineToolEdit | ChunkToolEdit>): edit is Partial<ChunkToolEdit> {
-	return (
-		typeof edit === "object" &&
-		edit !== null &&
-		"path" in edit &&
-		("write" in edit || "replace" in edit || "insert" in edit)
-	);
-}
-
-function getStreamingEditContent(content: unknown): string {
-	if (Array.isArray(content)) {
-		return content.join("\n");
-	}
-	return typeof content === "string" ? content : "";
-}
-
-function formatHashlineStreamingEdit(edit: Partial<HashlineToolEdit>): FormattedStreamingEdit {
-	if (typeof edit !== "object" || !edit) {
-		return { srcLabel: "\u2022 (incomplete edit)", dst: "" };
-	}
-
-	const contentLines = getStreamingEditContent(edit.content);
-	const loc = edit.loc;
-
-	if (loc === "append" || loc === "prepend") {
-		return { srcLabel: `\u2022 ${loc} (file-level)`, dst: contentLines };
-	}
-	if (typeof loc === "object" && loc) {
-		if ("range" in loc && typeof loc.range === "object" && loc.range) {
-			return { srcLabel: `\u2022 range ${loc.range.pos ?? "?"}\u2026${loc.range.end ?? "?"}`, dst: contentLines };
-		}
-		if ("line" in loc) {
-			return { srcLabel: `\u2022 line ${(loc as { line: string }).line}`, dst: contentLines };
-		}
-		if ("append" in loc) {
-			return { srcLabel: `\u2022 append ${(loc as { append: string }).append}`, dst: contentLines };
-		}
-		if ("prepend" in loc) {
-			return { srcLabel: `\u2022 prepend ${(loc as { prepend: string }).prepend}`, dst: contentLines };
-		}
-	}
-	return { srcLabel: "\u2022 (unknown edit)", dst: contentLines };
-}
-
-function formatChunkStreamingEdit(edit: Partial<ChunkToolEdit>): FormattedStreamingEdit {
-	if (typeof edit !== "object" || !edit) {
-		return { srcLabel: "\u2022 (incomplete edit)", dst: "" };
-	}
-
-	const target = edit.path ? (parseChunkEditPath(edit.path).selector ?? edit.path) : "?";
-	if (edit.write === null) {
-		return { srcLabel: `\u2022 remove ${target}`, dst: "" };
-	}
-	if (typeof edit.write === "string") {
-		return { srcLabel: `\u2022 replace ${target}`, dst: getStreamingEditContent(edit.write) };
-	}
-	if (typeof edit.replace === "object" && edit.replace) {
-		return { srcLabel: `\u2022 replace ${target}`, dst: getStreamingEditContent(edit.replace.new) };
-	}
-	if (typeof edit.insert === "object" && edit.insert) {
-		return { srcLabel: `\u2022 ${edit.insert.loc} ${target}`, dst: getStreamingEditContent(edit.insert.body) };
+function formatMetadataLine(lineCount: number | null, language: string | undefined, uiTheme: Theme): string {
+	const icon = uiTheme.getLangIcon(language);
+	if (lineCount !== null) {
+		return uiTheme.fg("dim", `${icon} ${lineCount} lines`);
 	}
-	return { srcLabel: `\u2022 edit ${target}`, dst: "" };
+	return uiTheme.fg("dim", `${icon}`);
 }
 
-function formatStreamingHashlineEdits(edits: Partial<HashlineToolEdit | ChunkToolEdit>[], uiTheme: Theme): string {
-	let text = "\n\n";
-
-	// Detect whether these are chunk edits (target field) or hashline edits (loc field)
-	const isChunk = edits.length > 0 && isChunkStreamingEdit(edits[0]);
-	const label = isChunk ? "chunk edit" : "hashline edit";
-	const formatEdit = isChunk ? formatChunkStreamingEdit : formatHashlineStreamingEdit;
-	text += uiTheme.fg("dim", `[${edits.length} ${label}${edits.length === 1 ? "" : "s"}]`);
-	text += "\n";
-	let shownEdits = 0;
-	let shownDstLines = 0;
-	for (const edit of edits) {
-		shownEdits++;
-		if (shownEdits > STREAMING_EDIT_PREVIEW_LIMIT) break;
-		const formatted = formatEdit(edit as never);
-		text += uiTheme.fg("toolOutput", truncateToWidth(replaceTabs(formatted.srcLabel), STREAMING_EDIT_PREVIEW_WIDTH));
-		text += "\n";
-		if (formatted.dst === "") {
-			text += uiTheme.fg("dim", truncateToWidth("  (delete)", STREAMING_EDIT_PREVIEW_WIDTH));
-			text += "\n";
+function formatMultiFileStreamingDiff(previews: PerFileDiffPreview[], uiTheme: Theme): string {
+	const parts: string[] = [];
+	for (const preview of previews) {
+		if (!preview.diff && !preview.error) continue;
+		const header = uiTheme.fg("dim", `\n\n── ${shortenPath(preview.path)} ──`);
+		if (preview.error) {
+			parts.push(`${header}\n${uiTheme.fg("error", replaceTabs(preview.error))}`);
 			continue;
 		}
-		for (const dstLine of formatted.dst.split("\n")) {
-			shownDstLines++;
-			if (shownDstLines > STREAMING_EDIT_PREVIEW_DST_LINE_LIMIT) break;
-			text += uiTheme.fg("toolOutput", truncateToWidth(replaceTabs(`+ ${dstLine}`), STREAMING_EDIT_PREVIEW_WIDTH));
-			text += "\n";
+		if (preview.diff) {
+			parts.push(`${header}${formatStreamingDiff(preview.diff, preview.path, uiTheme, "preview")}`);
 		}
-		if (shownDstLines > STREAMING_EDIT_PREVIEW_DST_LINE_LIMIT) break;
 	}
-	if (edits.length > STREAMING_EDIT_PREVIEW_LIMIT) {
-		text += uiTheme.fg("dim", `\u2026 (${edits.length - STREAMING_EDIT_PREVIEW_LIMIT} more edits)`);
-	}
-	if (shownDstLines > STREAMING_EDIT_PREVIEW_DST_LINE_LIMIT) {
-		text += uiTheme.fg("dim", `\n\u2026 (${shownDstLines - STREAMING_EDIT_PREVIEW_DST_LINE_LIMIT} more dst lines)`);
-	}
-
-	return text.trimEnd();
+	return parts.join("");
 }
 
-function formatMetadataLine(lineCount: number | null, language: string | undefined, uiTheme: Theme): string {
-	const icon = uiTheme.getLangIcon(language);
-	if (lineCount !== null) {
-		return uiTheme.fg("dim", `${icon} ${lineCount} lines`);
+function getCallPreview(
+	args: EditRenderArgs,
+	rawPath: string,
+	uiTheme: Theme,
+	renderContext: EditRenderContext | undefined,
+): string {
+	const multi = renderContext?.perFileDiffPreview;
+	if (multi && multi.length > 0 && multi.some(p => p.diff || p.error)) {
+		return formatMultiFileStreamingDiff(multi, uiTheme);
 	}
-	return uiTheme.fg("dim", `${icon}`);
-}
-
-function getCallPreview(args: EditRenderArgs, rawPath: string, uiTheme: Theme): string {
 	if (args.previewDiff) {
 		return formatStreamingDiff(args.previewDiff, rawPath, uiTheme, "preview");
 	}
 	if (args.diff && args.op) {
 		return formatStreamingDiff(args.diff, rawPath, uiTheme);
 	}
-	if (args.edits && args.edits.length > 0) {
-		// Only show hashline/chunk streaming edits — replace/patch use previewDiff above
-		const first = args.edits[0];
-		if (first && typeof first === "object" && ("loc" in first || isChunkStreamingEdit(first))) {
-			return formatStreamingHashlineEdits(args.edits, uiTheme);
-		}
-	}
 	if (args.diff) {
 		return renderPlainTextPreview(args.diff, uiTheme);
 	}
@@ -446,31 +398,44 @@ function wrapEditRendererLine(line: string, width: number): string[] {
 export const editToolRenderer = {
 	mergeCallAndResult: true,
 
-	renderCall(args: EditRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component {
-		if (isVimRenderArgs(args)) {
-			return vimToolRenderer.renderCall(args, options, uiTheme);
+	renderCall(
+		args: EditRenderArgs | VimRenderArgs,
+		options: RenderResultOptions & { renderContext?: EditRenderContext },
+		uiTheme: Theme,
+	): Component {
+		const renderContext = options.renderContext;
+		// Dispatch on the explicit editMode when available; fall back to the
+		// shape probe for legacy call sites that don't thread renderContext.
+		if (renderContext?.editMode === "vim" || isVimRenderArgs(args)) {
+			return vimToolRenderer.renderCall(args as VimRenderArgs, options, uiTheme);
 		}
 
-		const applyPatchSummary = getApplyPatchRenderSummary(args, options.isPartial);
+		const editArgs = args as EditRenderArgs;
+		const applyPatchSummary = getApplyPatchRenderSummary(editArgs, options.isPartial);
 		const firstApplyPatchEntry = applyPatchSummary?.entries[0];
 		// Extract path from first edit entry when top-level path is absent (new schema)
-		const firstEdit = Array.isArray(args.edits) && args.edits.length > 0 ? args.edits[0] : undefined;
+		const firstEdit = Array.isArray(editArgs.edits) && editArgs.edits.length > 0 ? editArgs.edits[0] : undefined;
 		const rawPath =
-			args.file_path || args.path || filePathFromEditEntry(firstEdit?.path) || firstApplyPatchEntry?.path || "";
-		const rename = args.rename || firstEdit?.rename || firstEdit?.move || firstApplyPatchEntry?.rename;
-		const op = args.op || firstEdit?.op || firstApplyPatchEntry?.op;
+			editArgs.file_path ||
+			editArgs.path ||
+			filePathFromEditEntry(firstEdit?.path) ||
+			getPartialJsonEditPath(editArgs) ||
+			firstApplyPatchEntry?.path ||
+			"";
+		const rename = editArgs.rename || firstEdit?.rename || firstEdit?.move || firstApplyPatchEntry?.rename;
+		const op = editArgs.op || firstEdit?.op || firstApplyPatchEntry?.op;
 		const { description } = formatEditDescription(rawPath, uiTheme, { rename });
 		const spinner =
 			options?.spinnerFrame !== undefined ? formatStatusIcon("running", uiTheme, options.spinnerFrame) : "";
 		let text = `${formatTitle(getOperationTitle(op), uiTheme)} ${spinner ? `${spinner} ` : ""}${description}`;
 		// Show file count hint for multi-file edits
-		const fileCount = Array.isArray(args.edits)
-			? countEditFiles(args.edits)
+		const fileCount = Array.isArray(editArgs.edits)
+			? countEditFiles(editArgs.edits)
 			: (applyPatchSummary?.entries.length ?? 0);
 		if (fileCount > 1) {
 			text += uiTheme.fg("dim", ` (+${fileCount - 1} more)`);
 		}
-		text += getCallPreview(args, rawPath, uiTheme);
+		text += getCallPreview(editArgs, rawPath, uiTheme, renderContext);
 		if (applyPatchSummary?.error) {
 			text += `\n\n${uiTheme.fg("error", truncateToWidth(replaceTabs(applyPatchSummary.error), CALL_TEXT_PREVIEW_WIDTH))}`;
 		}
@@ -484,7 +449,7 @@ export const editToolRenderer = {
 		uiTheme: Theme,
 		args?: EditRenderArgs,
 	): Component {
-		if (isVimToolDetails(result.details)) {
+		if (options.renderContext?.editMode === "vim" || isVimToolDetails(result.details)) {
 			return vimToolRenderer.renderResult(
 				result as { content: Array<{ type: string; text?: string }>; details?: VimToolDetails; isError?: boolean },
 				options,

package/src/edit/streaming.ts

@@ -0,0 +1,351 @@
+/**
+ * Streaming edit preview strategies.
+ *
+ * Each edit mode owns a strategy that knows how to:
+ * - collapse partial-JSON args to the subset safe to preview
+ *   (`extractCompleteEdits`),
+ * - compute unified diff previews for the in-flight args
+ *   (`computeDiffPreview`), and
+ * - render a text placeholder while no diff exists yet
+ *   (`renderStreamingFallback`).
+ *
+ * The shared renderer / `ToolExecutionComponent` consult the strategy via
+ * the injected `editMode` rather than probing argument shape.
+ */
+import type { Theme } from "../modes/theme/theme";
+import { type EditMode, resolveEditMode } from "../utils/edit-mode";
+import { computeEditDiff, type DiffError, type DiffResult } from "./diff";
+import { expandApplyPatchToEntries, expandApplyPatchToPreviewEntries } from "./modes/apply-patch";
+import { type ChunkToolEdit, computeChunkDiff, parseChunkEditPath } from "./modes/chunk";
+import { computeHashlineDiff, type HashlineToolEdit } from "./modes/hashline";
+import { computePatchDiff, type PatchEditEntry } from "./modes/patch";
+import type { ReplaceEditEntry } from "./modes/replace";
+
+export interface PerFileDiffPreview {
+	path: string;
+	diff?: string;
+	firstChangedLine?: number;
+	error?: string;
+}
+
+export interface StreamingDiffContext {
+	cwd: string;
+	signal: AbortSignal;
+	fuzzyThreshold?: number;
+	allowFuzzy?: boolean;
+}
+
+export interface EditStreamingStrategy<Args = unknown> {
+	/**
+	 * Return the args restricted to edits that are "complete enough" to
+	 * compute a diff against. Strategies drop the trailing incomplete entry
+	 * when `partialJson` indicates its closing `}` hasn't arrived yet.
+	 */
+	extractCompleteEdits(args: Args, partialJson: string | undefined): Args;
+	/**
+	 * Compute diff(s) for the given partial args. Returns `null` when args
+	 * do not yet carry enough structure to compute anything.
+	 */
+	computeDiffPreview(args: Args, ctx: StreamingDiffContext): Promise<PerFileDiffPreview[] | null>;
+	/**
+	 * Rendered inline while the diff hasn't been computed yet (or when the
+	 * compute returned `null` because args are still too partial).
+	 */
+	renderStreamingFallback(args: Args, uiTheme: Theme): string;
+}
+
+// -----------------------------------------------------------------------------
+// Partial-JSON handling
+// -----------------------------------------------------------------------------
+
+/**
+ * Given an edits array parsed from partial JSON, drop the last entry when the
+ * corresponding object in `partialJson` does not yet end with a closed `}`.
+ *
+ * This guards against `partial-json` silently coercing truncated tails like
+ * `"write":nu` / `"write":nul` into `{ write: null }`, which would make the
+ * last entry render a spurious null-write error until the value finishes
+ * streaming.
+ */
+export function dropIncompleteLastEdit<T>(edits: readonly T[], partialJson: string | undefined, listKey: string): T[] {
+	if (!Array.isArray(edits) || edits.length === 0) return [...(edits ?? [])];
+	if (!partialJson) return [...edits];
+
+	const keyMarker = `"${listKey}"`;
+	const keyIdx = partialJson.indexOf(keyMarker);
+	if (keyIdx === -1) return [...edits];
+
+	// Find the `[` that opens the list value.
+	let i = partialJson.indexOf("[", keyIdx + keyMarker.length);
+	if (i === -1) return [...edits];
+	i++;
+
+	let depth = 0;
+	let inString = false;
+	let escaped = false;
+	let lastClose = -1;
+	for (; i < partialJson.length; i++) {
+		const ch = partialJson[i];
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (ch === "\\") {
+			if (inString) escaped = true;
+			continue;
+		}
+		if (ch === '"') {
+			inString = !inString;
+			continue;
+		}
+		if (inString) continue;
+		if (ch === "{" || ch === "[") {
+			depth++;
+		} else if (ch === "}" || ch === "]") {
+			depth--;
+			if (ch === "}" && depth === 0) {
+				lastClose = i;
+			}
+			if (ch === "]" && depth === -1) {
+				// End of list reached.
+				break;
+			}
+		}
+	}
+
+	// If we're still inside the list and saw no closing `}` for the last entry,
+	// or there is trailing non-whitespace after the last `}` before the list
+	// ended (i.e. a new object has opened), drop the trailing entry.
+	const tail = lastClose === -1 ? partialJson.slice(i) : partialJson.slice(lastClose + 1);
+	const sawNewObjectAfterLastClose = /\{/.test(tail);
+	const listIsStillOpen = depth >= 0;
+
+	if (lastClose === -1 || (listIsStillOpen && sawNewObjectAfterLastClose)) {
+		return edits.slice(0, -1);
+	}
+	return [...edits];
+}
+
+// -----------------------------------------------------------------------------
+// Strategies
+// -----------------------------------------------------------------------------
+
+interface ReplaceArgs {
+	edits?: ReplaceEditEntry[];
+	__partialJson?: string;
+}
+
+const replaceStrategy: EditStreamingStrategy<ReplaceArgs> = {
+	extractCompleteEdits(args, partialJson) {
+		if (!args?.edits) return args;
+		return { ...args, edits: dropIncompleteLastEdit(args.edits, partialJson, "edits") };
+	},
+	async computeDiffPreview(args, ctx) {
+		const first = args.edits?.[0];
+		if (!first?.path || first.old_text === undefined || first.new_text === undefined) return null;
+		ctx.signal.throwIfAborted();
+		const result = await computeEditDiff(
+			first.path,
+			first.old_text,
+			first.new_text,
+			ctx.cwd,
+			ctx.allowFuzzy ?? true,
+			first.all,
+			ctx.fuzzyThreshold,
+		);
+		ctx.signal.throwIfAborted();
+		return [toPerFilePreview(first.path, result)];
+	},
+	renderStreamingFallback() {
+		return "";
+	},
+};
+
+interface PatchArgs {
+	edits?: PatchEditEntry[];
+	__partialJson?: string;
+}
+
+const patchStrategy: EditStreamingStrategy<PatchArgs> = {
+	extractCompleteEdits(args, partialJson) {
+		if (!args?.edits) return args;
+		return { ...args, edits: dropIncompleteLastEdit(args.edits, partialJson, "edits") };
+	},
+	async computeDiffPreview(args, ctx) {
+		const first = args.edits?.[0];
+		if (!first?.path) return null;
+		ctx.signal.throwIfAborted();
+		const result = await computePatchDiff(
+			{ path: first.path, op: first.op ?? "update", rename: first.rename, diff: first.diff },
+			ctx.cwd,
+			{ fuzzyThreshold: ctx.fuzzyThreshold, allowFuzzy: ctx.allowFuzzy },
+		);
+		ctx.signal.throwIfAborted();
+		return [toPerFilePreview(first.path, result)];
+	},
+	renderStreamingFallback() {
+		return "";
+	},
+};
+
+interface HashlineArgs {
+	edits?: HashlineToolEdit[];
+	move?: string;
+	__partialJson?: string;
+}
+
+const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
+	extractCompleteEdits(args, partialJson) {
+		if (!args?.edits) return args;
+		return { ...args, edits: dropIncompleteLastEdit(args.edits, partialJson, "edits") };
+	},
+	async computeDiffPreview(args, ctx) {
+		const first = args.edits?.[0] as (HashlineToolEdit & { path?: string }) | undefined;
+		if (!first?.path) return null;
+		const path = first.path;
+		const fileEdits = (args.edits ?? []).filter((e): e is HashlineToolEdit & { path: string } => {
+			return !!e && typeof e === "object" && (e as { path?: string }).path === path;
+		});
+		ctx.signal.throwIfAborted();
+		const result = await computeHashlineDiff({ path, edits: fileEdits, move: args.move }, ctx.cwd);
+		ctx.signal.throwIfAborted();
+		return [toPerFilePreview(path, result)];
+	},
+	renderStreamingFallback() {
+		return "";
+	},
+};
+
+interface ChunkArgs {
+	edits?: ChunkToolEdit[];
+	__partialJson?: string;
+}
+
+const chunkStrategy: EditStreamingStrategy<ChunkArgs> = {
+	extractCompleteEdits(args, partialJson) {
+		if (!args?.edits) return args;
+		let edits = dropIncompleteLastEdit(args.edits, partialJson, "edits");
+		// Extra guard: if partial JSON still contains `":nu` / `":nul` (partial
+		// `null` literals), `partial-json` may have already surfaced the last
+		// entry with `write === null`. When that entry's `}` hasn't closed
+		// yet, it has already been dropped above. But if dropping was not
+		// triggered (e.g. list still open and no new `{` after), also drop the
+		// trailing null-write entry so the preview does not flicker with an
+		// error for an incomplete string/null literal.
+		if (partialJson && edits.length > 0) {
+			const last = edits[edits.length - 1] as Partial<ChunkToolEdit> | undefined;
+			const endsInPartialNull = /:\s*nu?l?\s*$/.test(partialJson.trimEnd());
+			if (last && endsInPartialNull && last.write === null) {
+				edits = edits.slice(0, -1);
+			}
+		}
+		return { ...args, edits };
+	},
+	async computeDiffPreview(args, ctx) {
+		const edits = args.edits ?? [];
+		if (edits.length === 0) return null;
+		// Group edits by file path
+		const groups = new Map<string, ChunkToolEdit[]>();
+		const fileOrder: string[] = [];
+		for (const edit of edits) {
+			if (!edit?.path) continue;
+			const { filePath } = parseChunkEditPath(edit.path);
+			if (!filePath) continue;
+			let bucket = groups.get(filePath);
+			if (!bucket) {
+				bucket = [];
+				groups.set(filePath, bucket);
+				fileOrder.push(filePath);
+			}
+			bucket.push(edit);
+		}
+		if (fileOrder.length === 0) return null;
+
+		const MAX_FILES = 5;
+		const selected = fileOrder.slice(0, MAX_FILES);
+		const previews: PerFileDiffPreview[] = [];
+		for (const filePath of selected) {
+			ctx.signal.throwIfAborted();
+			const fileEdits = groups.get(filePath) ?? [];
+			const result = await computeChunkDiff({ path: filePath, edits: fileEdits }, ctx.cwd, { signal: ctx.signal });
+			previews.push(toPerFilePreview(filePath, result));
+		}
+		return previews;
+	},
+	renderStreamingFallback() {
+		return "";
+	},
+};
+
+interface ApplyPatchArgs {
+	input?: string;
+}
+
+const applyPatchStrategy: EditStreamingStrategy<ApplyPatchArgs> = {
+	extractCompleteEdits(args) {
+		// Apply_patch payload is plain text, not an edits array. Nothing to trim.
+		return args;
+	},
+	async computeDiffPreview(args, ctx) {
+		if (typeof args.input !== "string" || args.input.length === 0) return null;
+		let entries: PatchEditEntry[];
+		try {
+			entries = expandApplyPatchToEntries({ input: args.input });
+		} catch {
+			try {
+				entries = expandApplyPatchToPreviewEntries({ input: args.input });
+			} catch (err) {
+				return [{ path: "", error: err instanceof Error ? err.message : String(err) }];
+			}
+		}
+		const first = entries[0];
+		if (!first?.path) return null;
+		ctx.signal.throwIfAborted();
+		const result = await computePatchDiff(
+			{ path: first.path, op: first.op ?? "update", rename: first.rename, diff: first.diff },
+			ctx.cwd,
+			{ fuzzyThreshold: ctx.fuzzyThreshold, allowFuzzy: ctx.allowFuzzy },
+		);
+		ctx.signal.throwIfAborted();
+		return [toPerFilePreview(first.path, result)];
+	},
+	renderStreamingFallback() {
+		return "";
+	},
+};
+
+// Vim streaming preview is handled by the existing vimToolRenderer inside
+// edit/renderer.ts. The strategy here is a no-op so the registry is total.
+const vimStrategy: EditStreamingStrategy<unknown> = {
+	extractCompleteEdits(args) {
+		return args;
+	},
+	async computeDiffPreview() {
+		return null;
+	},
+	renderStreamingFallback() {
+		return "";
+	},
+};
+
+export const EDIT_MODE_STRATEGIES: Record<EditMode, EditStreamingStrategy<unknown>> = {
+	replace: replaceStrategy as EditStreamingStrategy<unknown>,
+	patch: patchStrategy as EditStreamingStrategy<unknown>,
+	hashline: hashlineStrategy as EditStreamingStrategy<unknown>,
+	chunk: chunkStrategy as EditStreamingStrategy<unknown>,
+	apply_patch: applyPatchStrategy as EditStreamingStrategy<unknown>,
+	vim: vimStrategy,
+};
+
+export { resolveEditMode };
+
+// -----------------------------------------------------------------------------
+// Helpers
+// -----------------------------------------------------------------------------
+
+function toPerFilePreview(path: string, result: DiffResult | DiffError): PerFileDiffPreview {
+	if ("error" in result) {
+		return { path, error: result.error };
+	}
+	return { path, diff: result.diff, firstChangedLine: result.firstChangedLine };
+}