pi-hashline-edit-pro 0.12.2 → 0.12.3

package/README.md

@@ -106,7 +106,7 @@ The post-edit diff (with `+`/`-` markers) is exposed to the host UI via `details
 - **Strict patch content.** If `content_lines` contains `+HASH│` display prefixes (or `-N   ` numbered deletion rows), the edit is rejected with `[E_INVALID_PATCH]`. This narrowly guards against pasting the tool's own diff-preview rows back as content; standard unified-diff lines (`+x`, `-x`, ` x`, `@@ … @@`) are **not** rejected — they are written literally, since literal content must never be silently altered. Bare `HASH│` content (the first 4 chars of a `content_lines` entry looking like 3 base64 chars + `│`) is rejected with `[E_BARE_HASH_PREFIX]`. When the suspect's prefix happens to match a real file-line anchor, the error message flags that as strong evidence the model copied an anchor from the read output.
 - **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.
+- **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 is a short header followed by a hashline-anchored window: the duplicated pair plus 2 lines of context before and after, shown as plain `HASH│content` rows with post-edit hashes. Seeing the duplication in context (rather than just being told a hash) is what prompts the model to act on it — and since the hashes are current and staleness is per-line, the model can remove the duplicate in one follow-up `replace` without re-reading. 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.12.2",
+  "version": "0.12.3",
   "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/read.md

@@ -7,6 +7,7 @@ HASH format:
 
 Pagination:
 - Large files return a truncated preview with a pagination hint (e.g. `[Showing lines 1-100 of 500. Use offset=101 to continue.]`). Call `read` again with `offset=N` to continue.
+- Default cap: {{DEFAULT_MAX_LINES}} lines or {{DEFAULT_MAX_BYTES}}; output exceeding either is truncated. Pass `limit` to read fewer lines.
 
 File kinds:
 - Text files are returned as `HASH│content` lines.

package/src/hashline/apply.ts

@@ -211,6 +211,56 @@ function assemble(
 	return result;
 }
 
+/**
+ * Builds the boundary-duplication warning shown after an edit. A minimal header
+ * is followed by a hashline-anchored window: 2 lines of context before the
+ * duplicated pair, the pair itself, and 2 lines after. The window carries the
+ * post-edit hashes the model needs to remove the duplicate in a follow-up
+ * `replace` (no `read` round-trip required, since the hashes are current and
+ * staleness is per-line). Rows are plain `HASH│content` — no annotations.
+ */
+function fmtBoundaryWarning(params: {
+	kind: "trailing" | "leading";
+	survivingContent: string;
+	matchIndex: number;
+	resultLines: string[];
+	resultHashes: string[];
+}): string {
+	const header =
+		params.kind === "trailing"
+			? "Boundary duplication (trailing): the last replacement line duplicated the next line. Delete the duplicate."
+			: "Boundary duplication (leading): the first replacement line duplicated the previous line. Delete the duplicate.";
+
+	// Locate the adjacent duplicated pair (two identical neighboring lines). The
+	// occurrence-based matchIndex usually lands inside the pair; when a file has
+	// several identical lines we pick the pair nearest matchIndex so the window
+	// frames the duplication this edit introduced, not an unrelated one.
+	let pairStart = -1;
+	let bestDist = Infinity;
+	for (let i = 0; i < params.resultLines.length - 1; i++) {
+		if (
+			params.resultLines[i] === params.survivingContent &&
+			params.resultLines[i + 1] === params.survivingContent
+		) {
+			const dist = Math.abs(i - params.matchIndex);
+			if (dist < bestDist) {
+				bestDist = dist;
+				pairStart = i;
+			}
+		}
+	}
+	if (pairStart < 0) pairStart = params.matchIndex;
+
+	const winStart = Math.max(0, pairStart - 2);
+	const winEnd = Math.min(params.resultLines.length - 1, pairStart + 3);
+
+	const rows: string[] = [];
+	for (let i = winStart; i <= winEnd; i++) {
+		rows.push(`${params.resultHashes[i]}${HASH_SEP}${params.resultLines[i]}`);
+	}
+	return `${header}\n\n${rows.join("\n")}`;
+}
+
 export function applyEdits(
 	content: string,
 	edits: import("./resolve").HEdit[],
@@ -284,16 +334,15 @@ export function applyEdits(
 			}
 		}
 		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}`
-				);
-			}
+			warnings.push(
+				fmtBoundaryWarning({
+					kind: bw.kind,
+					survivingContent: bw.survivingLineContent,
+					matchIndex,
+					resultLines,
+					resultHashes,
+				}),
+			);
 		}
 	}