@oh-my-pi/pi-coding-agent 14.1.0 → 14.1.1

package/src/edit/modes/patch.ts

@@ -1576,7 +1576,7 @@ export async function computePatchDiff(
 	}
 }
 
-export const patchEditSchema = Type.Object({
+export const patchEditEntrySchema = Type.Object({
 	path: Type.String({ description: "File path" }),
 	op: Type.Optional(
 		StringEnum(["create", "delete", "update"], {
@@ -1587,11 +1587,16 @@ export const patchEditSchema = Type.Object({
 	diff: Type.Optional(Type.String({ description: "Diff hunks (update) or full content (create)" })),
 });
 
+export const patchEditSchema = Type.Object({
+	edits: Type.Array(patchEditEntrySchema, { description: "Patch operations", minItems: 1 }),
+});
+
+export type PatchEditEntry = Static<typeof patchEditEntrySchema>;
 export type PatchParams = Static<typeof patchEditSchema>;
 
-interface ExecutePatchModeOptions {
+export interface ExecutePatchSingleOptions {
 	session: ToolSession;
-	params: PatchParams;
+	params: PatchEditEntry;
 	signal?: AbortSignal;
 	batchRequest?: LspBatchRequest;
 	allowFuzzy: boolean;
@@ -1601,10 +1606,11 @@ interface ExecutePatchModeOptions {
 }
 
 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);
+	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 {
@@ -1690,9 +1696,9 @@ function mergeDiagnosticsWithWarnings(
 	};
 }
 
-export async function executePatchMode(
-	options: ExecutePatchModeOptions,
-): Promise<AgentToolResult<EditToolDetails, typeof patchEditSchema>> {
+export async function executePatchSingle(
+	options: ExecutePatchSingleOptions,
+): Promise<AgentToolResult<EditToolDetails, typeof patchEditEntrySchema>> {
 	const {
 		session,
 		params,

package/src/edit/modes/replace.ts

@@ -987,18 +987,23 @@ export function findContextLine(
 	return { index: undefined, confidence: bestScore };
 }
 
-export const replaceEditSchema = Type.Object({
+export const replaceEditEntrySchema = Type.Object({
 	path: Type.String({ description: "File path (relative or absolute)" }),
 	old_text: Type.String({ description: "Text to find (fuzzy whitespace matching enabled)" }),
 	new_text: Type.String({ description: "Replacement text" }),
 	all: Type.Optional(Type.Boolean({ description: "Replace all occurrences (default: unique match required)" })),
 });
 
+export const replaceEditSchema = Type.Object({
+	edits: Type.Array(replaceEditEntrySchema, { description: "Replacements", minItems: 1 }),
+});
+
+export type ReplaceEditEntry = Static<typeof replaceEditEntrySchema>;
 export type ReplaceParams = Static<typeof replaceEditSchema>;
 
-interface ExecuteReplaceModeOptions {
+export interface ExecuteReplaceSingleOptions {
 	session: ToolSession;
-	params: ReplaceParams;
+	params: ReplaceEditEntry;
 	signal?: AbortSignal;
 	batchRequest?: LspBatchRequest;
 	allowFuzzy: boolean;
@@ -1008,12 +1013,15 @@ interface ExecuteReplaceModeOptions {
 }
 
 export function isReplaceParams(params: unknown): params is ReplaceParams {
-	return typeof params === "object" && params !== null && "old_text" in params && "new_text" in params;
+	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 executeReplaceMode(
-	options: ExecuteReplaceModeOptions,
-): Promise<AgentToolResult<EditToolDetails, typeof replaceEditSchema>> {
+export async function executeReplaceSingle(
+	options: ExecuteReplaceSingleOptions,
+): Promise<AgentToolResult<EditToolDetails, typeof replaceEditEntrySchema>> {
 	const {
 		session,
 		params,

package/src/edit/renderer.ts

@@ -21,9 +21,11 @@ import {
 	shortenPath,
 	truncateDiffByHunk,
 } from "../tools/render-utils";
+import { type VimRenderArgs, vimToolRenderer } from "../tools/vim";
 import { Hasher, type RenderCache, renderStatusLine, truncateToWidth } from "../tui";
+import type { VimToolDetails } from "../vim/types";
 import type { DiffError, DiffResult } from "./diff";
-import type { ChunkToolEdit } from "./modes/chunk";
+import { type ChunkToolEdit, parseChunkEditPath } from "./modes/chunk";
 import type { HashlineToolEdit } from "./modes/hashline";
 import type { Operation } from "./modes/patch";
 
@@ -56,6 +58,18 @@ export function getLspBatchRequest(toolCall: ToolCallContext | undefined): LspBa
 // Tool Details Types
 // ═══════════════════════════════════════════════════════════════════════════
 
+export interface EditToolPerFileResult {
+	path: string;
+	diff: string;
+	firstChangedLine?: number;
+	diagnostics?: FileDiagnosticsResult;
+	op?: Operation;
+	move?: string;
+	isError?: boolean;
+	errorText?: string;
+	meta?: OutputMeta;
+}
+
 export interface EditToolDetails {
 	/** Unified diff of the changes made */
 	diff: string;
@@ -69,6 +83,8 @@ export interface EditToolDetails {
 	move?: string;
 	/** Structured output metadata */
 	meta?: OutputMeta;
+	/** Per-file results (multi-file edits) */
+	perFileResults?: EditToolPerFileResult[];
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -94,6 +110,31 @@ interface EditRenderArgs {
 	edits?: Partial<HashlineToolEdit | ChunkToolEdit>[];
 }
 
+function isVimRenderArgs(args: EditRenderArgs | VimRenderArgs): args is VimRenderArgs {
+	return (
+		typeof args === "object" &&
+		args !== null &&
+		typeof (args as { file?: unknown }).file === "string" &&
+		!("path" in args) &&
+		!("file_path" in args) &&
+		!("edits" in args)
+	);
+}
+
+function isVimToolDetails(details: unknown): details is VimToolDetails {
+	if (!details || typeof details !== "object" || Array.isArray(details)) {
+		return false;
+	}
+	const cursor = (details as { cursor?: unknown }).cursor;
+	const viewportLines = (details as { viewportLines?: unknown }).viewportLines;
+	return (
+		typeof (details as { file?: unknown }).file === "string" &&
+		typeof cursor === "object" &&
+		cursor !== null &&
+		Array.isArray(viewportLines)
+	);
+}
+
 /** Extended context for edit tool rendering */
 export interface EditRenderContext {
 	/** Pre-computed diff preview (computed before tool executes) */
@@ -114,6 +155,18 @@ interface FormattedStreamingEdit {
 	dst: string;
 }
 
+/** Extract file path from an edit entry's path (handles chunk's file:selector format). */
+function filePathFromEditEntry(p: string | undefined): string | undefined {
+	if (!p) return undefined;
+	const ci = /^[a-zA-Z]:[/\\]/.test(p) ? p.indexOf(":", 2) : p.indexOf(":");
+	return ci === -1 ? p : p.slice(0, ci);
+}
+
+/** Count distinct file paths in an edits array. */
+function countEditFiles(edits: any[]): number {
+	return new Set(edits.map((e: any) => filePathFromEditEntry(e?.path)).filter(Boolean)).size;
+}
+
 function countLines(text: string): number {
 	if (!text) return 0;
 	return text.split("\n").length;
@@ -182,7 +235,12 @@ function formatStreamingDiff(diff: string, rawPath: string, uiTheme: Theme, labe
 }
 
 function isChunkStreamingEdit(edit: Partial<HashlineToolEdit | ChunkToolEdit>): edit is Partial<ChunkToolEdit> {
-	return "sel" in edit;
+	return (
+		typeof edit === "object" &&
+		edit !== null &&
+		"path" in edit &&
+		("write" in edit || "replace" in edit || "insert" in edit)
+	);
 }
 
 function getStreamingEditContent(content: unknown): string {
@@ -225,25 +283,20 @@ function formatChunkStreamingEdit(edit: Partial<ChunkToolEdit>): FormattedStream
 		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,
-			};
+	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) };
+	}
+	return { srcLabel: `\u2022 edit ${target}`, dst: "" };
 }
 
 function formatStreamingHashlineEdits(edits: Partial<HashlineToolEdit | ChunkToolEdit>[], uiTheme: Theme): string {
@@ -302,7 +355,11 @@ function getCallPreview(args: EditRenderArgs, rawPath: string, uiTheme: Theme):
 		return formatStreamingDiff(args.diff, rawPath, uiTheme);
 	}
 	if (args.edits && args.edits.length > 0) {
-		return formatStreamingHashlineEdits(args.edits, uiTheme);
+		// 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);
@@ -376,11 +433,24 @@ export const editToolRenderer = {
 	mergeCallAndResult: true,
 
 	renderCall(args: EditRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component {
-		const rawPath = args.file_path || args.path || "";
-		const { description } = formatEditDescription(rawPath, uiTheme, { rename: args.rename });
+		if (isVimRenderArgs(args)) {
+			return vimToolRenderer.renderCall(args, options, uiTheme);
+		}
+
+		// 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 rawPath = args.file_path || args.path || (firstEdit as any)?.path || "";
+		const rename = args.rename || (firstEdit as any)?.rename;
+		const op = args.op || (firstEdit as any)?.op;
+		const { description } = formatEditDescription(rawPath, uiTheme, { rename });
 		const spinner =
 			options?.spinnerFrame !== undefined ? formatStatusIcon("running", uiTheme, options.spinnerFrame) : "";
-		let text = `${formatTitle(getOperationTitle(args.op), uiTheme)} ${spinner ? `${spinner} ` : ""}${description}`;
+		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 as any[]) : 0;
+		if (fileCount > 1) {
+			text += uiTheme.fg("dim", ` (+${fileCount - 1} more)`);
+		}
 		text += getCallPreview(args, rawPath, uiTheme);
 
 		return new Text(text, 0, 0);
@@ -392,76 +462,160 @@ export const editToolRenderer = {
 		uiTheme: Theme,
 		args?: EditRenderArgs,
 	): Component {
-		const rawPath = args?.file_path || args?.path || "";
-		const op = args?.op || result.details?.op;
-		const rename = args?.rename || result.details?.move;
-		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 ?? ""), language, uiTheme)}`
-				: "";
-
-		// Pre-compute error text (static)
-		const errorText = result.isError ? (result.content?.find(c => c.type === "text")?.text ?? "") : "";
-
-		let cached: RenderCache | undefined;
-
-		return {
-			render(width) {
-				const { expanded, renderContext } = options;
-				const editDiffPreview = renderContext?.editDiffPreview;
-				const renderDiffFn = renderContext?.renderDiff ?? ((t: string) => t);
-				const key = new Hasher().bool(expanded).u32(width).digest();
-				if (cached?.key === key) return cached.lines;
-
-				const firstChangedLine =
-					(editDiffPreview && "firstChangedLine" in editDiffPreview
-						? editDiffPreview.firstChangedLine
-						: undefined) || (result.details && !result.isError ? result.details.firstChangedLine : undefined);
-				const { description } = formatEditDescription(rawPath, uiTheme, { rename, firstChangedLine });
-
-				const header = renderStatusLine(
-					{
-						icon: result.isError ? "error" : "success",
-						title: getOperationTitle(op),
-						description,
-					},
-					uiTheme,
-				);
-				let text = header;
-				text += metadataLine;
-
-				if (result.isError) {
-					if (errorText) {
-						text += `\n\n${uiTheme.fg("error", replaceTabs(errorText))}`;
-					}
-				} else if (result.details?.diff) {
-					text += renderDiffSection(result.details.diff, rawPath, expanded, uiTheme, renderDiffFn);
-				} else if (editDiffPreview) {
-					if ("error" in editDiffPreview) {
-						text += `\n\n${uiTheme.fg("error", replaceTabs(editDiffPreview.error))}`;
-					} else if (editDiffPreview.diff) {
-						text += renderDiffSection(editDiffPreview.diff, rawPath, expanded, uiTheme, renderDiffFn);
-					}
-				}
-
-				// Show LSP diagnostics if available
-				if (result.details?.diagnostics) {
-					text += formatDiagnostics(result.details.diagnostics, expanded, uiTheme, (fp: string) =>
-						uiTheme.getLangIcon(getLanguageFromPath(fp)),
-					);
-				}
+		if (isVimToolDetails(result.details)) {
+			return vimToolRenderer.renderResult(
+				result as { content: Array<{ type: string; text?: string }>; details?: VimToolDetails; isError?: boolean },
+				options,
+				uiTheme,
+			);
+		}
 
-				const lines =
-					width > 0 ? text.split("\n").flatMap(line => wrapEditRendererLine(line, width)) : text.split("\n");
-				cached = { key, lines };
-				return lines;
-			},
-			invalidate() {
-				cached = undefined;
-			},
-		};
+		const perFileResults = result.details?.perFileResults;
+		const totalFiles = Array.isArray(args?.edits) ? countEditFiles(args!.edits as any[]) : 0;
+		if (perFileResults && (perFileResults.length > 1 || totalFiles > 1)) {
+			return renderMultiFileResult(perFileResults, totalFiles, options, uiTheme);
+		}
+		return renderSingleFileResult(result, options, uiTheme, args);
 	},
 };
+
+function renderSingleFileResult(
+	result: {
+		content: Array<{ type: string; text?: string }>;
+		details?: EditToolDetails | EditToolPerFileResult;
+		isError?: boolean;
+	},
+	options: RenderResultOptions & { renderContext?: EditRenderContext },
+	uiTheme: Theme,
+	args?: EditRenderArgs,
+): Component {
+	const details = result.details;
+	const isError = result.isError ?? (details && "isError" in details ? details.isError : false);
+	const rawPath = args?.file_path || args?.path || (details && "path" in details ? details.path : "") || "";
+	const op = args?.op || details?.op;
+	const rename = args?.rename || 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 errorText = isError
+		? (details && "errorText" in details && details.errorText) ||
+			(result.content?.find(c => c.type === "text")?.text ?? "")
+		: "";
+
+	let cached: RenderCache | undefined;
+
+	return {
+		render(width) {
+			const { expanded, renderContext } = options;
+			const editDiffPreview = renderContext?.editDiffPreview;
+			const renderDiffFn = renderContext?.renderDiff ?? ((t: string) => t);
+			const key = new Hasher().bool(expanded).u32(width).digest();
+			if (cached?.key === key) return cached.lines;
+
+			const firstChangedLine =
+				(editDiffPreview && "firstChangedLine" in editDiffPreview ? editDiffPreview.firstChangedLine : undefined) ||
+				(details && !isError ? details.firstChangedLine : undefined);
+			const { description } = formatEditDescription(rawPath, uiTheme, { rename, firstChangedLine });
+
+			const header = renderStatusLine(
+				{
+					icon: isError ? "error" : "success",
+					title: getOperationTitle(op),
+					description,
+				},
+				uiTheme,
+			);
+			let text = header;
+			text += metadataLine;
+
+			if (isError) {
+				if (errorText) {
+					text += `\n\n${uiTheme.fg("error", replaceTabs(errorText))}`;
+				}
+			} else if (details?.diff) {
+				text += renderDiffSection(details.diff, rawPath, expanded, uiTheme, renderDiffFn);
+			} else if (editDiffPreview) {
+				if ("error" in editDiffPreview) {
+					text += `\n\n${uiTheme.fg("error", replaceTabs(editDiffPreview.error))}`;
+				} else if (editDiffPreview.diff) {
+					text += renderDiffSection(editDiffPreview.diff, rawPath, expanded, uiTheme, renderDiffFn);
+				}
+			}
+
+			if (details?.diagnostics) {
+				text += formatDiagnostics(details.diagnostics, expanded, uiTheme, (fp: string) =>
+					uiTheme.getLangIcon(getLanguageFromPath(fp)),
+				);
+			}
+
+			const lines =
+				width > 0 ? text.split("\n").flatMap(line => wrapEditRendererLine(line, width)) : text.split("\n");
+			cached = { key, lines };
+			return lines;
+		},
+		invalidate() {
+			cached = undefined;
+		},
+	};
+}
+
+function renderMultiFileResult(
+	perFileResults: EditToolPerFileResult[],
+	totalFiles: number,
+	options: RenderResultOptions & { renderContext?: EditRenderContext },
+	uiTheme: Theme,
+): Component {
+	const fileComponents = perFileResults.map(fileResult =>
+		renderSingleFileResult({ content: [], details: fileResult, isError: fileResult.isError }, options, uiTheme),
+	);
+	const remaining = Math.max(0, totalFiles - perFileResults.length);
+
+	let cached: RenderCache | undefined;
+
+	return {
+		render(width) {
+			const key = new Hasher().bool(options.expanded).u32(width).u32(perFileResults.length).u32(remaining).digest();
+			if (cached?.key === key) return cached.lines;
+
+			const allLines: string[] = [];
+			for (let i = 0; i < fileComponents.length; i++) {
+				if (i > 0) {
+					allLines.push("");
+				}
+				allLines.push(...fileComponents[i].render(width));
+			}
+
+			// Show pending indicator for files still being processed
+			if (remaining > 0) {
+				if (allLines.length > 0) allLines.push("");
+				const spinnerFrame = options.spinnerFrame;
+				const spinner = spinnerFrame !== undefined ? formatStatusIcon("running", uiTheme, spinnerFrame) : "";
+				allLines.push(
+					renderStatusLine(
+						{
+							icon: "pending",
+							title: "Edit",
+							description: uiTheme.fg("dim", `${remaining} more file${remaining > 1 ? "s" : ""} pending…`),
+						},
+						uiTheme,
+					),
+				);
+				if (spinner) {
+					// Replace the pending icon with spinner on the last line
+					allLines[allLines.length - 1] = allLines[allLines.length - 1].replace(/^(?:\x1b\[[^m]*m)*./u, spinner);
+				}
+			}
+
+			cached = { key, lines: allLines };
+			return allLines;
+		},
+		invalidate() {
+			cached = undefined;
+			for (const c of fileComponents) c.invalidate();
+		},
+	};
+}