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

package/src/edit/modes/chunk.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs/promises";
 import * as nodePath from "node:path";
 import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import { StringEnum } from "@oh-my-pi/pi-coding-agent";
+import { StringEnum } from "@oh-my-pi/pi-ai";
 import {
 	ChunkAnchorStyle,
 	ChunkEditOp,
@@ -25,6 +25,7 @@ import { invalidateFsScanAfterWrite } from "../../tools/fs-cache-invalidation";
 import { outputMeta } from "../../tools/output-meta";
 import { enforcePlanModeWrite, resolvePlanPath } from "../../tools/plan-mode-guard";
 import { generateUnifiedDiffString } from "../diff";
+import { HASHLINE_BIGRAMS } from "../line-hash";
 import { detectLineEnding, normalizeToLF, restoreLineEndings, stripBom } from "../normalize";
 import type { EditToolDetails, LspBatchRequest } from "../renderer";
 
@@ -32,7 +33,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 +120,8 @@ type ChunkSourceContext = {
 	chunkLanguage: string | undefined;
 };
 
+type ChunkSourceIntent = "read" | "write";
+
 function normalizeLanguage(language: string | undefined): string {
 	return language?.trim().toLowerCase() || "";
 }
@@ -140,11 +142,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 +169,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 +248,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(":");
 }
 
@@ -300,11 +373,13 @@ export async function describeChunkedGrepMatch(params: {
 	};
 }
 
-const CHUNK_CHECKSUM_ALPHABET = "ZPMQVRWSNKTXJBYH";
+const CHUNK_CHECKSUM_BIGRAMS = new Set<string>(HASHLINE_BIGRAMS);
 type NativeChunkRegion = "head" | "body";
 
 function isChunkChecksumToken(value: string): boolean {
-	return value.length === 4 && Array.from(value).every(ch => CHUNK_CHECKSUM_ALPHABET.includes(ch.toUpperCase()));
+	if (value.length !== 4) return false;
+	const lower = value.toLowerCase();
+	return CHUNK_CHECKSUM_BIGRAMS.has(lower.slice(0, 2)) && CHUNK_CHECKSUM_BIGRAMS.has(lower.slice(2, 4));
 }
 
 function parseChunkEditSelector(selector: string | undefined): {
@@ -334,11 +409,11 @@ function parseChunkEditSelector(selector: string | undefined): {
 	if (hashIndex >= 0) {
 		const suffix = selectorPart.slice(hashIndex + 1).trim();
 		if (isChunkChecksumToken(suffix)) {
-			crc = suffix.toUpperCase();
+			crc = suffix.toLowerCase();
 			selectorPart = selectorPart.slice(0, hashIndex).trimEnd();
 		}
 	} else if (isChunkChecksumToken(selectorPart)) {
-		crc = selectorPart.toUpperCase();
+		crc = selectorPart.toLowerCase();
 		selectorPart = "";
 	}
 
@@ -376,15 +451,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":
@@ -486,22 +552,21 @@ export function missingChunkReadTarget(selector: string): ChunkReadTarget {
 
 export const chunkToolEditSchema = Type.Object(
 	{
-		path: Type.String({
-			description: "File path with chunk selector. Examples: 'src/app.ts:fn_foo#ABCD~', 'src/app.ts:class_Bar'.",
-		}),
+		path: Type.Optional(
+			Type.String({
+				description: "File path with chunk selector. Examples: 'src/app.ts:fn_foo#thth~', 'src/app.ts:class_Bar'.",
+			}),
+		),
 		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(
@@ -517,6 +582,7 @@ export const chunkToolEditSchema = Type.Object(
 );
 export const chunkEditParamsSchema = Type.Object(
 	{
+		path: Type.Optional(Type.String({ description: "Default file path used when an edit omits its own `path`" })),
 		edits: Type.Array(chunkToolEditSchema, {
 			description: "Chunk edits",
 			minItems: 1,
@@ -538,25 +604,6 @@ export interface ExecuteChunkSingleOptions {
 	beginDeferredDiagnosticsForPath: (path: string) => WritethroughDeferredHandle;
 }
 
-export function isChunkParams(params: unknown): params is ChunkParams {
-	if (
-		typeof params !== "object" ||
-		params === null ||
-		!("edits" in params) ||
-		!Array.isArray(params.edits) ||
-		params.edits.length === 0
-	) {
-		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.
-	return typeof first === "object" && first !== null && "path" in first;
-}
-
 /** Auto-correct indentation for content targeting a body region (`~`) when autoIndent is on.
  *  Handles two patterns:
  *  1. Tab-based over-indentation: models include the function's base \t indent.
@@ -605,6 +652,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 +682,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 +705,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 +718,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 +782,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 !== ".") {