pi-hashline-edit-pro 0.9.3 → 0.9.4

package/README.md

@@ -79,7 +79,7 @@ Replaces using the `HASH│content` anchors from `read` output to target lines p
 - **Request structure validation.** The request envelope (`path`, `edits`) and individual edit items are validated before any file I/O. Unknown fields, missing required fields, invalid types, and malformed anchors are rejected with `[E_BAD_SHAPE]` or `[E_BAD_REF]`.
 - **Legacy dialect rejected.** The native top-level `oldText`/`newText` (and `old_text`/`new_text`) dialect is rejected with `[E_LEGACY_SHAPE]`. The error message tells the model to call `read` first and send `{old_range: ["<START>", "<END>"], new_lines: [...]}`.
 
-All edits in a single call validate against the same pre-edit snapshot and apply bottom-up, so line numbers stay consistent across operations.
+All edits in a single call validate against the same pre-edit snapshot and apply bottom-up, so the hashes from a single `read` call remain valid across all edits in the batch.
 
 ### Chained edits
 
@@ -108,6 +108,7 @@ The post-edit diff (with `+`/`-` markers) is exposed to the host UI via `details
 - **Legacy dialect rejected.** The native top-level `oldText`/`newText` (and `old_text`/`new_text`) dialect is rejected with `[E_LEGACY_SHAPE]`. The error message tells the model to call `read` first and send `{old_range: ["<START>", "<END>"], new_lines: [...]}`.
 - **Atomic writes.** Files are written via temp-file-then-rename to avoid corruption from interrupted writes. Symlink chains are resolved so the target file is updated without replacing the symlink. Hard-linked files are updated in place to preserve the shared inode. File permissions are preserved across atomic renames.
 - **Per-file mutation queue.** Edits queue by the canonical write target, so concurrent edits through different symlink paths still serialize onto the same underlying file.
+- **Boundary duplication warnings.** When the last line of a replacement matches the next surviving line (or the first line matches the preceding one), a warning is emitted. This catches a common LLM pattern where closing delimiters like `}`, `});`, or `} else {` are accidentally duplicated. The warning includes the surviving line's post-edit hash so the model can reference it in a follow-up edit. No autocorrection is applied — the duplicate stays in the file and the model decides whether to remove it. Raw line comparison (not trimmed) avoids false positives when indentation differs.
 
 ## Hashing
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "0.9.3",
+  "version": "0.9.4",
   "description": "Strict hashline read/replace tool for pi-coding-agent with hash-anchored edits (3-char, 18-bit, perfect hashing)",
   "main": "index.ts",
   "repository": {

package/src/hashline/apply.ts

@@ -10,6 +10,7 @@ import {
 	type ResolvedHashlineEdit,
 	type NoopEdit,
 	type HashlineEdit,
+	type BoundaryDuplicationWarning,
 } from "./resolve";
 import { countVisibleLines } from "../utils";
 
@@ -248,7 +249,7 @@ export function applyHashlineEdits(
 	const noopEdits: NoopEdit[] = [];
 	const warnings: string[] = [];
 
-	const { resolved, mismatches } = validateAnchorEdits(
+	const { resolved, mismatches, boundaryWarnings } = validateAnchorEdits(
 		edits,
 		lineIndex.fileLines,
 		fileHashes,
@@ -277,6 +278,34 @@ export function applyHashlineEdits(
 	assertDoesNotEmptyFile(content, result);
 	const changedRange = computeChangedLineRange(content, result);
 
+	// Reconstruct boundary duplication warnings with post-edit hashes.
+	// Use position + occurrence to find the exact surviving line (handles
+	// files with multiple identical lines like several `}` closings).
+	const resultLines = result.split("\n");
+	const resultHashes = computeLineHashes(result);
+	for (const bw of boundaryWarnings) {
+		let seen = 0;
+		let matchIndex = -1;
+		for (let i = 0; i < resultLines.length; i++) {
+			if (resultLines[i] === bw.survivingLineContent) {
+				if (seen === bw.occurrence) { matchIndex = i; break; }
+				seen++;
+			}
+		}
+		if (matchIndex >= 0) {
+			const hash = resultHashes[matchIndex];
+			if (bw.kind === "trailing") {
+				warnings.push(
+					`Potential boundary duplication: the last line of the replacement (${JSON.stringify(bw.replacementLineContent)}) matches the next surviving line. Surviving line hash: ${hash}`
+				);
+			} else {
+				warnings.push(
+					`Potential boundary duplication: the first line of the replacement (${JSON.stringify(bw.replacementLineContent)}) matches the preceding surviving line. Surviving line hash: ${hash}`
+				);
+			}
+		}
+	}
+
 	return {
 		content: result,
 		firstChangedLine: changedRange?.firstChangedLine,

package/src/hashline/index.ts

@@ -26,6 +26,7 @@ export {
 	type ResolvedHashlineEdit,
 	type HashlineToolEdit,
 	type NoopEdit,
+	type BoundaryDuplicationWarning,
 	describeEdit,
 	resolveEditAnchors,
 	validateAnchorEdits,

package/src/hashline/resolve.ts

@@ -21,6 +21,15 @@ interface HashMismatch {
 	candidates?: number[];
 }
 
+export interface BoundaryDuplicationWarning {
+	kind: "trailing" | "leading";
+	survivingLineContent: string;
+	survivingLineIndex: number;
+	occurrence: number;
+	replacementLineContent: string;
+	editIndex: number;
+}
+
 export interface NoopEdit {
 	editIndex: number;
 	loc: string;
@@ -233,7 +242,7 @@ export function validateAnchorEdits(
 	fileHashes: string[],
 	warnings: string[],
 	signal: AbortSignal | undefined,
-): { resolved: ResolvedHashlineEdit[]; mismatches: HashMismatch[] } {
+): { resolved: ResolvedHashlineEdit[]; mismatches: HashMismatch[]; boundaryWarnings: BoundaryDuplicationWarning[] } {
 	if (fileHashes.length !== fileLines.length) {
 		throw new Error(
 			`validateAnchorEdits: fileHashes.length (${fileHashes.length}) must match fileLines.length (${fileLines.length}).`,
@@ -241,6 +250,7 @@ export function validateAnchorEdits(
 	}
 	const resolved: ResolvedHashlineEdit[] = [];
 	const mismatches: HashMismatch[] = [];
+	const boundaryWarnings: BoundaryDuplicationWarning[] = [];
 
 	const tryResolve = (ref: Anchor): ResolvedAnchor | undefined => {
 		const result = resolveAnchor(ref, fileLines, fileHashes);
@@ -266,36 +276,38 @@ export function validateAnchorEdits(
 		}
 		const endLine = endResolved.line;
 		const nextLine = fileLines[endLine];
-		const replacementLastLine = edit.new_lines.at(-1)?.trim();
+		const replacementLastLine = edit.new_lines.at(-1);
 		if (
 			nextLine !== undefined &&
-			replacementLastLine &&
-			/[\p{L}\p{N}]/u.test(replacementLastLine) &&
-			replacementLastLine === nextLine.trim()
+			replacementLastLine !== undefined &&
+			replacementLastLine.length > 0 &&
+			replacementLastLine === nextLine
 		) {
-			const resolvedEdit: ResolvedHashlineEdit = {
-				old_range: [startResolved, endResolved],
-				new_lines: edit.new_lines,
-			};
-			warnings.push(
-				`Potential boundary duplication after ${describeEdit(resolvedEdit)}: the replacement ends with a line that matches the next surviving line after trim.`,
-			);
+			boundaryWarnings.push({
+				kind: "trailing",
+				survivingLineContent: nextLine,
+				survivingLineIndex: endLine,
+				occurrence: fileLines.slice(0, endLine).filter(l => l === nextLine).length,
+				replacementLineContent: replacementLastLine,
+				editIndex: resolved.length,
+			});
 		}
 		const prevLine = fileLines[startResolved.line - 2];
-		const replacementFirstLine = edit.new_lines[0]?.trim();
+		const replacementFirstLine = edit.new_lines[0];
 		if (
 			prevLine !== undefined &&
-			replacementFirstLine &&
-			/[\p{L}\p{N}]/u.test(replacementFirstLine) &&
-			replacementFirstLine === prevLine.trim()
+			replacementFirstLine !== undefined &&
+			replacementFirstLine.length > 0 &&
+			replacementFirstLine === prevLine
 		) {
-			const resolvedEdit: ResolvedHashlineEdit = {
-				old_range: [startResolved, endResolved],
-				new_lines: edit.new_lines,
-			};
-			warnings.push(
-				`Potential boundary duplication before ${describeEdit(resolvedEdit)}: the replacement starts with a line that matches the preceding surviving line after trim.`,
-			);
+			boundaryWarnings.push({
+				kind: "leading",
+				survivingLineContent: prevLine,
+				survivingLineIndex: startResolved.line - 2,
+				occurrence: fileLines.slice(0, startResolved.line - 2).filter(l => l === prevLine).length,
+				replacementLineContent: replacementFirstLine,
+				editIndex: resolved.length,
+			});
 		}
 		resolved.push({
 			old_range: [startResolved, endResolved],
@@ -303,7 +315,7 @@ export function validateAnchorEdits(
 		});
 	}
 
-	return { resolved, mismatches };
+	return { resolved, mismatches, boundaryWarnings };
 }
 
 export { maybeWarnSuspiciousUnicodeEscapePlaceholder };