pi-hashline-edit-pro 0.9.2 → 0.9.4

package/README.md

@@ -76,14 +76,14 @@ Replaces using the `HASH│content` anchors from `read` output to target lines p
 | `old_range` | Inclusive line range `[start_hash, end_hash]` (required). |
 | `new_lines` | Replacement content (one string per line). Use `[]` to delete. |
 
-- **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_OP]`.
+- **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
 
-After a successful replace, the result text contains an `--- Anchors ---` block with fresh `HASH│content` references for the changed region. These can be used directly in the next `replace` call on the same file without a full re-read, provided the next replace targets the same or nearby lines. For distant changes, use `read` first.
+After a successful replace, the response text is empty (warnings are still shown if present). To get fresh anchors for follow-up edits, call `read` on the file first. This avoids token overhead from re-displaying content the model already knows.
 
 ### Auto-read after write
 
@@ -98,7 +98,7 @@ For large files (>2000 lines), the auto-read output is truncated with a paginati
 
 ### Diff for the host
 
-The post-edit diff (with `+`/`-` markers and new `HASH│content` anchors) is exposed to the host UI via `details.diff`. It is intentionally not in the LLM-visible text. The model only needs the fresh anchors in `text` to chain follow-up edits, and re-emitting the diff would cost extra tokens.
+The post-edit diff (with `+`/`-` markers) is exposed to the host UI via `details.diff`. It is intentionally not in the LLM-visible text. The model already knows what it changed and can call `read` for fresh anchors when needed.
 
 ## Design Decisions
 
@@ -108,6 +108,7 @@ The post-edit diff (with `+`/`-` markers and new `HASH│content` anchors) is ex
 - **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.2",
+  "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/prompts/replace.md

@@ -59,7 +59,7 @@ Rules:
 - If `new_lines` matches current content, the replace is classified as `noop` (file unchanged).
 - The `old_range` is inclusive — both anchors and every line between them are replaced. If your replacement content includes lines that already exist in the file (e.g. closing brackets), make sure those lines are within your range, otherwise they will appear twice.
 
-On success, the response contains an `--- Anchors ---` block with fresh HASH anchors for the changed region. Use those for nearby follow-up replaces instead of re-reading.
+On success, the response text is empty (or contains only warnings if present). Call `read` to get fresh anchors for follow-up edits.
 
 Error recovery:
 - `[E_STALE_ANCHOR]` — file changed since last read. Call `read` to get fresh anchors, then copy the HASH and retry.

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