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

package/src/{patch → edit}/normalize.ts

@@ -70,12 +70,16 @@ export function getLeadingWhitespace(line: string): string {
 	return line.slice(0, countLeadingWhitespace(line));
 }
 
+function isNonEmptyLine(line: string): boolean {
+	return line.trim().length > 0;
+}
+
 /** Compute minimum indentation of non-empty lines */
 export function minIndent(text: string): number {
 	const lines = text.split("\n");
 	let min = Infinity;
 	for (const line of lines) {
-		if (line.trim().length > 0) {
+		if (isNonEmptyLine(line)) {
 			min = Math.min(min, countLeadingWhitespace(line));
 		}
 	}
@@ -107,9 +111,7 @@ function gcd(a: number, b: number): number {
 
 interface IndentProfile {
 	lines: string[];
-	indentStrings: string[];
 	indentCounts: number[];
-	min: number;
 	char: " " | "\t" | undefined;
 	spaceOnly: boolean;
 	tabOnly: boolean;
@@ -120,9 +122,7 @@ interface IndentProfile {
 
 function buildIndentProfile(text: string): IndentProfile {
 	const lines = text.split("\n");
-	const indentStrings: string[] = [];
 	const indentCounts: number[] = [];
-	let min = Infinity;
 	let char: " " | "\t" | undefined;
 	let spaceOnly = true;
 	let tabOnly = true;
@@ -131,12 +131,10 @@ function buildIndentProfile(text: string): IndentProfile {
 	let unit = 0;
 
 	for (const line of lines) {
-		if (line.trim().length === 0) continue;
+		if (!isNonEmptyLine(line)) continue;
 		nonEmptyCount++;
 		const indent = getLeadingWhitespace(line);
-		indentStrings.push(indent);
 		indentCounts.push(indent.length);
-		min = Math.min(min, indent.length);
 		if (indent.includes(" ")) {
 			tabOnly = false;
 		}
@@ -156,10 +154,6 @@ function buildIndentProfile(text: string): IndentProfile {
 		}
 	}
 
-	if (min === Infinity) {
-		min = 0;
-	}
-
 	if (spaceOnly && nonEmptyCount > 0) {
 		let current = 0;
 		for (const count of indentCounts) {
@@ -175,9 +169,7 @@ function buildIndentProfile(text: string): IndentProfile {
 
 	return {
 		lines,
-		indentStrings,
 		indentCounts,
-		min,
 		char,
 		spaceOnly,
 		tabOnly,
@@ -246,6 +238,87 @@ export function normalizeForFuzzy(line: string): string {
 		.replace(/[ \t]+/g, " ");
 }
 
+function isIndentationOnlyRewrite(oldText: string, newText: string): boolean {
+	const oldLines = oldText.split("\n");
+	const newLines = newText.split("\n");
+	if (oldLines.length !== newLines.length) {
+		return false;
+	}
+	for (let i = 0; i < oldLines.length; i++) {
+		if (oldLines[i].trim() !== newLines[i].trim()) {
+			return false;
+		}
+	}
+	return true;
+}
+
+function maybeConvertTabIndentation(
+	oldProfile: IndentProfile,
+	actualProfile: IndentProfile,
+	newProfile: IndentProfile,
+	newText: string,
+): string | undefined {
+	if (!actualProfile.spaceOnly || !oldProfile.tabOnly || !newProfile.tabOnly || actualProfile.unit <= 0) {
+		return undefined;
+	}
+
+	const lineCount = Math.min(oldProfile.lines.length, actualProfile.lines.length);
+	for (let i = 0; i < lineCount; i++) {
+		const oldLine = oldProfile.lines[i];
+		const actualLine = actualProfile.lines[i];
+		if (!isNonEmptyLine(oldLine) || !isNonEmptyLine(actualLine)) continue;
+		const oldIndent = getLeadingWhitespace(oldLine);
+		if (oldIndent.length === 0) continue;
+		const actualIndent = getLeadingWhitespace(actualLine);
+		if (actualIndent.length !== oldIndent.length * actualProfile.unit) {
+			return undefined;
+		}
+	}
+
+	return convertLeadingTabsToSpaces(newText, actualProfile.unit);
+}
+
+function computeUniformIndentDelta(oldProfile: IndentProfile, actualProfile: IndentProfile): number | undefined {
+	const lineCount = Math.min(oldProfile.lines.length, actualProfile.lines.length);
+	const deltas: number[] = [];
+	for (let i = 0; i < lineCount; i++) {
+		const oldLine = oldProfile.lines[i];
+		const actualLine = actualProfile.lines[i];
+		if (!isNonEmptyLine(oldLine) || !isNonEmptyLine(actualLine)) continue;
+		deltas.push(countLeadingWhitespace(actualLine) - countLeadingWhitespace(oldLine));
+	}
+
+	if (deltas.length === 0) {
+		return undefined;
+	}
+
+	const delta = deltas[0];
+	return deltas.every(value => value === delta) ? delta : undefined;
+}
+
+function applyIndentDelta(text: string, delta: number, indentChar: string): string {
+	const adjusted = text.split("\n").map(line => {
+		if (!isNonEmptyLine(line)) {
+			return line;
+		}
+		if (delta > 0) {
+			return indentChar.repeat(delta) + line;
+		}
+		const toRemove = Math.min(-delta, countLeadingWhitespace(line));
+		return line.slice(toRemove);
+	});
+
+	return adjusted.join("\n");
+}
+
+function hasNonEmptyIndentProfiles(...profiles: IndentProfile[]): boolean {
+	return profiles.every(profile => profile.nonEmptyCount > 0);
+}
+
+function hasMixedIndentation(...profiles: IndentProfile[]): boolean {
+	return profiles.some(profile => profile.mixed);
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Indentation Adjustment
 // ═══════════════════════════════════════════════════════════════════════════
@@ -264,73 +337,32 @@ export function adjustIndentation(oldText: string, actualText: string, newText:
 	}
 
 	// If the patch is purely an indentation change (same trimmed content), apply exactly as specified
-	const oldLines = oldText.split("\n");
-	const newLines = newText.split("\n");
-	if (oldLines.length === newLines.length) {
-		let indentationOnly = true;
-		for (let i = 0; i < oldLines.length; i++) {
-			if (oldLines[i].trim() !== newLines[i].trim()) {
-				indentationOnly = false;
-				break;
-			}
-		}
-		if (indentationOnly) {
-			return newText;
-		}
+	if (isIndentationOnlyRewrite(oldText, newText)) {
+		return newText;
 	}
 
 	const oldProfile = buildIndentProfile(oldText);
 	const actualProfile = buildIndentProfile(actualText);
 	const newProfile = buildIndentProfile(newText);
 
-	if (newProfile.nonEmptyCount === 0 || oldProfile.nonEmptyCount === 0 || actualProfile.nonEmptyCount === 0) {
+	if (!hasNonEmptyIndentProfiles(oldProfile, actualProfile, newProfile)) {
 		return newText;
 	}
 
-	if (oldProfile.mixed || actualProfile.mixed || newProfile.mixed) {
+	if (hasMixedIndentation(oldProfile, actualProfile, newProfile)) {
 		return newText;
 	}
 
 	if (oldProfile.char && actualProfile.char && oldProfile.char !== actualProfile.char) {
-		if (actualProfile.spaceOnly && oldProfile.tabOnly && newProfile.tabOnly && actualProfile.unit > 0) {
-			let consistent = true;
-			const lineCount = Math.min(oldProfile.lines.length, actualProfile.lines.length);
-			for (let i = 0; i < lineCount; i++) {
-				const oldLine = oldProfile.lines[i];
-				const actualLine = actualProfile.lines[i];
-				if (oldLine.trim().length === 0 || actualLine.trim().length === 0) continue;
-				const oldIndent = getLeadingWhitespace(oldLine);
-				const actualIndent = getLeadingWhitespace(actualLine);
-				if (oldIndent.length === 0) continue;
-				if (actualIndent.length !== oldIndent.length * actualProfile.unit) {
-					consistent = false;
-					break;
-				}
-			}
-			return consistent ? convertLeadingTabsToSpaces(newText, actualProfile.unit) : newText;
+		const converted = maybeConvertTabIndentation(oldProfile, actualProfile, newProfile, newText);
+		if (converted !== undefined) {
+			return converted;
 		}
 		return newText;
 	}
 
-	const lineCount = Math.min(oldProfile.lines.length, actualProfile.lines.length);
-	const deltas: number[] = [];
-	for (let i = 0; i < lineCount; i++) {
-		const oldLine = oldProfile.lines[i];
-		const actualLine = actualProfile.lines[i];
-		if (oldLine.trim().length === 0 || actualLine.trim().length === 0) continue;
-		deltas.push(countLeadingWhitespace(actualLine) - countLeadingWhitespace(oldLine));
-	}
-
-	if (deltas.length === 0) {
-		return newText;
-	}
-
-	const delta = deltas[0];
-	if (!deltas.every(value => value === delta)) {
-		return newText;
-	}
-
-	if (delta === 0) {
+	const delta = computeUniformIndentDelta(oldProfile, actualProfile);
+	if (delta === undefined || delta === 0) {
 		return newText;
 	}
 
@@ -339,16 +371,5 @@ export function adjustIndentation(oldText: string, actualText: string, newText:
 	}
 
 	const indentChar = actualProfile.char ?? oldProfile.char ?? detectIndentChar(actualText);
-	const adjusted = newText.split("\n").map(line => {
-		if (line.trim().length === 0) {
-			return line;
-		}
-		if (delta > 0) {
-			return indentChar.repeat(delta) + line;
-		}
-		const toRemove = Math.min(-delta, countLeadingWhitespace(line));
-		return line.slice(toRemove);
-	});
-
-	return adjusted.join("\n");
+	return applyIndentDelta(newText, delta, indentChar);
 }

package/src/{patch/shared.ts → edit/renderer.ts}

@@ -1,5 +1,5 @@
 /**
- * Shared utilities for edit tool TUI rendering.
+ * Edit tool renderer and LSP batching helpers.
  */
 import type { ToolCallContext } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
@@ -22,8 +22,10 @@ import {
 	truncateDiffByHunk,
 } from "../tools/render-utils";
 import { Hasher, type RenderCache, renderStatusLine, truncateToWidth } from "../tui";
-import type { HashlineToolEdit } from "./index";
-import type { DiffError, DiffResult, Operation } from "./types";
+import type { DiffError, DiffResult } from "./diff";
+import type { ChunkToolEdit } from "./modes/chunk";
+import type { HashlineToolEdit } from "./modes/hashline";
+import type { Operation } from "./modes/patch";
 
 // ═══════════════════════════════════════════════════════════════════════════
 // LSP Batching
@@ -31,7 +33,12 @@ import type { DiffError, DiffResult, Operation } from "./types";
 
 const LSP_BATCH_TOOLS = new Set(["edit", "write"]);
 
-export function getLspBatchRequest(toolCall: ToolCallContext | undefined): { id: string; flush: boolean } | undefined {
+export interface LspBatchRequest {
+	id: string;
+	flush: boolean;
+}
+
+export function getLspBatchRequest(toolCall: ToolCallContext | undefined): LspBatchRequest | undefined {
 	if (!toolCall) {
 		return undefined;
 	}
@@ -83,8 +90,8 @@ interface EditRenderArgs {
 	 * Computed preview diff (used when tool args don't include a diff, e.g. hashline mode).
 	 */
 	previewDiff?: string;
-	// Hashline mode fields
-	edits?: Partial<HashlineToolEdit>[];
+	// Hashline / chunk mode fields
+	edits?: Partial<HashlineToolEdit | ChunkToolEdit>[];
 }
 
 /** Extended context for edit tool rendering */
@@ -96,12 +103,69 @@ 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;
+}
 
 function countLines(text: string): number {
 	if (!text) return 0;
 	return text.split("\n").length;
 }
 
+function getOperationTitle(op: Operation | undefined): string {
+	return op === "create" ? "Create" : op === "delete" ? "Delete" : "Edit";
+}
+
+function formatEditPathDisplay(
+	rawPath: string,
+	uiTheme: Theme,
+	options?: { rename?: string; firstChangedLine?: number },
+): string {
+	let pathDisplay = rawPath ? uiTheme.fg("accent", shortenPath(rawPath)) : uiTheme.fg("toolOutput", "…");
+
+	if (options?.firstChangedLine) {
+		pathDisplay += uiTheme.fg("warning", `:${options.firstChangedLine}`);
+	}
+
+	if (options?.rename) {
+		pathDisplay += ` ${uiTheme.fg("dim", "→")} ${uiTheme.fg("accent", shortenPath(options.rename))}`;
+	}
+
+	return pathDisplay;
+}
+
+function formatEditDescription(
+	rawPath: string,
+	uiTheme: Theme,
+	options?: { rename?: string; firstChangedLine?: number },
+): { language: string; description: string } {
+	const language = getLanguageFromPath(rawPath) ?? "text";
+	const icon = uiTheme.fg("muted", uiTheme.getLangIcon(language));
+	return {
+		language,
+		description: `${icon} ${formatEditPathDisplay(rawPath, uiTheme, options)}`,
+	};
+}
+
+function renderPlainTextPreview(text: string, uiTheme: Theme): string {
+	const previewLines = text.split("\n");
+	let preview = "\n\n";
+	for (const line of previewLines.slice(0, CALL_TEXT_PREVIEW_LINES)) {
+		preview += `${uiTheme.fg("toolOutput", truncateToWidth(replaceTabs(line), CALL_TEXT_PREVIEW_WIDTH))}\n`;
+	}
+	if (previewLines.length > CALL_TEXT_PREVIEW_LINES) {
+		preview += uiTheme.fg("dim", `… ${previewLines.length - CALL_TEXT_PREVIEW_LINES} more lines`);
+	}
+	return preview.trimEnd();
+}
+
 function formatStreamingDiff(diff: string, rawPath: string, uiTheme: Theme, label = "streaming"): string {
 	if (!diff) return "";
 	const lines = diff.split("\n");
@@ -117,69 +181,111 @@ function formatStreamingDiff(diff: string, rawPath: string, uiTheme: Theme, labe
 	return text;
 }
 
-function formatStreamingHashlineEdits(edits: Partial<HashlineToolEdit>[], uiTheme: Theme): string {
-	const MAX_EDITS = 4;
-	const MAX_DST_LINES = 8;
+function isChunkStreamingEdit(edit: Partial<HashlineToolEdit | ChunkToolEdit>): edit is Partial<ChunkToolEdit> {
+	return "sel" 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 contentLines = getStreamingEditContent(edit.content);
+	const target = edit.sel ?? "?";
+	const op = edit.op ?? "replace";
+
+	switch (op) {
+		case "append":
+			return { srcLabel: `\u2022 append ${target}`, dst: contentLines };
+		case "prepend":
+			return { srcLabel: `\u2022 prepend ${target}`, dst: contentLines };
+		case "after":
+			return { srcLabel: `\u2022 insert after ${target}`, dst: contentLines };
+		case "before":
+			return { srcLabel: `\u2022 insert before ${target}`, dst: contentLines };
+		default:
+			return {
+				srcLabel: contentLines.length === 0 ? `\u2022 remove ${target}` : `\u2022 replace ${target}`,
+				dst: contentLines,
+			};
+	}
+}
+
+function formatStreamingHashlineEdits(edits: Partial<HashlineToolEdit | ChunkToolEdit>[], uiTheme: Theme): string {
 	let text = "\n\n";
-	text += uiTheme.fg("dim", `[${edits.length} hashline edit${edits.length === 1 ? "" : "s"}]`);
+
+	// 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 > MAX_EDITS) break;
-		const formatted = formatHashlineEdit(edit);
-		text += uiTheme.fg("toolOutput", truncateToWidth(replaceTabs(formatted.srcLabel), 120));
+		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)", 120));
+			text += uiTheme.fg("dim", truncateToWidth("  (delete)", STREAMING_EDIT_PREVIEW_WIDTH));
 			text += "\n";
 			continue;
 		}
 		for (const dstLine of formatted.dst.split("\n")) {
 			shownDstLines++;
-			if (shownDstLines > MAX_DST_LINES) break;
-			text += uiTheme.fg("toolOutput", truncateToWidth(replaceTabs(`+ ${dstLine}`), 120));
+			if (shownDstLines > STREAMING_EDIT_PREVIEW_DST_LINE_LIMIT) break;
+			text += uiTheme.fg("toolOutput", truncateToWidth(replaceTabs(`+ ${dstLine}`), STREAMING_EDIT_PREVIEW_WIDTH));
 			text += "\n";
 		}
-		if (shownDstLines > MAX_DST_LINES) break;
+		if (shownDstLines > STREAMING_EDIT_PREVIEW_DST_LINE_LIMIT) break;
 	}
-	if (edits.length > MAX_EDITS) {
-		text += uiTheme.fg("dim", `… (${edits.length - MAX_EDITS} more edits)`);
+	if (edits.length > STREAMING_EDIT_PREVIEW_LIMIT) {
+		text += uiTheme.fg("dim", `\u2026 (${edits.length - STREAMING_EDIT_PREVIEW_LIMIT} more edits)`);
 	}
-	if (shownDstLines > MAX_DST_LINES) {
-		text += uiTheme.fg("dim", `\n… (${shownDstLines - MAX_DST_LINES} more dst lines)`);
+	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();
-	function formatHashlineEdit(edit: Partial<HashlineToolEdit>): { srcLabel: string; dst: string } {
-		if (typeof edit !== "object" || !edit) {
-			return { srcLabel: "• (incomplete edit)", dst: "" };
-		}
-
-		const contentLines = Array.isArray(edit.content) ? (edit.content as string[]).join("\n") : "";
-		const loc = edit.loc;
-
-		if (loc === "append" || loc === "prepend") {
-			return { srcLabel: `• ${loc} (file-level)`, dst: contentLines };
-		}
-		if (typeof loc === "object" && loc) {
-			if ("range" in loc && typeof loc.range === "object" && loc.range) {
-				return { srcLabel: `• range ${loc.range.pos ?? "?"}…${loc.range.end ?? "?"}`, dst: contentLines };
-			}
-			if ("line" in loc) {
-				return { srcLabel: `• line ${(loc as { line: string }).line}`, dst: contentLines };
-			}
-			if ("append" in loc) {
-				return { srcLabel: `• append ${(loc as { append: string }).append}`, dst: contentLines };
-			}
-			if ("prepend" in loc) {
-				return { srcLabel: `• prepend ${(loc as { prepend: string }).prepend}`, dst: contentLines };
-			}
-		}
-		return { srcLabel: "• (unknown edit)", dst: contentLines };
-	}
 }
+
 function formatMetadataLine(lineCount: number | null, language: string | undefined, uiTheme: Theme): string {
 	const icon = uiTheme.getLangIcon(language);
 	if (lineCount !== null) {
@@ -188,6 +294,25 @@ function formatMetadataLine(lineCount: number | null, language: string | undefin
 	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) {
+		return formatStreamingHashlineEdits(args.edits, uiTheme);
+	}
+	if (args.diff) {
+		return renderPlainTextPreview(args.diff, uiTheme);
+	}
+	if (args.newText || args.patch) {
+		return renderPlainTextPreview(args.newText ?? args.patch ?? "", uiTheme);
+	}
+	return "";
+}
+
 function renderDiffSection(
 	diff: string,
 	rawPath: string,
@@ -252,50 +377,11 @@ export const editToolRenderer = {
 
 	renderCall(args: EditRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component {
 		const rawPath = args.file_path || args.path || "";
-		const filePath = shortenPath(rawPath);
-		const editLanguage = getLanguageFromPath(rawPath) ?? "text";
-		const editIcon = uiTheme.fg("muted", uiTheme.getLangIcon(editLanguage));
-		let pathDisplay = filePath ? uiTheme.fg("accent", filePath) : uiTheme.fg("toolOutput", "…");
-
-		// Add arrow for move/rename operations
-		if (args.rename) {
-			pathDisplay += ` ${uiTheme.fg("dim", "→")} ${uiTheme.fg("accent", shortenPath(args.rename))}`;
-		}
-
-		// Show operation type for patch mode
-		const opTitle = args.op === "create" ? "Create" : args.op === "delete" ? "Delete" : "Edit";
+		const { description } = formatEditDescription(rawPath, uiTheme, { rename: args.rename });
 		const spinner =
 			options?.spinnerFrame !== undefined ? formatStatusIcon("running", uiTheme, options.spinnerFrame) : "";
-		let text = `${formatTitle(opTitle, uiTheme)} ${spinner ? `${spinner} ` : ""}${editIcon} ${pathDisplay}`;
-
-		// Show streaming preview of diff/content
-		if (args.previewDiff) {
-			text += formatStreamingDiff(args.previewDiff, rawPath, uiTheme, "preview");
-		} else if (args.diff && args.op) {
-			text += formatStreamingDiff(args.diff, rawPath, uiTheme);
-		} else if (args.edits && args.edits.length > 0) {
-			text += formatStreamingHashlineEdits(args.edits, uiTheme);
-		} else if (args.diff) {
-			const previewLines = args.diff.split("\n");
-			const maxLines = 6;
-			text += "\n\n";
-			for (const line of previewLines.slice(0, maxLines)) {
-				text += `${uiTheme.fg("toolOutput", truncateToWidth(replaceTabs(line), 80))}\n`;
-			}
-			if (previewLines.length > maxLines) {
-				text += uiTheme.fg("dim", `… ${previewLines.length - maxLines} more lines`);
-			}
-		} else if (args.newText || args.patch) {
-			const previewLines = (args.newText ?? args.patch ?? "").split("\n");
-			const maxLines = 6;
-			text += "\n\n";
-			for (const line of previewLines.slice(0, maxLines)) {
-				text += `${uiTheme.fg("toolOutput", truncateToWidth(replaceTabs(line), 80))}\n`;
-			}
-			if (previewLines.length > maxLines) {
-				text += uiTheme.fg("dim", `… ${previewLines.length - maxLines} more lines`);
-			}
-		}
+		let text = `${formatTitle(getOperationTitle(args.op), uiTheme)} ${spinner ? `${spinner} ` : ""}${description}`;
+		text += getCallPreview(args, rawPath, uiTheme);
 
 		return new Text(text, 0, 0);
 	},
@@ -307,18 +393,14 @@ export const editToolRenderer = {
 		args?: EditRenderArgs,
 	): Component {
 		const rawPath = args?.file_path || args?.path || "";
-		const filePath = shortenPath(rawPath);
-		const editLanguage = getLanguageFromPath(rawPath) ?? "text";
-		const editIcon = uiTheme.fg("muted", uiTheme.getLangIcon(editLanguage));
-
 		const op = args?.op || result.details?.op;
 		const rename = args?.rename || result.details?.move;
-		const opTitle = op === "create" ? "Create" : op === "delete" ? "Delete" : "Edit";
+		const { language } = formatEditDescription(rawPath, uiTheme, { rename });
 
 		// Pre-compute metadata line (static across renders)
 		const metadataLine =
 			op !== "delete"
-				? `\n${formatMetadataLine(countLines(args?.newText ?? args?.oldText ?? args?.diff ?? args?.patch ?? ""), editLanguage, uiTheme)}`
+				? `\n${formatMetadataLine(countLines(args?.newText ?? args?.oldText ?? args?.diff ?? args?.patch ?? ""), language, uiTheme)}`
 				: "";
 
 		// Pre-compute error text (static)
@@ -334,26 +416,17 @@ export const editToolRenderer = {
 				const key = new Hasher().bool(expanded).u32(width).digest();
 				if (cached?.key === key) return cached.lines;
 
-				// Build path display with line number
-				let pathDisplay = filePath ? uiTheme.fg("accent", filePath) : uiTheme.fg("toolOutput", "…");
 				const firstChangedLine =
 					(editDiffPreview && "firstChangedLine" in editDiffPreview
 						? editDiffPreview.firstChangedLine
 						: undefined) || (result.details && !result.isError ? result.details.firstChangedLine : undefined);
-				if (firstChangedLine) {
-					pathDisplay += uiTheme.fg("warning", `:${firstChangedLine}`);
-				}
-
-				// Add arrow for rename operations
-				if (rename) {
-					pathDisplay += ` ${uiTheme.fg("dim", "→")} ${uiTheme.fg("accent", shortenPath(rename))}`;
-				}
+				const { description } = formatEditDescription(rawPath, uiTheme, { rename, firstChangedLine });
 
 				const header = renderStatusLine(
 					{
 						icon: result.isError ? "error" : "success",
-						title: opTitle,
-						description: `${editIcon} ${pathDisplay}`,
+						title: getOperationTitle(op),
+						description,
 					},
 					uiTheme,
 				);

package/src/exec/bash-executor.ts

@@ -155,8 +155,10 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 						timeoutMs: options?.timeout,
 						signal: runAbortController.signal,
 					},
-					chunk => {
-						enqueueChunk(chunk);
+					(err, chunk) => {
+						if (!err) {
+							enqueueChunk(chunk);
+						}
 					},
 				);