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

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

@@ -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;
 }
 
@@ -377,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`,
@@ -489,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 ?? "")
 		: "";
 

package/src/edit/streaming.ts

@@ -131,6 +131,7 @@ export function dropIncompleteLastEdit<T>(edits: readonly T[], partialJson: stri
 // -----------------------------------------------------------------------------
 
 interface ReplaceArgs {
+	path?: string;
 	edits?: ReplaceEditEntry[];
 	__partialJson?: string;
 }
@@ -142,10 +143,12 @@ const replaceStrategy: EditStreamingStrategy<ReplaceArgs> = {
 	},
 	async computeDiffPreview(args, ctx) {
 		const first = args.edits?.[0];
-		if (!first?.path || first.old_text === undefined || first.new_text === undefined) return null;
+		if (!first) return null;
+		const path = first.path ?? args.path;
+		if (!path || first.old_text === undefined || first.new_text === undefined) return null;
 		ctx.signal.throwIfAborted();
 		const result = await computeEditDiff(
-			first.path,
+			path,
 			first.old_text,
 			first.new_text,
 			ctx.cwd,
@@ -154,7 +157,7 @@ const replaceStrategy: EditStreamingStrategy<ReplaceArgs> = {
 			ctx.fuzzyThreshold,
 		);
 		ctx.signal.throwIfAborted();
-		return [toPerFilePreview(first.path, result)];
+		return [toPerFilePreview(path, result)];
 	},
 	renderStreamingFallback() {
 		return "";
@@ -162,6 +165,7 @@ const replaceStrategy: EditStreamingStrategy<ReplaceArgs> = {
 };
 
 interface PatchArgs {
+	path?: string;
 	edits?: PatchEditEntry[];
 	__partialJson?: string;
 }
@@ -173,15 +177,16 @@ const patchStrategy: EditStreamingStrategy<PatchArgs> = {
 	},
 	async computeDiffPreview(args, ctx) {
 		const first = args.edits?.[0];
-		if (!first?.path) return null;
+		const path = first?.path ?? args.path;
+		if (!path) return null;
 		ctx.signal.throwIfAborted();
 		const result = await computePatchDiff(
-			{ path: first.path, op: first.op ?? "update", rename: first.rename, diff: first.diff },
+			{ 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)];
+		return [toPerFilePreview(path, result)];
 	},
 	renderStreamingFallback() {
 		return "";
@@ -189,8 +194,8 @@ const patchStrategy: EditStreamingStrategy<PatchArgs> = {
 };
 
 interface HashlineArgs {
+	path?: string;
 	edits?: HashlineToolEdit[];
-	move?: string;
 	__partialJson?: string;
 }
 
@@ -201,13 +206,18 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 	},
 	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;
-		});
+		const path = first?.path ?? args.path;
+		if (!path) return null;
+		const fileEdits = (args.edits ?? [])
+			.map(e => {
+				if (!e || typeof e !== "object") return undefined;
+				const entryPath = (e as { path?: string }).path ?? args.path;
+				if (!entryPath || entryPath !== path) return undefined;
+				return { ...(e as HashlineToolEdit), path } as HashlineToolEdit & { path: string };
+			})
+			.filter((e): e is HashlineToolEdit & { path: string } => e !== undefined);
 		ctx.signal.throwIfAborted();
-		const result = await computeHashlineDiff({ path, edits: fileEdits, move: args.move }, ctx.cwd);
+		const result = await computeHashlineDiff({ path, edits: fileEdits }, ctx.cwd);
 		ctx.signal.throwIfAborted();
 		return [toPerFilePreview(path, result)];
 	},
@@ -217,6 +227,7 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 };
 
 interface ChunkArgs {
+	path?: string;
 	edits?: ChunkToolEdit[];
 	__partialJson?: string;
 }
@@ -248,8 +259,10 @@ const chunkStrategy: EditStreamingStrategy<ChunkArgs> = {
 		const groups = new Map<string, ChunkToolEdit[]>();
 		const fileOrder: string[] = [];
 		for (const edit of edits) {
-			if (!edit?.path) continue;
-			const { filePath } = parseChunkEditPath(edit.path);
+			if (!edit) continue;
+			const editPath = edit.path ?? args.path;
+			if (!editPath) continue;
+			const { filePath } = parseChunkEditPath(editPath);
 			if (!filePath) continue;
 			let bucket = groups.get(filePath);
 			if (!bucket) {
@@ -257,7 +270,7 @@ const chunkStrategy: EditStreamingStrategy<ChunkArgs> = {
 				groups.set(filePath, bucket);
 				fileOrder.push(filePath);
 			}
-			bucket.push(edit);
+			bucket.push({ ...edit, path: editPath });
 		}
 		if (fileOrder.length === 0) return null;
 
@@ -328,6 +341,26 @@ const vimStrategy: EditStreamingStrategy<unknown> = {
 	},
 };
 
+interface AtomArgs {
+	path?: string;
+	edits?: unknown[];
+}
+
+const atomStrategy: EditStreamingStrategy<AtomArgs> = {
+	extractCompleteEdits(args, partialJson) {
+		if (!args.edits) return args;
+		return { ...args, edits: dropIncompleteLastEdit(args.edits, partialJson, "edits") };
+	},
+	async computeDiffPreview() {
+		// Atom edits are line-anchored and validated against live file hashes; a
+		// streaming preview without that validation could mislead. Skip for now.
+		return null;
+	},
+	renderStreamingFallback() {
+		return "";
+	},
+};
+
 export const EDIT_MODE_STRATEGIES: Record<EditMode, EditStreamingStrategy<unknown>> = {
 	replace: replaceStrategy as EditStreamingStrategy<unknown>,
 	patch: patchStrategy as EditStreamingStrategy<unknown>,
@@ -335,6 +368,7 @@ export const EDIT_MODE_STRATEGIES: Record<EditMode, EditStreamingStrategy<unknow
 	chunk: chunkStrategy as EditStreamingStrategy<unknown>,
 	apply_patch: applyPatchStrategy as EditStreamingStrategy<unknown>,
 	vim: vimStrategy,
+	atom: atomStrategy as EditStreamingStrategy<unknown>,
 };
 
 export { resolveEditMode };

package/src/exec/bash-executor.ts

@@ -239,7 +239,7 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 		// artifact, and splice an `artifact://<id>` footer into the visible text so
 		// the agent can retrieve the raw bytes losslessly.
 		const minimized = winner.result.minimized;
-		if (minimized) {
+		if (minimized && minimized.text !== minimized.originalText) {
 			sink.replace(minimized.text);
 			if (options?.onMinimizedSave) {
 				const artifactId = await options.onMinimizedSave(minimized.originalText, {
@@ -248,9 +248,7 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 					outputBytes: minimized.outputBytes,
 				});
 				if (artifactId) {
-					sink.push(
-						`\n… full output: artifact://${artifactId} (${minimized.inputBytes} → ${minimized.outputBytes} bytes)\n`,
-					);
+					sink.push(`\n[raw output: artifact://${artifactId}]\n`);
 				}
 			}
 		}