pi-hashline-edit-pro 2.1.0 → 2.1.2

package/README.md

@@ -91,7 +91,7 @@ One edit per call, with `hash_bounds` and `new_content` at the top level:
 Notes:
 
 - The request is checked before any file I/O, so a bad request never touches the file.
-- Common copy-paste slips are fixed automatically and reported: a leftover `HASH│` prefix, diff-preview rows pasted into the replacement, a reversed range, or a boundary line pasted twice. `file_path` works as an alias for `path`.
+- Common copy-paste slips are fixed automatically and reported: a leftover `HASH│` prefix in `new_content` or `hash_bounds`, diff-preview rows pasted into the replacement, a reversed range, or a boundary line pasted twice. A new line that duplicates a unique line adjacent to the range is stripped automatically. `file_path` works as an alias for `path` in all three tools.
 - An edit that produces identical content reports `No changes made` and leaves the anchors alone.
 - After a successful edit you get the post-edit diff with fresh anchors, so you can keep editing without re-reading.
 
@@ -110,7 +110,7 @@ Notes:
 Enabled by default. After a successful `write` that changes the file, the extension reads the file and appends an `--- Auto-read (hashline anchors) ---` block to the result, so you get fresh `HASH│content` anchors without a separate `read` call.
 
 - After `replace` and `undo_last_replace`, the result shows the post-edit diff. The `+HASH│` and ` HASH│` rows carry the current hashes, so follow-up edits can anchor on the diff directly. Call `read` when you want the full file's anchors.
-- After `write`, the block dumps from the top of the file. For files over 2000 lines, the dump is truncated with a pagination hint; use `read` with `offset` to continue.
+- After `replace` and `undo_last_replace`, the result shows the post-edit diff. The `+HASH│` and ` HASH│` rows carry the current hashes, so follow-up edits can anchor on the diff directly. The `-HASH│` rows show removed lines with their old hashes, so you can see exactly which anchors were deleted (those hashes are stale after the edit). Call `read` when you want the full file's anchors.
 - Auto-read keeps a 50KB display budget. Lines over 50KB are skipped with a marker instead of their content (use `read` for lines up to 200KB).
 - Toggle at runtime with `/toggle-auto-read`; the setting persists across sessions.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "type": "module",
   "description": "Strict hashline read/replace tool for pi-coding-agent with hash-anchored edits (3-char, 62-symbol, perfect hashing)",
   "main": "index.ts",
@@ -49,7 +49,8 @@
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage --coverage.thresholds.lines=90 --coverage.thresholds.statements=90 --coverage.thresholds.functions=85 --coverage.thresholds.branches=80",
     "lint": "eslint \"src/**/*.ts\" \"index.ts\" \"test/**/*.ts\"",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run typecheck && npm run lint && npm test"
   },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "^0.84.0",

package/prompts/replace-guidelines.md

@@ -3,4 +3,4 @@
 - `replace`: to replace a single line, repeat its hash in both positions of hash_bounds: ["<HASH>", "<HASH>"] — never extend the range to neighboring lines for a one-line edit.
 - `replace`: when copying a line from read output, remove its HASH│ prefix and keep the leading whitespace exactly as shown.
 - `replace`: to add a blank line, end new_content with an explicit empty line (e.g. ending with \n\n).
-- `replace`: when auto-read shows the post-edit diff, its rows are the fresh anchors for the new file — `+HASH│` and ` HASH│` rows carry current hashes and unchanged lines keep their previous hashes, so you can anchor follow-up edits on the diff without re-reading.
+- `replace`: when auto-read shows the post-edit diff, its rows are the fresh anchors for the new file — `+HASH│` and ` HASH│` rows carry current hashes and unchanged lines keep their previous hashes, so you can anchor follow-up edits on the diff without re-reading. `-HASH│` rows show removed lines with their old hashes; those hashes are stale after the edit.

package/prompts/undo-last-replace-guidelines.md

@@ -1,2 +1,2 @@
 - `undo_last_replace`: reverts only the most recent replace on the file — any write to the file clears the undo history, so call it immediately after a bad replace.
-- `undo_last_replace`: when auto-read shows the post-edit diff, its `+HASH│` and ` HASH│` rows are the fresh anchors for the restored file, so follow-up edits can anchor on the diff without re-reading.
+- `undo_last_replace`: when auto-read shows the post-edit diff, its `+HASH│` and ` HASH│` rows are the fresh anchors for the restored file, so follow-up edits can anchor on the diff without re-reading. `-HASH│` rows show removed lines with their old hashes; those hashes are stale after the undo.

package/src/hashline/apply.ts

@@ -1,4 +1,4 @@
-import { abortIf, splitLines, lastNonEmptyIndex, firstNonEmptyIndex } from "../utils";
+import { abortIf, splitLines } from "../utils";
 import { _lineHashesPure, HASH_SEP } from "./hash";
 import {
 	valEdit,
@@ -49,7 +49,6 @@ type NoopSpan = {
 	loc: string;
 	currentContent: string;
 };
-
 function assertNotEmpty(originalContent: string, result: string): void {
 	if (originalContent.length > 0 && result.length === 0) {
 		throw new Error(
@@ -164,7 +163,7 @@ export function applyEdit(
 		warnings,
 	);
 
-	const { resolved: initialResolved, mismatches, boundaryWarnings } = valEdit(
+	const { resolved: initialResolved, mismatches, boundaryDups } = valEdit(
 		prefixFixed,
 		lineIndex.fileLines,
 		fileHashes,
@@ -181,26 +180,20 @@ export function applyEdit(
 
 	let resolved = initialResolved;
 	let autoFixes: AutoFix[] | undefined;
-	if (boundaryWarnings.length > 0) {
+	if (boundaryDups.length > 0) {
 		autoFixes = [];
 		const correctedEdit: HEdit = {
 			...prefixFixed,
 			content_lines: [...prefixFixed.content_lines],
 		};
-		for (const bw of boundaryWarnings) {
-			if (bw.kind === "trailing") {
-				const idx = lastNonEmptyIndex(correctedEdit.content_lines);
-				if (idx >= 0) {
-					const removed = correctedEdit.content_lines.splice(idx, 1)[0];
-					autoFixes.push({ kind: "trailing", removedLine: removed });
-				}
-			} else {
-				const idx = firstNonEmptyIndex(correctedEdit.content_lines);
-				if (idx >= 0) {
-					const removed = correctedEdit.content_lines.splice(idx, 1)[0];
-					autoFixes.push({ kind: "leading", removedLine: removed });
-				}
-			}
+		const dupsByIndex = [...boundaryDups].sort(
+			(a, b) => b.replacementLineIndex - a.replacementLineIndex,
+		);
+		for (const dup of dupsByIndex) {
+			const idx = dup.replacementLineIndex;
+			if (idx < 0 || idx >= correctedEdit.content_lines.length) continue;
+			const removed = correctedEdit.content_lines.splice(idx, 1)[0];
+			autoFixes.push({ kind: dup.kind, removedLine: removed, removedLineIndex: idx });
 		}
 		const correctedResult = valEdit(
 			correctedEdit,

package/src/hashline/hash.ts

@@ -47,7 +47,7 @@ export const HL_PREFIX_MINUS_RE = new RegExp(
 
 export const HL_BARE_PREFIX_RE = new RegExp(`^\\s*(${HASH_CLASS})│`);
 
-function canon(line: string): string {
+export function canon(line: string): string {
 	return line.replace(/\r/g, "").trimEnd();
 }
 

package/src/hashline/index.ts

@@ -12,6 +12,7 @@ export {
 	lineHashes,
 	_lineHashesPure,
 	initHasher,
+	canon,
 } from "./hash";
 
 export {
@@ -26,7 +27,7 @@ export {
 	type RHEdit,
 	type HTEdit,
 	type NEdit,
-	type BDupWarn,
+	type BDup,
 	type AutoFix,
 	resEdit,
 	valEdit,
@@ -34,6 +35,7 @@ export {
 	stripDiffPrefixes,
 	swapReversedRanges,
 	fmtMismatch,
+	findNewEdge,
 } from "./resolve";
 
 export {

package/src/hashline/resolve.ts

@@ -1,5 +1,5 @@
-import { abortIf, rejectUnknownFields, lastNonEmpty, firstNonEmpty, clipLine } from "../utils";
-import { HL_BARE_PREFIX_RE, HL_PREFIX_PLUS_RE, HL_PREFIX_MINUS_RE } from "./hash";
+import { abortIf, rejectUnknownFields, lastNonEmpty, firstNonEmpty, firstNonEmptyIndex, lastNonEmptyIndex, clipLine } from "../utils";
+import { HASH_CLASS, HL_BARE_PREFIX_RE, HL_PREFIX_PLUS_RE, HL_PREFIX_MINUS_RE, canon } from "./hash";
 import { parseHashRef, parseText, type Anchor } from "./parse";
 import { NEW_CONTENT_NOT_STRING_MSG } from "../constants";
 
@@ -22,16 +22,15 @@ interface HMismatch {
 	context?: RAnchor;
 }
 
-export interface BDupWarn {
-	kind: "trailing" | "leading";
-	survivingLineContent: string;
-	survivingLineIndex: number;
-	replacementLineContent: string;
+export interface BDup {
+	kind: "trailing" | "leading" | "first-new-after" | "last-new-before";
+	replacementLineIndex: number;
 }
 
 export interface AutoFix {
-  kind: "trailing" | "leading";
-  removedLine: string;
+	kind: "trailing" | "leading" | "first-new-after" | "last-new-before";
+	removedLine: string;
+	removedLineIndex: number;
 }
 
 export interface NEdit {
@@ -161,13 +160,32 @@ function assertItem(edit: Record<string, unknown>): void {
   }
 }
 
-export function resEdit(edit: HTEdit): HEdit {
+const ANCHOR_ROW_RE = new RegExp(`^([+-]?)(${HASH_CLASS})│`);
+
+export function resEdit(edit: HTEdit, warnings?: string[]): HEdit {
   assertItem(edit as Record<string, unknown>);
 
   const replaceLines = parseText(edit.new_content);
+  const bounds = edit.hash_bounds.map((ref) => {
+    const trimmed = ref.trim();
+    const match = trimmed.match(ANCHOR_ROW_RE);
+    if (match) {
+      let message: string;
+      if (match[1] === "+") {
+        message = `[E_BAD_REF] Autocorrected: stripped diff-preview marker copied from the diff preview in hash_bounds entry "${trimmed}".`;
+      } else if (match[1] === "-") {
+        message = `[E_BAD_REF] Autocorrected: stripped leading "-" marker in hash_bounds entry "${trimmed}".`;
+      } else {
+        message = `[E_BAD_REF] Autocorrected: stripped "HASH│" prefix copied from read output in hash_bounds entry "${trimmed}".`;
+      }
+      warnings?.push(message);
+      return match[2]!;
+    }
+    return ref;
+  }) as [string, string];
   return {
     content_lines: replaceLines,
-    hash_bounds: [parseHashRef(edit.hash_bounds[0]), parseHashRef(edit.hash_bounds[1])],
+    hash_bounds: [parseHashRef(bounds[0]), parseHashRef(bounds[1])],
   };
 }
 
@@ -265,24 +283,79 @@ export function swapReversedRanges(
 	return { ...edit, hash_bounds: [endRef, startRef] as [Anchor, Anchor] };
 }
 
+function edgeRef(
+	line: string | undefined,
+	index: number,
+): { index: number; line: string } | undefined {
+	return line === undefined ? undefined : { index, line };
+}
+
 function checkBoundaryDup(
 	adjacentLine: string | undefined,
-	replacementEdge: string | undefined,
-	kind: "trailing" | "leading",
-	survivingLineIndex: number,
-): BDupWarn | null {
+	replacementEdge: { index: number; line: string } | undefined,
+	kind: BDup["kind"],
+	canonical = false,
+	uniqueInFile?: Map<string, number>,
+): BDup | null {
 	if (
 		adjacentLine === undefined ||
 		replacementEdge === undefined ||
-		replacementEdge.length === 0 ||
-		replacementEdge !== adjacentLine
-	) return null;
-  return {
-    kind,
-    survivingLineContent: adjacentLine,
-    survivingLineIndex,
-    replacementLineContent: replacementEdge,
-  };
+		replacementEdge.line.length === 0
+	) {
+		return null;
+	}
+	const matches = canonical
+		? canon(adjacentLine) === canon(replacementEdge.line)
+		: adjacentLine === replacementEdge.line;
+	if (!matches) return null;
+	if (uniqueInFile && (uniqueInFile.get(canon(adjacentLine)) ?? 0) !== 1) {
+		return null;
+	}
+	return {
+		kind,
+		replacementLineIndex: replacementEdge.index,
+	};
+}
+
+function canonCounts(lines: string[]): Map<string, number> {
+	const counts = new Map<string, number>();
+	for (const line of lines) {
+		const key = canon(line);
+		counts.set(key, (counts.get(key) ?? 0) + 1);
+	}
+	return counts;
+}
+
+export function findNewEdge(
+	contentLines: string[],
+	rangeLines: string[],
+	fromEnd: boolean,
+): { index: number; line: string } | undefined {
+	const multiset = canonCounts(rangeLines);
+	const step = fromEnd ? -1 : 1;
+	const start = fromEnd ? contentLines.length - 1 : 0;
+	for (let i = start; i >= 0 && i < contentLines.length; i += step) {
+		const line = contentLines[i]!;
+		if (line.length === 0) continue;
+		const key = canon(line);
+		const count = multiset.get(key) ?? 0;
+		if (count > 0) {
+			multiset.set(key, count - 1);
+		} else {
+			return { index: i, line };
+		}
+	}
+	return undefined;
+}
+
+function newEdgeLines(
+	contentLines: string[],
+	rangeLines: string[],
+): { firstNew: { index: number; line: string } | undefined; lastNew: { index: number; line: string } | undefined } {
+	return {
+		firstNew: findNewEdge(contentLines, rangeLines, false),
+		lastNew: findNewEdge(contentLines, rangeLines, true),
+	};
 }
 
 export function valEdit(
@@ -291,10 +364,10 @@ export function valEdit(
 	fileHashes: string[],
 	warnings: string[],
 	signal: AbortSignal | undefined,
-): { resolved: RHEdit | undefined; mismatches: HMismatch[]; boundaryWarnings: BDupWarn[] } {
+): { resolved: RHEdit | undefined; mismatches: HMismatch[]; boundaryDups: BDup[] } {
 	assertAligned(fileLines, fileHashes, "valEdit");
 	const mismatches: HMismatch[] = [];
-	const boundaryWarnings: BDupWarn[] = [];
+	const boundaryDups: BDup[] = [];
 
 	const hashIndex = new Map<string, number[]>();
 	for (let i = 0; i < fileHashes.length; i++) {
@@ -324,7 +397,7 @@ export function valEdit(
 			const endMismatch = mismatches.findLast((m) => m.ref === edit.hash_bounds[1]);
 			if (endMismatch && endMismatch.kind === "not_found") endMismatch.context = startResolved;
 		}
-		return { resolved: undefined, mismatches, boundaryWarnings };
+		return { resolved: undefined, mismatches, boundaryDups };
 	}
 	if (startResolved.line > endResolved.line) {
 		throw new Error(
@@ -334,12 +407,19 @@ export function valEdit(
 	const endLine = endResolved.line;
 	const nextLine = fileLines[endLine];
 	const replacementLastLine = lastNonEmpty(edit.content_lines);
-	const trailing = checkBoundaryDup(nextLine, replacementLastLine, "trailing", endLine);
-	if (trailing) boundaryWarnings.push(trailing);
+	const trailing = checkBoundaryDup(nextLine, edgeRef(replacementLastLine, lastNonEmptyIndex(edit.content_lines)), "trailing");
+	if (trailing) boundaryDups.push(trailing);
 	const prevLine = fileLines[startResolved.line - 2];
 	const replacementFirstLine = firstNonEmpty(edit.content_lines);
-	const leading = checkBoundaryDup(prevLine, replacementFirstLine, "leading", startResolved.line - 2);
-	if (leading) boundaryWarnings.push(leading);
+	const leading = checkBoundaryDup(prevLine, edgeRef(replacementFirstLine, firstNonEmptyIndex(edit.content_lines)), "leading");
+	if (leading) boundaryDups.push(leading);
+	const rangeLines = fileLines.slice(startResolved.line - 1, endLine);
+	const { firstNew, lastNew } = newEdgeLines(edit.content_lines, rangeLines);
+	const fileCounts = canonCounts(fileLines);
+	const firstNewAfter = checkBoundaryDup(nextLine, firstNew, "first-new-after", true, fileCounts);
+	if (firstNewAfter) boundaryDups.push(firstNewAfter);
+	const lastNewBefore = checkBoundaryDup(prevLine, lastNew, "last-new-before", true, fileCounts);
+	if (lastNewBefore) boundaryDups.push(lastNewBefore);
 
 	return {
 		resolved: {
@@ -347,7 +427,7 @@ export function valEdit(
 			hash_bounds: [startResolved, endResolved],
 		},
 		mismatches,
-		boundaryWarnings,
+		boundaryDups,
 	};
 }
 

package/src/read.ts

@@ -12,7 +12,7 @@ import { loadFileKindAndText } from "./file-kind";
 import { readNormFile } from "./file-reader";
 import { lineHashes, fmtRegion, HASH_SEP, MAX_HASH_LINES } from "./hashline";
 import { toCwd } from "./paths";
-import { abortIf } from "./utils";
+import { abortIf, isRec, normalizeFilePath } from "./utils";
 import { fileSnap } from "./file-reader";
 import { visLines } from "./utils";
 import { loadP, loadGuide } from "./prompts";
@@ -154,6 +154,12 @@ export function regRead(pi: ExtensionAPI): void {
 		description: R_DESC,
 		promptSnippet: R_SNIPPET,
 		promptGuidelines: readGuide(),
+		prepareArguments: (args: unknown) => {
+			if (!isRec(args)) return args as any;
+			const record = { ...args };
+			normalizeFilePath(record);
+			return record;
+		},
 		parameters: Type.Object({
 			path: Type.String({
 				description: "Path to the file to read (relative or absolute)",

package/src/replace-diff.ts

@@ -56,12 +56,14 @@ export function genDiff(
   newContent: string,
   contextLines = 2,
   newContentHashes?: string[],
+  oldContentHashes?: string[],
 ): { diff: string; firstChangedLine: number | undefined } {
   const effectiveNewHashes = newContentHashes ?? _lineHashesPure(newContent);
 
   const parts = Diff.diffLines(oldContent, newContent);
   const output: string[] = [];
   let newLineNum = 1;
+  let oldLineNum = 1;
   let lastWasChange = false;
   let firstChangedLine: number | undefined;
 
@@ -79,7 +81,9 @@ export function genDiff(
           output.push(fmtDiffLine("+", displayLines[k]!, hash));
           newLineNum++;
         } else {
-          output.push(fmtDiffLine("-", displayLines[k]!, undefined));
+          const hash = oldContentHashes?.[oldLineNum - 1];
+          output.push(fmtDiffLine("-", displayLines[k]!, hash));
+          oldLineNum++;
         }
       }
       lastWasChange = true;
@@ -107,19 +111,23 @@ export function genDiff(
       if (skipStart > 0) {
         output.push(" ...");
         newLineNum += skipStart;
+        oldLineNum += skipStart;
       }
       for (const line of linesToShow) {
         if (isEllipsisMarker(line)) {
           output.push(" ...");
           newLineNum += skipMiddle;
+          oldLineNum += skipMiddle;
           continue;
         }
         const hash = effectiveNewHashes[newLineNum - 1];
         output.push(fmtDiffLine(" ", line, hash));
         newLineNum++;
+        oldLineNum++;
       }
     } else {
       newLineNum += displayLines.length;
+      oldLineNum += displayLines.length;
     }
     lastWasChange = false;
   }

package/src/replace-normalize.ts

@@ -1,11 +1,4 @@
-import { isRec } from "./utils";
-
-export function normalizeFilePath(record: Record<string, unknown>): void {
-  if (typeof record.path !== "string" && typeof record.file_path === "string") {
-    record.path = record.file_path;
-    delete record.file_path;
-  }
-}
+import { isRec, normalizeFilePath } from "./utils";
 
 export function normReq(input: unknown): unknown {
   if (!isRec(input)) {

package/src/replace-render.ts

@@ -163,62 +163,8 @@ function trimEmpty(lines: string[]): string[] {
 	return lines.slice(start, end);
 }
 
-function isSectionBoundary(line: string): boolean {
-	return (
-		line === "--- Anchors ---" ||
-		line === "Warnings:" ||
-		line === "Structure outline:" ||
-		/^--- Range \d+ ---$/.test(line)
-	);
-}
-
 export function fmtResultMd(text: string): string {
-	const lines = text.split("\n");
-	const sections: string[] = [];
-	let plainLines: string[] = [];
-
-	const flush = () => {
-		const trimmed = trimEmpty(plainLines);
-		if (trimmed.length > 0) {
-			sections.push(trimmed.join("\n"));
-		}
-		plainLines = [];
-	};
-
-	let index = 0;
-	while (index < lines.length) {
-		const line = lines[index]!;
-
-		if (line.startsWith("--- Anchors ")) {
-			flush();
-			const title = line.replace(/^---\s*/, "").replace(/\s*---$/, "");
-			index++;
-			const bodyLines: string[] = [];
-			while (
-				index < lines.length &&
-				!isSectionBoundary(lines[index]!)
-			) {
-				bodyLines.push(lines[index]!);
-				index++;
-			}
-			sections.push(
-				[
-					`#### ${title}`,
-					"```text",
-					...trimEmpty(bodyLines),
-					"```",
-				].join("\n"),
-			);
-			continue;
-		}
-
-		plainLines.push(line);
-		index++;
-	}
-
-	flush();
-
-	return sections.join("\n\n");
+	return trimEmpty(text.split("\n")).join("\n");
 }
 
 export function mkMdTheme(theme: MdTheme) {

package/src/replace-response.ts

@@ -123,10 +123,9 @@ export function buildNoop(input: NoopInput): TResult {
 }
 
 export function buildChanged(input: SuccessInput): TResult {
-  const { path, result, warnings, snapshotId, originalNormalized, editMeta, resultHashes } = input;
-
+  const { path, result, warnings, snapshotId, originalNormalized, originalHashes, editMeta, resultHashes } = input;
   const resultLines = visLines(result);
-  const diffResult = genDiff(originalNormalized, result, 1, resultHashes);
+  const diffResult = genDiff(originalNormalized, result, 1, resultHashes, originalHashes);
   const addedLines = editMeta.addedLines;
   const removedLines = editMeta.removedLines;
   const warningsBlock = warnBlock(warnings);

package/src/replace-undo.ts

@@ -7,10 +7,10 @@ import { contentChecksum } from "./hashline/hasher";
 import { resolveTarget, writeAtomic } from "./fs-write";
 import { toCwd } from "./paths";
 import { toLF, stripBOM, genDiff, restoreEndings, type LineEnding } from "./replace-diff";
-import { cntDiff, splitLines, errCode } from "./utils";
+import { cntDiff, splitLines, errCode, isRec, normalizeFilePath } from "./utils";
 import { loadP, loadGuide } from "./prompts";
 import { buildMetrics } from "./replace-response";
-import { changedRange } from "./hashline";
+import { changedRange, lineHashes } from "./hashline";
 export interface UndoEntry {
   content: string;
   bom: string;
@@ -91,6 +91,12 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
     description: loadP("../prompts/undo-last-replace.md"),
     promptSnippet: loadP("../prompts/undo-last-replace-snippet.md"),
     promptGuidelines: loadGuide("../prompts/undo-last-replace-guidelines.md"),
+    prepareArguments: (args: unknown) => {
+      if (!isRec(args)) return args as any;
+      const record = { ...args };
+      normalizeFilePath(record);
+      return record;
+    },
     parameters: Type.Object({
       path: Type.String({
         description: "Path to the file to undo",
@@ -153,11 +159,12 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
 
         const { text: currentStripped } = stripBOM(currentRaw);
         const currentNormalized = toLF(currentStripped);
-        const diffResult = genDiff(undo.content, currentNormalized, 0);
+        const currentHashes = await lineHashes(currentNormalized, mutationTargetPath);
+        const diffResult = genDiff(undo.content, currentNormalized, 0, undefined, undo.hashes);
         const linesAddedByReplace = cntDiff(diffResult.diff, "+");
         const linesRemovedByReplace = cntDiff(diffResult.diff, "-");
         const restoredRange = changedRange(currentNormalized, undo.content);
-        const undoDiff = genDiff(currentNormalized, undo.content, 1, undo.hashes).diff;
+        const undoDiff = genDiff(currentNormalized, undo.content, 1, undo.hashes, currentHashes).diff;
 
         await writeAtomic(
           mutationTargetPath,

package/src/replace.ts

@@ -12,8 +12,8 @@ import {
   type LineEnding,
 } from "./replace-diff";
 import { readNormFile } from "./file-reader";
-import { normReq, normalizeFilePath } from "./replace-normalize";
-import { isRec, rejectUnknownFields, abortIf } from "./utils";
+import { normReq } from "./replace-normalize";
+import { isRec, rejectUnknownFields, abortIf, normalizeFilePath } from "./utils";
 import { resolveTarget, writeAtomic } from "./fs-write";
 import { applyEdit,
   lineHashes,
@@ -175,10 +175,14 @@ export async function execPipeline(
 
   const path = params.path;
 
-  const edit = resEdit({
-    hash_bounds: params.hash_bounds,
-    new_content: params.new_content,
-  });
+  const editWarnings: string[] = [];
+  const edit = resEdit(
+    {
+      hash_bounds: params.hash_bounds,
+      new_content: params.new_content,
+    },
+    editWarnings,
+  );
 
   const hashStore = options?.store ?? await loadHashStore();
   const { normalized: originalNormalized, bom, originalEnding, fileHashes: originalHashes, hadUtf8DecodeErrors, absolutePath } = await readNormFile(
@@ -207,8 +211,7 @@ export async function execPipeline(
         hashes: originalHashes,
         removedHashes,
       }, hashStore, noPersist !== true);
-  const warnings = [...(anchorResult.warnings ?? [])];
-
+  const warnings = [...editWarnings, ...(anchorResult.warnings ?? [])];
   const { totalAddedLines, totalRemovedLines } = countLineChanges(
     edit, originalHashes, isNoop, anchorResult.autoFixes?.length ?? 0,
   );
@@ -238,19 +241,18 @@ export async function compPreview(
   try {
     const normalized = normReq(request);
     assertReq(normalized);
-    const { path, originalNormalized, result, resultHashes } = await execPipeline(
+    const { path, originalNormalized, result, resultHashes, originalHashes } = await execPipeline(
       normalized,
       cwd,
       { accessMode: constants.R_OK, noPersist: true },
     );
-
     if (originalNormalized === result) {
       return {
         error: `No changes made to ${path}. The edit produced identical content.`,
       };
     }
 
-    return { diff: genDiff(originalNormalized, result, 4, resultHashes).diff };
+    return { diff: genDiff(originalNormalized, result, 4, resultHashes, originalHashes).diff };
   } catch (error: unknown) {
     return { error: error instanceof Error ? error.message : String(error) };
   }

package/src/utils.ts

@@ -2,8 +2,11 @@ export function isRec(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-export function has(record: Record<string, unknown>, key: string): boolean {
-	return Object.hasOwn(record, key);
+export function normalizeFilePath(record: Record<string, unknown>): void {
+  if (typeof record.path !== "string" && typeof record.file_path === "string") {
+    record.path = record.file_path;
+    delete record.file_path;
+  }
 }
 
 export function splitLines(text: string): string[] {