pi-hashline-edit-pro 2.1.2 → 2.2.1

package/README.md

@@ -86,12 +86,12 @@ One edit per call, with `hash_bounds` and `new_content` at the top level:
 | Field | Description |
 | --- | --- |
 | `hash_bounds` | Pair of 3-char hashes from `read` output marking the first and last line of the range to replace (inclusive). |
-| `new_content` | Replacement content as a single string with `\n` line separators; a trailing newline is the last line's ending, not an extra empty line. Use `""` to delete the range. |
+| `new_content` | Replacement content as a single string with `\n` line separators; every `\n` separates lines, so a trailing `\n` adds a final empty line — mirror the replaced range's lines exactly, blank lines included (a replacement that is only blank lines is written as one `\n` per blank line). Use `""` to delete the range. |
 
 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. 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.
+- 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.
 

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "2.1.2",
+  "version": "2.2.1",
   "type": "module",
-  "description": "Strict hashline read/replace tool for pi-coding-agent with hash-anchored edits (3-char, 62-symbol, perfect hashing)",
+  "description": "Hash-anchored read/replace/undo tools for pi-coding-agent. Every line gets a unique 3-char hash (A-Za-z0-9) that stays stable across edits; stale or ambiguous anchors are rejected, never fuzzy-matched. Undo persists across restarts.",
   "main": "index.ts",
   "repository": {
     "type": "git",
@@ -16,7 +16,14 @@
     "extension",
     "hashline",
     "hash-anchored",
-    "strict"
+    "hash",
+    "anchors",
+    "read",
+    "replace",
+    "edit",
+    "undo",
+    "file-editing",
+    "stable"
   ],
   "license": "MIT",
   "files": [

package/prompts/replace-guidelines.md

@@ -2,5 +2,5 @@
 - `replace`: minimize the replaced range — anchor only the lines that actually change, so few unchanged lines must be reproduced byte-exact.
 - `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`: every `\n` in new_content separates lines, so a trailing `\n` adds a final empty line. Mirror the replaced range's lines exactly: a range that ends on a blank line must end new_content with `\n` (e.g. `"code\n"`), and a replacement whose last line is not blank must not end with `\n`. To add a blank line after a line, end new_content with an explicit empty line after it (e.g. `"X\n"` adds a blank after X). A replacement that is only blank lines is written as one `\n` per blank line (e.g. `"\n"` is a single blank line).
 - `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/src/hashline/apply.ts

@@ -11,6 +11,7 @@ import {
 	type NEdit,
 	type HEdit,
 	type AutoFix,
+	type BDup,
 } from "./resolve";
 
 type LIdx = {
@@ -186,7 +187,14 @@ export function applyEdit(
 			...prefixFixed,
 			content_lines: [...prefixFixed.content_lines],
 		};
-		const dupsByIndex = [...boundaryDups].sort(
+		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) {

package/src/hashline/parse.ts

@@ -45,7 +45,6 @@ export function parseText(edit: string): string[] {
   }
   const normalized = edit.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
   if (normalized === "") return [];
-  const lines = normalized.split("\n");
-  if (normalized.endsWith("\n")) lines.pop();
-  return lines;
+  if (/^\n+$/.test(normalized)) return new Array(normalized.length).fill("");
+  return normalized.split("\n");
 }

package/src/hashline/resolve.ts

@@ -1,4 +1,4 @@
-import { abortIf, rejectUnknownFields, lastNonEmpty, firstNonEmpty, firstNonEmptyIndex, lastNonEmptyIndex, clipLine } from "../utils";
+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";
@@ -283,38 +283,78 @@ 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 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 checkBoundaryDup(
-	adjacentLine: string | undefined,
-	replacementEdge: { index: number; line: string } | undefined,
-	kind: BDup["kind"],
-	canonical = false,
-	uniqueInFile?: Map<string, number>,
-): BDup | null {
-	if (
-		adjacentLine === undefined ||
-		replacementEdge === undefined ||
-		replacementEdge.line.length === 0
-	) {
-		return null;
+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 });
 	}
-	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 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 {
-		kind,
-		replacementLineIndex: replacementEdge.index,
-	};
+	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> {
@@ -348,16 +388,6 @@ export function findNewEdge(
 	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(
 	edit: HEdit,
 	fileLines: string[],
@@ -405,21 +435,14 @@ export function valEdit(
 		);
 	}
 	const endLine = endResolved.line;
-	const nextLine = fileLines[endLine];
-	const replacementLastLine = lastNonEmpty(edit.content_lines);
-	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, 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);
+	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: {

package/src/replace.ts

@@ -47,7 +47,7 @@ import { loadHashStore, type HashStore } from "./hash-store";
 
 const newContentSchema = Type.String({
   description:
-    "Replacement content as a single string with \\n line separators; a trailing newline is the last line's ending, not an extra empty line. Use \"\" to delete the range."
+    "Replacement content as a single string with \\n line separators; every \\n separates lines, so a trailing \\n adds a final empty line. Mirror the replaced range's lines exactly, blank lines included. A replacement that is only blank lines is written as one \\n per blank line. Use \"\" to delete the range."
 });
 
 const hashBoundsSchema = Type.Array(