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

package/src/edit/modes/chunk.ts

@@ -32,7 +32,6 @@ export type { ChunkReadTarget };
 
 export type ChunkEditOperation =
 	| { op: "put"; sel?: string; content: string }
-	| { op: "replace"; sel?: string; content: string; find: string }
 	| { op: "delete"; sel?: string }
 	| { op: "before"; sel?: string; content: string }
 	| { op: "after"; sel?: string; content: string }
@@ -120,6 +119,8 @@ type ChunkSourceContext = {
 	chunkLanguage: string | undefined;
 };
 
+type ChunkSourceIntent = "read" | "write";
+
 function normalizeLanguage(language: string | undefined): string {
 	return language?.trim().toLowerCase() || "";
 }
@@ -140,11 +141,17 @@ function fileLanguageTag(filePath: string, language?: string): string | undefine
 	return ext.length > 0 ? ext : undefined;
 }
 
-async function resolveChunkSourceContext(session: ToolSession, path: string): Promise<ChunkSourceContext> {
+async function resolveChunkSourceContext(
+	session: ToolSession,
+	path: string,
+	options?: { intent?: ChunkSourceIntent },
+): Promise<ChunkSourceContext> {
 	const resolvedPath = resolvePlanPath(session, path);
 	const sourceFile = Bun.file(resolvedPath);
 	const sourceExists = await sourceFile.exists();
-	enforcePlanModeWrite(session, path, { op: sourceExists ? "update" : "create" });
+	if ((options?.intent ?? "write") === "write") {
+		enforcePlanModeWrite(session, path, { op: sourceExists ? "update" : "create" });
+	}
 
 	let rawContent = "";
 	if (sourceExists) {
@@ -161,6 +168,57 @@ async function resolveChunkSourceContext(session: ToolSession, path: string): Pr
 	};
 }
 
+/**
+ * Preview-safe loader: read raw source without plan-mode enforcement or
+ * editable-file guards. Used by streaming diff previews that must not throw
+ * side-effecting errors while args are still being streamed.
+ */
+export async function loadChunkSource(params: {
+	cwd: string;
+	path: string;
+}): Promise<{ resolvedPath: string; rawContent: string; language: string | undefined; exists: boolean }> {
+	const resolvedPath = nodePath.isAbsolute(params.path) ? params.path : nodePath.resolve(params.cwd, params.path);
+	const sourceFile = Bun.file(resolvedPath);
+	const exists = await sourceFile.exists();
+	const rawContent = exists ? await sourceFile.text() : "";
+	return { resolvedPath, rawContent, language: getLanguageFromPath(resolvedPath), exists };
+}
+
+/**
+ * Compute a unified diff preview for a chunk edit without applying it.
+ * Used for streaming previews while args are still arriving. Returns
+ * `{ error }` on any failure so callers can decide whether to surface it.
+ */
+export async function computeChunkDiff(
+	input: { path: string; edits: ChunkToolEdit[] },
+	cwd: string,
+	options?: { anchorStyle?: ChunkAnchorStyle; signal?: AbortSignal },
+): Promise<{ diff: string; firstChangedLine: number | undefined } | { error: string }> {
+	try {
+		options?.signal?.throwIfAborted?.();
+		const { filePath } = parseChunkEditPath(input.path);
+		if (!filePath) return { error: "chunk edit path is empty" };
+		const { resolvedPath, rawContent, language } = await loadChunkSource({ cwd, path: filePath });
+		options?.signal?.throwIfAborted?.();
+		const { operations } = normalizeChunkEditOperations(input.edits);
+		const result = applyChunkEdits({
+			source: rawContent,
+			language,
+			cwd,
+			filePath: resolvedPath,
+			operations,
+			anchorStyle: options?.anchorStyle,
+		});
+		options?.signal?.throwIfAborted?.();
+		if (!result.changed) {
+			return { diff: "", firstChangedLine: undefined };
+		}
+		return generateUnifiedDiffString(result.diffSourceBefore, result.diffSourceAfter);
+	} catch (err) {
+		return { error: err instanceof Error ? err.message : String(err) };
+	}
+}
+
 function normalizeChunkRegionSyntax(text: string): string {
 	return text.replaceAll("@body", "~").replaceAll("@head", "^");
 }
@@ -189,6 +247,20 @@ function chunkReadPathSeparatorIndex(readPath: string): number {
 	if (/^[a-zA-Z]:[/\\]/.test(readPath)) {
 		return readPath.indexOf(":", 2);
 	}
+	const urlMatch = readPath.match(/^([a-z][a-z0-9+.-]*):\/\//i);
+	if (urlMatch) {
+		const scheme = urlMatch[1].toLowerCase();
+		const urlPrefixEnd = urlMatch[0].length;
+		if (scheme === "local") {
+			const index = readPath.lastIndexOf(":");
+			return index >= urlPrefixEnd ? index : -1;
+		}
+
+		const pathStart = readPath.indexOf("/", urlPrefixEnd);
+		if (pathStart === -1) return -1;
+		const index = readPath.lastIndexOf(":");
+		return index >= pathStart ? index : -1;
+	}
 	return readPath.indexOf(":");
 }
 
@@ -376,15 +448,6 @@ function toNativeEditOperation(
 				region: nativeRegion,
 				content: operation.content,
 			};
-		case "replace":
-			return {
-				op: ChunkEditOp.Replace,
-				sel: selector,
-				crc,
-				region: nativeRegion,
-				find: operation.find,
-				content: operation.content,
-			};
 		case "before":
 			return { op: ChunkEditOp.Before, sel: selector, crc, region: nativeRegion, content: operation.content };
 		case "after":
@@ -491,17 +554,14 @@ export const chunkToolEditSchema = Type.Object(
 		}),
 		write: Type.Optional(
 			Type.Union([Type.String(), Type.Null()], {
-				description: "Write complete new content to the targeted region. Use null to delete the chunk.",
+				description:
+					"Write complete new content to the targeted region. Null is rejected; use delete: true for deletion.",
 			}),
 		),
-		replace: Type.Optional(
-			Type.Object(
-				{
-					old: Type.String({ description: "Literal substring to find. Must match exactly once." }),
-					new: Type.String({ description: "Replacement text." }),
-				},
-				{ description: "Find and replace a substring within the chunk." },
-			),
+		delete: Type.Optional(
+			Type.Boolean({
+				description: "Explicitly delete the targeted chunk. Must be true; include the current chunk ID.",
+			}),
 		),
 		insert: Type.Optional(
 			Type.Object(
@@ -549,11 +609,8 @@ export function isChunkParams(params: unknown): params is ChunkParams {
 		return false;
 	}
 	const first = params.edits[0];
-	// Accept a bare `{ path }` entry: it is interpreted downstream as a chunk
-	// delete. Some providers strip `null` values from tool-call JSON, so a
-	// documented `{ path, write: null }` delete can arrive here as just
-	// `{ path }`. Rejecting that surfaced as a misleading
-	// "Invalid edit parameters for chunk mode." error.
+	// Accept a bare `{ path }` entry so the executor can return a targeted
+	// "missing operation" error instead of the generic schema failure.
 	return typeof first === "object" && first !== null && "path" in first;
 }
 
@@ -605,6 +662,29 @@ function autoCorrectBodyIndent(content: string, index: number): { content: strin
 	return { content, warnings };
 }
 
+function chunkEditOperationFields(edit: ChunkToolEdit): string[] {
+	const fields: string[] = [];
+	if (edit.write !== undefined) fields.push("write");
+	if (edit.insert != null) fields.push("insert");
+	if (edit.delete === true) fields.push("delete");
+	return fields;
+}
+
+function assertSingleChunkOperation(edit: ChunkToolEdit, index: number): string {
+	const fields = chunkEditOperationFields(edit);
+	if (fields.length === 0) {
+		throw new Error(
+			`Edit ${index + 1}: no operation specified. Use write:"..." to replace, insert:{loc,body} to insert, or delete:true to delete. Use the open tool to inspect chunks.`,
+		);
+	}
+	if (fields.length > 1) {
+		throw new Error(
+			`Edit ${index + 1}: multiple operation fields set (${fields.join(", ")}). Each chunk edit entry must have exactly one operation.`,
+		);
+	}
+	return fields[0];
+}
+
 function normalizeChunkEditOperations(edits: ChunkToolEdit[]): {
 	operations: ChunkEditOperation[];
 	warnings: string[];
@@ -612,26 +692,22 @@ function normalizeChunkEditOperations(edits: ChunkToolEdit[]): {
 	const warnings: string[] = [];
 	const operations = edits.map((edit, index): ChunkEditOperation => {
 		const { selector } = parseChunkEditPath(edit.path);
-		// When multiple ops are present (model confusion), prefer write (total replacement) as the
-		// safest default, then replace (surgical), then insert (additive), then delete.
-		const hasInsert = edit.insert != null && typeof edit.insert.body === "string" && edit.insert.body.length > 0;
-		const hasReplace =
-			edit.replace != null &&
-			((typeof edit.replace.old === "string" && edit.replace.old.length > 0) ||
-				(typeof edit.replace.new === "string" && edit.replace.new.length > 0));
-		const hasWrite = typeof edit.write === "string" && edit.write.length > 0;
-		const opCount = [hasInsert, hasReplace, hasWrite].filter(Boolean).length;
-		if (opCount > 1) {
-			const chosen = hasWrite ? "write" : hasReplace ? "replace" : "insert";
-			const present = [hasWrite && "write", hasReplace && "replace", hasInsert && "insert"]
-				.filter(Boolean)
-				.join(", ");
-			warnings.push(
-				`Edit ${index + 1}: multiple operation fields set (${present}). Each edit entry must have exactly ONE of write/replace/insert — not multiple. Used "${chosen}", ignored the rest.`,
-			);
-		}
-		if (hasWrite) {
-			let writeContent = edit.write!;
+		const operation = assertSingleChunkOperation(edit, index);
+		if (operation === "write") {
+			if (edit.write === null) {
+				throw new Error(
+					`Edit ${index + 1}: write:null no longer deletes chunks. Use delete:true to delete, or open the chunk to inspect its content without modifying the file.`,
+				);
+			}
+			if (typeof edit.write !== "string") {
+				throw new Error(`Edit ${index + 1}: write must be a string.`);
+			}
+			if (edit.write.length === 0) {
+				throw new Error(
+					`Edit ${index + 1}: write:"" is a destructive empty replacement. Use delete:true to delete the chunk, or open the chunk to inspect its content without modifying the file.`,
+				);
+			}
+			let writeContent = edit.write;
 			if (selector?.endsWith("~")) {
 				const corrected = autoCorrectBodyIndent(writeContent, index);
 				writeContent = corrected.content;
@@ -639,15 +715,12 @@ function normalizeChunkEditOperations(edits: ChunkToolEdit[]): {
 			}
 			return { op: "put", sel: selector, content: writeContent };
 		}
-		if (typeof edit.write === "string" && !hasInsert && !hasReplace) {
-			return { op: "put", sel: selector, content: edit.write };
-		}
-		if (hasReplace) {
-			return { op: "replace", sel: selector, content: edit.replace!.new, find: edit.replace!.old };
-		}
-		if (hasInsert) {
-			const op = edit.insert!.loc === "prepend" ? "before" : "after";
-			let insertContent = edit.insert!.body;
+		if (operation === "insert") {
+			if (edit.insert == null || typeof edit.insert.body !== "string" || edit.insert.body.length === 0) {
+				throw new Error(`Edit ${index + 1}: insert.body must be a non-empty string.`);
+			}
+			const op = edit.insert.loc === "prepend" ? "before" : "after";
+			let insertContent = edit.insert.body;
 			if (selector?.endsWith("~")) {
 				const corrected = autoCorrectBodyIndent(insertContent, index);
 				insertContent = corrected.content;
@@ -655,7 +728,9 @@ function normalizeChunkEditOperations(edits: ChunkToolEdit[]): {
 			}
 			return { op, sel: selector, content: insertContent };
 		}
-		// write: null or no op specified → delete
+		if (operation !== "delete") {
+			throw new Error(`Edit ${index + 1}: unsupported chunk edit operation "${operation}".`);
+		}
 		return { op: "delete", sel: selector };
 	});
 	return { operations, warnings };
@@ -717,6 +792,7 @@ export async function executeChunkSingle(
 	const { resolvedPath, sourceFile, sourceExists, rawContent, chunkLanguage } = await resolveChunkSourceContext(
 		session,
 		path,
+		{ intent: "write" },
 	);
 	const parentDir = nodePath.dirname(resolvedPath);
 	if (parentDir && parentDir !== ".") {

package/src/edit/modes/hashline.ts

@@ -52,12 +52,14 @@ export type HashlineEdit =
 const HASHLINE_PREFIX_RE = /^\s*(?:>>>|>>)?\s*(?:\+?\s*(?:\d+\s*#\s*|#\s*)|\+)\s*[ZPMQVRWSNKTXJBYH]{2}:/;
 const HASHLINE_PREFIX_PLUS_RE = /^\s*(?:>>>|>>)?\s*\+\s*(?:\d+\s*#\s*|#\s*)?[ZPMQVRWSNKTXJBYH]{2}:/;
 const DIFF_PLUS_RE = /^[+](?![+])/;
+const READ_TRUNCATION_NOTICE_RE = /^\[(?:Showing lines \d+-\d+ of \d+|\d+ more lines? in (?:file|\S+))\b.*\bsel=L\d+/;
 
 type LinePrefixStats = {
 	nonEmpty: number;
 	hashPrefixCount: number;
 	diffPlusHashPrefixCount: number;
 	diffPlusCount: number;
+	truncationNoticeCount: number;
 };
 
 function collectLinePrefixStats(lines: string[]): LinePrefixStats {
@@ -66,10 +68,15 @@ function collectLinePrefixStats(lines: string[]): LinePrefixStats {
 		hashPrefixCount: 0,
 		diffPlusHashPrefixCount: 0,
 		diffPlusCount: 0,
+		truncationNoticeCount: 0,
 	};
 
 	for (const line of lines) {
 		if (line.length === 0) continue;
+		if (READ_TRUNCATION_NOTICE_RE.test(line)) {
+			stats.truncationNoticeCount++;
+			continue;
+		}
 		stats.nonEmpty++;
 		if (HASHLINE_PREFIX_RE.test(line)) stats.hashPrefixCount++;
 		if (HASHLINE_PREFIX_PLUS_RE.test(line)) stats.diffPlusHashPrefixCount++;
@@ -79,6 +86,20 @@ function collectLinePrefixStats(lines: string[]): LinePrefixStats {
 	return stats;
 }
 
+function stripLeadingHashlinePrefixes(line: string): string {
+	let result = line;
+	let prev: string;
+	do {
+		prev = result;
+		result = result.replace(HASHLINE_PREFIX_RE, "");
+	} while (result !== prev);
+	return result;
+}
+
+function _filterTruncationNotices(lines: string[]): string[] {
+	return lines.filter(line => !READ_TRUNCATION_NOTICE_RE.test(line));
+}
+
 export function stripNewLinePrefixes(lines: string[]): string[] {
 	const { nonEmpty, hashPrefixCount, diffPlusHashPrefixCount, diffPlusCount } = collectLinePrefixStats(lines);
 	if (nonEmpty === 0) return lines;
@@ -88,20 +109,24 @@ export function stripNewLinePrefixes(lines: string[]): string[] {
 		!stripHash && diffPlusHashPrefixCount === 0 && diffPlusCount > 0 && diffPlusCount >= nonEmpty * 0.5;
 	if (!stripHash && !stripPlus && diffPlusHashPrefixCount === 0) return lines;
 
-	return lines.map(line => {
-		if (stripHash) return line.replace(HASHLINE_PREFIX_RE, "");
-		if (stripPlus) return line.replace(DIFF_PLUS_RE, "");
-		if (diffPlusHashPrefixCount > 0 && HASHLINE_PREFIX_PLUS_RE.test(line)) {
-			return line.replace(HASHLINE_PREFIX_RE, "");
-		}
-		return line;
-	});
+	const mapped = lines
+		.filter(line => !READ_TRUNCATION_NOTICE_RE.test(line))
+		.map(line => {
+			if (stripHash) return stripLeadingHashlinePrefixes(line);
+			if (stripPlus) return line.replace(DIFF_PLUS_RE, "");
+			if (diffPlusHashPrefixCount > 0 && HASHLINE_PREFIX_PLUS_RE.test(line)) {
+				return line.replace(HASHLINE_PREFIX_RE, "");
+			}
+			return line;
+		});
+	return mapped;
 }
 
 export function stripHashlinePrefixes(lines: string[]): string[] {
 	const { nonEmpty, hashPrefixCount } = collectLinePrefixStats(lines);
-	if (nonEmpty === 0 || hashPrefixCount !== nonEmpty) return lines;
-	return lines.map(line => line.replace(HASHLINE_PREFIX_RE, ""));
+	if (nonEmpty === 0) return lines;
+	if (hashPrefixCount !== nonEmpty) return lines;
+	return lines.filter(line => !READ_TRUNCATION_NOTICE_RE.test(line)).map(line => stripLeadingHashlinePrefixes(line));
 }
 
 const linesSchema = Type.Union([
@@ -530,7 +555,7 @@ export class HashlineMismatchError extends Error {
 		const lines: string[] = [];
 
 		lines.push(
-			`${mismatches.length} line${mismatches.length > 1 ? "s have" : " has"} changed since last read. Use the updated LINE#ID references shown below (>>> marks changed lines).`,
+			`Edit rejected: ${mismatches.length} line${mismatches.length > 1 ? "s have" : " has"} changed since the last read. The edit was NOT applied. Use the updated LINE#ID references shown below (>>> marks changed lines) and retry the edit.`,
 		);
 		lines.push("");