pi-hashline-edit-pro 2.1.1 → 2.2.0

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 in `new_content` or `hash_bounds`, diff-preview rows pasted into the replacement, a reversed range, or a boundary line pasted twice. `file_path` works as an alias for `path` in all three tools.
+- 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. New lines that duplicate unique lines adjacent to the range are stripped automatically — consecutive duplicates are stripped as a run, so re-including a whole unchanged block next to the range never duplicates it. `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.1",
+  "version": "2.2.0",
   "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",

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,
@@ -11,6 +11,7 @@ import {
 	type NEdit,
 	type HEdit,
 	type AutoFix,
+	type BDup,
 } from "./resolve";
 
 type LIdx = {
@@ -49,7 +50,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 +164,7 @@ export function applyEdit(
 		warnings,
 	);
 
-	const { resolved: initialResolved, mismatches, boundaryWarnings } = valEdit(
+	const { resolved: initialResolved, mismatches, boundaryDups } = valEdit(
 		prefixFixed,
 		lineIndex.fileLines,
 		fileHashes,
@@ -181,26 +181,27 @@ 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 seen = new Set<number>();
+		const uniqueDups: BDup[] = [];
+		for (const dup of boundaryDups) {
+			if (seen.has(dup.replacementLineIndex)) continue;
+			seen.add(dup.replacementLineIndex);
+			uniqueDups.push(dup);
+		}
+		const dupsByIndex = uniqueDups.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 { HASH_CLASS, HL_BARE_PREFIX_RE, HL_PREFIX_PLUS_RE, HL_PREFIX_MINUS_RE } from "./hash";
+import { abortIf, rejectUnknownFields, 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 {
@@ -284,24 +283,109 @@ export function swapReversedRanges(
 	return { ...edit, hash_bounds: [endRef, startRef] as [Anchor, Anchor] };
 }
 
-function checkBoundaryDup(
-	adjacentLine: string | undefined,
-	replacementEdge: string | undefined,
-	kind: "trailing" | "leading",
-	survivingLineIndex: number,
-): BDupWarn | null {
-	if (
-		adjacentLine === undefined ||
-		replacementEdge === undefined ||
-		replacementEdge.length === 0 ||
-		replacementEdge !== adjacentLine
-	) return null;
-  return {
-    kind,
-    survivingLineContent: adjacentLine,
-    survivingLineIndex,
-    replacementLineContent: replacementEdge,
-  };
+function trailingDups(
+	contentLines: string[],
+	fileLines: string[],
+	endLine: number,
+): BDup[] {
+	const start = lastNonEmptyIndex(contentLines);
+	if (start < 0) return [];
+	const dups: BDup[] = [];
+	const maxK = Math.min(start + 1, fileLines.length - endLine);
+	for (let k = 0; k < maxK; k++) {
+		if (contentLines[start - k] !== fileLines[endLine + k]) break;
+		dups.push({ kind: "trailing", replacementLineIndex: start - k });
+	}
+	return dups;
+}
+
+function leadingDups(
+	contentLines: string[],
+	fileLines: string[],
+	startLine: number,
+): BDup[] {
+	const start = firstNonEmptyIndex(contentLines);
+	if (start < 0) return [];
+	const dups: BDup[] = [];
+	const maxK = Math.min(contentLines.length - start, startLine - 1);
+	for (let k = 0; k < maxK; k++) {
+		if (contentLines[start + k] !== fileLines[startLine - 2 - k]) break;
+		dups.push({ kind: "leading", replacementLineIndex: start + k });
+	}
+	return dups;
+}
+
+function firstNewAfterDups(
+	contentLines: string[],
+	rangeLines: string[],
+	fileLines: string[],
+	endLine: number,
+	fileCounts: Map<string, number>,
+): BDup[] {
+	const firstNew = findNewEdge(contentLines, rangeLines, false);
+	if (!firstNew) return [];
+	const dups: BDup[] = [];
+	const maxK = Math.min(contentLines.length - firstNew.index, fileLines.length - endLine);
+	for (let k = 0; k < maxK; k++) {
+		const newLine = contentLines[firstNew.index + k]!;
+		const fileLine = fileLines[endLine + k]!;
+		if (canon(newLine) !== canon(fileLine)) break;
+		if ((fileCounts.get(canon(fileLine)) ?? 0) !== 1) break;
+		dups.push({ kind: "first-new-after", replacementLineIndex: firstNew.index + k });
+	}
+	return dups;
+}
+
+function lastNewBeforeDups(
+	contentLines: string[],
+	rangeLines: string[],
+	fileLines: string[],
+	startLine: number,
+	fileCounts: Map<string, number>,
+): BDup[] {
+	const lastNew = findNewEdge(contentLines, rangeLines, true);
+	if (!lastNew) return [];
+	const dups: BDup[] = [];
+	const maxK = Math.min(lastNew.index + 1, startLine - 1);
+	for (let k = 0; k < maxK; k++) {
+		const newLine = contentLines[lastNew.index - k]!;
+		const fileLine = fileLines[startLine - 2 - k]!;
+		if (canon(newLine) !== canon(fileLine)) break;
+		if ((fileCounts.get(canon(fileLine)) ?? 0) !== 1) break;
+		dups.push({ kind: "last-new-before", replacementLineIndex: lastNew.index - k });
+	}
+	return dups;
+}
+
+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;
 }
 
 export function valEdit(
@@ -310,10 +394,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++) {
@@ -343,7 +427,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(
@@ -351,14 +435,14 @@ 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 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 rangeLines = fileLines.slice(startResolved.line - 1, endLine);
+	const fileCounts = canonCounts(fileLines);
+	boundaryDups.push(
+		...trailingDups(edit.content_lines, fileLines, endLine),
+		...leadingDups(edit.content_lines, fileLines, startResolved.line),
+		...firstNewAfterDups(edit.content_lines, rangeLines, fileLines, endLine, fileCounts),
+		...lastNewBeforeDups(edit.content_lines, rangeLines, fileLines, startResolved.line, fileCounts),
+	);
 
 	return {
 		resolved: {
@@ -366,7 +450,7 @@ export function valEdit(
 			hash_bounds: [startResolved, endResolved],
 		},
 		mismatches,
-		boundaryWarnings,
+		boundaryDups,
 	};
 }
 

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-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

@@ -10,7 +10,7 @@ import { toLF, stripBOM, genDiff, restoreEndings, type LineEnding } from "./repl
 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;
@@ -159,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

@@ -241,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) };
   }