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

package/src/edit/modes/patch.ts

@@ -1577,7 +1577,7 @@ export async function computePatchDiff(
 }
 
 export const patchEditEntrySchema = Type.Object({
-	path: Type.String({ description: "File path" }),
+	path: Type.Optional(Type.String({ description: "File path (omit to use top-level `path`)" })),
 	op: Type.Optional(
 		StringEnum(["create", "delete", "update"], {
 			description: "Operation (default: update)",
@@ -1588,6 +1588,7 @@ export const patchEditEntrySchema = Type.Object({
 });
 
 export const patchEditSchema = Type.Object({
+	path: Type.Optional(Type.String({ description: "Default file path used when an edit omits its own `path`" })),
 	edits: Type.Array(patchEditEntrySchema, { description: "Patch operations", minItems: 1 }),
 });
 
@@ -1605,14 +1606,6 @@ export interface ExecutePatchSingleOptions {
 	beginDeferredDiagnosticsForPath: (path: string) => WritethroughDeferredHandle;
 }
 
-export function isPatchParams(params: unknown): params is PatchParams {
-	if (typeof params !== "object" || params === null) return false;
-	if (!("edits" in params) || !Array.isArray((params as any).edits)) return false;
-	const first = (params as any).edits[0];
-	if (!first || typeof first !== "object") return false;
-	return "path" in first && !("old_text" in first) && !("new_text" in first);
-}
-
 class LspFileSystem implements FileSystem {
 	#lastDiagnostics: FileDiagnosticsResult | undefined;
 	#fileCache: Record<string, Bun.BunFile> = {};
@@ -1710,6 +1703,9 @@ export async function executePatchSingle(
 		beginDeferredDiagnosticsForPath,
 	} = options;
 	const { path, op: rawOp, rename, diff } = params;
+	if (typeof path !== "string" || path.length === 0) {
+		throw new Error("patch edit: missing `path`. Provide `path` on the edit or supply a top-level `path`.");
+	}
 
 	const op: Operation = rawOp === "create" || rawOp === "delete" ? rawOp : "update";
 

package/src/edit/modes/replace.ts

@@ -977,13 +977,14 @@ export function findContextLine(
 }
 
 export const replaceEditEntrySchema = Type.Object({
-	path: Type.String({ description: "File path (relative or absolute)" }),
+	path: Type.Optional(Type.String({ description: "File path (omit to use top-level `path`)" })),
 	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)" })),
 });
 
 export const replaceEditSchema = Type.Object({
+	path: Type.Optional(Type.String({ description: "Default file path used when an edit omits its own `path`" })),
 	edits: Type.Array(replaceEditEntrySchema, { description: "Replacements", minItems: 1 }),
 });
 
@@ -1001,13 +1002,6 @@ export interface ExecuteReplaceSingleOptions {
 	beginDeferredDiagnosticsForPath: (path: string) => WritethroughDeferredHandle;
 }
 
-export function isReplaceParams(params: unknown): params is ReplaceParams {
-	if (typeof params !== "object" || params === null) return false;
-	if (!("edits" in params) || !Array.isArray((params as any).edits)) return false;
-	const first = (params as any).edits[0];
-	return first && typeof first === "object" && "old_text" in first && "new_text" in first;
-}
-
 export async function executeReplaceSingle(
 	options: ExecuteReplaceSingleOptions,
 ): Promise<AgentToolResult<EditToolDetails, typeof replaceEditEntrySchema>> {
@@ -1022,6 +1016,9 @@ export async function executeReplaceSingle(
 		beginDeferredDiagnosticsForPath,
 	} = options;
 	const { path, old_text, new_text, all } = params;
+	if (typeof path !== "string" || path.length === 0) {
+		throw new Error("replace edit: missing `path`. Provide `path` on the edit or supply a top-level `path`.");
+	}
 
 	enforcePlanModeWrite(session, path);
 
@@ -1065,9 +1062,7 @@ export async function executeReplaceSingle(
 	}
 
 	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.`,
-		);
+		throw new Error(`Edits to ${path} resulted in no changes being made.`);
 	}
 
 	const finalContent = bom + restoreLineEndings(result.content, originalEnding);

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
@@ -50,6 +50,9 @@ export interface EditToolPerFileResult {
 	move?: string;
 	isError?: boolean;
 	errorText?: string;
+	/** TUI-friendly error text. When present, rendered to the user instead of `errorText`.
+	 * Set when the underlying error carries a `displayMessage` (e.g. {@link HashlineMismatchError}). */
+	displayErrorText?: string;
 	meta?: OutputMeta;
 }
 
@@ -90,6 +93,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 +137,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 +150,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 +158,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 +272,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);
 	}
@@ -425,18 +380,18 @@ function wrapEditRendererLine(line: string, width: number): string[] {
 	const startAnsi = line.match(/^((?:\x1b\[[0-9;]*m)*)/)?.[1] ?? "";
 	const bodyWithReset = line.slice(startAnsi.length);
 	const body = bodyWithReset.endsWith("\x1b[39m") ? bodyWithReset.slice(0, -"\x1b[39m".length) : bodyWithReset;
-	const diffMatch = /^([+\-\s])(\s*\d+)\|(.*)$/s.exec(body);
+	const diffMatch = /^([+\-\s])(\s*\d+)([|│])(.*)$/s.exec(body);
 
 	if (!diffMatch) {
 		return wrapTextWithAnsi(line, width);
 	}
 
-	const [, marker, lineNum, content] = diffMatch;
-	const prefix = `${marker}${lineNum}|`;
+	const [, marker, lineNum, separator, content] = diffMatch;
+	const prefix = `${marker}${lineNum}${separator}`;
 	const prefixWidth = visibleWidth(prefix);
 	const contentWidth = Math.max(1, width - prefixWidth);
-	const continuationPrefix = `${" ".repeat(Math.max(0, prefixWidth - 1))}|`;
-	const wrappedContent = wrapTextWithAnsi(content, contentWidth);
+	const continuationPrefix = `${" ".repeat(Math.max(0, prefixWidth - 1))}${separator}`;
+	const wrappedContent = wrapTextWithAnsi(content ?? "", contentWidth);
 
 	return wrappedContent.map(
 		(segment, index) => `${startAnsi}${index === 0 ? prefix : continuationPrefix}${segment}\x1b[39m`,
@@ -446,31 +401,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 +452,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,
@@ -524,13 +492,14 @@ function renderSingleFileResult(
 	const rename = args?.rename || firstEdit?.rename || firstEdit?.move || details?.move;
 	const { language } = formatEditDescription(rawPath, uiTheme, { rename });
 
-	const metadataLine =
-		op !== "delete"
-			? `\n${formatMetadataLine(countLines(args?.newText ?? args?.oldText ?? args?.diff ?? args?.patch ?? ""), language, uiTheme)}`
-			: "";
+	const editTextSource = args?.newText ?? args?.oldText ?? args?.diff ?? args?.patch;
+	const metadataLineCount = editTextSource ? countLines(editTextSource) : null;
+	const metadataLine = op !== "delete" ? `\n${formatMetadataLine(metadataLineCount, language, uiTheme)}` : "";
 
+	const displayErrorText = isError && details && "displayErrorText" in details ? details.displayErrorText : undefined;
 	const errorText = isError
-		? (details && "errorText" in details && details.errorText) ||
+		? displayErrorText ||
+			(details && "errorText" in details && details.errorText) ||
 			(result.content?.find(c => c.type === "text")?.text ?? "")
 		: "";