pi-hashline-edit-pro 0.19.0 → 0.19.2

package/README.md

@@ -96,6 +96,11 @@ Replaces using the `HASH│content` anchors from `read` output to target lines p
 
 Hashes are now computed with a persistent store (`~/.config/pi-hashline-edit-pro/hash-store.sqlite`) that preserves hashes for unchanged lines across edits. When you replace lines in a file, the runtime maps the old content against the new content and copies hashes for unchanged lines to their new positions. This means editing one part of a file does not change the hashes of unrelated lines elsewhere — the model can keep using previously seen anchors for untouched regions. A replace that produces identical content (a no-op, reported as "No changes made") never rotates hashes: no file change means no anchor change, so previously read anchors remain valid after a no-op.
 
+Two guarantees make the mapping safe for duplicated content:
+
+- **An edited range never borrows a hash from a line outside it.** Lines outside the replaced range keep their hashes unconditionally, even when their content is byte-identical to lines inside the range. Previously, identical text in a replacement could "steal" the nearest sibling line's hash, silently relocating an anchor the model was still holding.
+- **Re-inserted identical text keeps its hash.** When replacement content matches a line that was just removed, the removed line's hash is reused for it (same canonical content, same meaning). Previously this was a coin flip: the hash was retired and a fresh one assigned, so "replace X with X" rotated the anchor even though nothing changed.
+
 The store is a SQLite database (WAL journal mode) keyed by canonical file path. Each snapshot stores a 64-bit content checksum (`xxhash64`) plus the per-line hashes, not the full text, so a cache hit is a single keyed lookup and a one-row write. Reads, replaces, undo, and pruning all share one transactional store, so concurrent Pi sessions editing different files never silently clobber each other's snapshots (per-path writers serialize via `BEGIN IMMEDIATE`; same-path concurrent edits still fail safe — stale anchors are rejected by content matching). Stale snapshots (for files that no longer exist) are pruned on session start.
 
 On first run after upgrading, a one-time migration imports the previous `hash-store.json` into the database and renames the old file to `hash-store.json.bak`; the old JSON store is otherwise discarded.

package/index.ts

@@ -3,7 +3,7 @@ import { initHasher } from "./src/hashline";
 import { regReplace, regReplaceFlat } from "./src/replace";
 import { regReplaceUndo, clearUndo } from "./src/replace-undo";
 import { regRead, fmtReadPreview } from "./src/read";
-import { visLines } from "./src/utils";
+import type { RMetrics } from "./src/replace-response";
 import { AUTO_READ_MAX } from "./src/constants";
 import { MAX_HASH_LINES } from "./src/hashline";
 import {
@@ -95,17 +95,17 @@ export default function (pi: ExtensionAPI): void {
     const filePath = (event.input as Record<string, unknown>)?.path;
     if (typeof filePath !== "string") return;
 
+    const metrics = (event.details as { metrics?: RMetrics } | undefined)?.metrics;
+    if (event.toolName !== "write" && metrics?.classification === "noop") return;
+
     try {
       const { normalized, fileHashes, absolutePath } = await readNormFile(
         filePath, ctx.cwd, { maxLines: MAX_HASH_LINES },
       );
-      if (visLines(normalized).length === 0) return;
 
       const changedLines =
         event.toolName === "replace" || event.toolName === "undo_last_replace"
-          ? (event.details as
-              | { metrics?: { changed_lines?: { first: number; last: number } } }
-              | undefined)?.metrics?.changed_lines
+          ? metrics?.changed_lines
           : undefined;
       let offset: number | undefined;
       let limit = AUTO_READ_MAX;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "0.19.0",
+  "version": "0.19.2",
   "type": "module",
   "description": "Strict hashline read/replace tool for pi-coding-agent with hash-anchored edits (3-char, 18-bit, perfect hashing)",
   "main": "index.ts",
@@ -46,6 +46,7 @@
   "scripts": {
     "test": "vitest run",
     "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
     "lint": "eslint 'src/**/*.ts' 'index.ts' 'test/**/*.ts'",
     "typecheck": "tsc --noEmit"
   },
@@ -53,6 +54,7 @@
     "@earendil-works/pi-coding-agent": "^0.74.0",
     "@eslint/js": "^10.0.1",
     "@types/node": "^24.0.0",
+    "@vitest/coverage-v8": "^4.1.10",
     "eslint": "^10.7.0",
     "typescript": "^5.8.0",
     "typescript-eslint": "^8.65.0",

package/prompts/replace-guidelines.md

@@ -1,2 +1,3 @@
 - `replace`: content_lines is a native JSON array of strings — never a serialized JSON string; strip the HASH│ prefix from read output and keep leading whitespace exactly as shown after │; no line numbers or diff markers.
-- `replace`: hash_range_inclusive must use only anchors from the most recent read of the same file; on [E_STALE_ANCHOR], re-read the file and retry with fresh anchors.
+- `replace`: hash_range_inclusive must use only anchors from the most recent read of the same file; on [E_STALE_ANCHOR], re-read the file and retry with fresh anchors.
+- `replace`: minimize the replaced range — anchor only the lines that actually change; for insertions use a single-line range (e.g. the line after the insertion point) instead of a whole block, so fewer unchanged lines must be reproduced byte-exact.

package/src/hash-store.ts

@@ -53,7 +53,20 @@ function openDb(storePath: string): { db: DatabaseSync; stmts: Prepared } {
       "updated_at INTEGER NOT NULL" +
     ")"
   );
-
+  db.exec(
+    "CREATE TABLE IF NOT EXISTS meta (" +
+      "key TEXT PRIMARY KEY, " +
+      "value TEXT NOT NULL" +
+    ")"
+  );
+  const versionRow = db.prepare("SELECT value FROM meta WHERE key = 'version'").get() as { value?: string } | undefined;
+  if (versionRow && versionRow.value !== String(HASH_STORE_VERSION)) {
+    db.exec("DELETE FROM snapshots");
+  }
+  db.prepare(
+    "INSERT INTO meta (key, value) VALUES ('version', ?) " +
+    "ON CONFLICT(key) DO UPDATE SET value = excluded.value"
+  ).run(String(HASH_STORE_VERSION));
   const getStmt = db.prepare("SELECT hashes FROM snapshots WHERE path = ? AND checksum = ? AND line_count = ?");
   const allStmt = db.prepare("SELECT path FROM snapshots");
   const delStmt = db.prepare("DELETE FROM snapshots WHERE path = ?");
@@ -284,5 +297,3 @@ export async function pruneMissing(store: HashStore): Promise<void> {
     for (const path of missing) store.stmts.deleteOne(path);
   });
 }
-
-export { HASH_STORE_VERSION };

package/src/hashline/apply.ts

@@ -219,44 +219,6 @@ function assemble(
 	return result;
 }
 
-export 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. This happens when `content_lines` includes a line that was already outside the replaced range. Delete the duplicate — the original line outside the range is still there."
-			: "Boundary duplication (leading): the first replacement line duplicated the previous line. This happens when `content_lines` includes a line that was already outside the replaced range. Delete the duplicate — the original line outside the range is still there.";
-
-	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: HEdit[],

package/src/hashline/hash.ts

@@ -37,9 +37,6 @@ const HASH_TABLE: string[] = Array.from(
   (_, i) => idxToHash(i),
 );
 
-export const HL_PREFIX_RE = new RegExp(
-	`^\\s*(?:>>>|>>)?\\s*${HASH_CLASS}│`,
-);
 export const HL_PREFIX_PLUS_RE = new RegExp(
 	`^\\+\\s*${HASH_CLASS}│`,
 );
@@ -180,15 +177,15 @@ function hashToIndex(hash: string): number {
   return idx;
 }
 
-function findNearestCandidate(
-  candidates: { index: number; hash: string }[],
+function nearestNew(
+  candidates: number[],
   target: number,
 ): number {
   let lo = 0;
   let hi = candidates.length;
   while (lo < hi) {
     const mid = (lo + hi) >>> 1;
-    if (candidates[mid]!.index < target) lo = mid + 1;
+    if (candidates[mid]! < target) lo = mid + 1;
     else hi = mid;
   }
   const left = lo - 1;
@@ -196,8 +193,7 @@ function findNearestCandidate(
   if (
     left >= 0 &&
     (right >= candidates.length ||
-      target - candidates[left]!.index <=
-        candidates[right]!.index - target)
+      target - candidates[left]! <= candidates[right]! - target)
   ) {
     return left;
   }
@@ -210,46 +206,78 @@ function mapStableHashes(
   newContent: string,
   removedHashes?: Set<string>,
 ): string[] {
+  const oldLines = splitLines(oldContent);
   const newLines = splitLines(newContent);
   const newHashes = new Array<string>(newLines.length);
   const used = new Uint32Array(BITSET_WORDS);
   const hint = { value: 0 };
+  const removed = removedHashes ?? new Set<string>();
 
-  if (removedHashes) {
-    for (const hash of removedHashes) {
-      const idx = hashToIndex(hash);
-      if (idx >= 0) setBit(used, idx);
-    }
+  const oldHashIndex = new Map<string, number>();
+  for (let i = 0; i < oldHashes.length; i++) {
+    const hash = oldHashes[i]!;
+    oldHashIndex.set(hash, i);
+    const idx = hashToIndex(hash);
+    if (idx >= 0) setBit(used, idx);
   }
 
-  const contentMap = new Map<string, { index: number; hash: string }[]>();
-  const oldLines = splitLines(oldContent);
+  const removedIndexes = new Set<number>();
+  for (const hash of removed) {
+    const idx = oldHashIndex.get(hash);
+    if (idx !== undefined) removedIndexes.add(idx);
+  }
+
+  const survivors: { index: number; hash: string }[] = [];
+  const removedEntries: { index: number; hash: string }[] = [];
   for (let i = 0; i < oldLines.length; i++) {
-    const line = oldLines[i]!;
-    const hash = oldHashes[i]!;
-    if (removedHashes?.has(hash)) continue;
-    const entry = { index: i, hash };
-    const list = contentMap.get(line);
-    if (list) {
-      list.push(entry);
-    } else {
-      contentMap.set(line, [entry]);
-    }
+    const entry = { index: i, hash: oldHashes[i]! };
+    if (removedIndexes.has(i)) removedEntries.push(entry);
+    else survivors.push(entry);
   }
+
+  const newByContent = new Map<string, number[]>();
   for (let i = 0; i < newLines.length; i++) {
-    const line = newLines[i]!;
-    const candidates = contentMap.get(line);
+    const key = canon(newLines[i]!);
+    const list = newByContent.get(key);
+    if (list) list.push(i);
+    else newByContent.set(key, [i]);
+  }
+
+  const markUsed = (hash: string): void => {
+    const idx = hashToIndex(hash);
+    if (idx >= 0) {
+      setBit(used, idx);
+      if (idx + 1 > hint.value) hint.value = idx + 1;
+    }
+  };
+
+  for (const entry of survivors) {
+    const candidates = newByContent.get(canon(oldLines[entry.index]!));
     if (!candidates || candidates.length === 0) continue;
+    const pos = nearestNew(candidates, entry.index);
+    if (pos < 0) continue;
+    const newIdx = candidates.splice(pos, 1)[0]!;
+    newHashes[newIdx] = entry.hash;
+    markUsed(entry.hash);
+  }
 
-    const bestIdx = findNearestCandidate(candidates, i);
-    if (bestIdx < 0) continue;
-    const match = candidates.splice(bestIdx, 1)[0]!;
-    newHashes[i] = match.hash;
-    const matchIdx = hashToIndex(match.hash);
-    if (matchIdx >= 0) {
-      setBit(used, matchIdx);
-      if (matchIdx + 1 > hint.value) hint.value = matchIdx + 1;
+  const removedByContent = new Map<string, { hashes: string[]; pos: number }>();
+  for (const entry of removedEntries) {
+    const key = canon(oldLines[entry.index]!);
+    let queue = removedByContent.get(key);
+    if (!queue) {
+      queue = { hashes: [], pos: 0 };
+      removedByContent.set(key, queue);
     }
+    queue.hashes.push(entry.hash);
+  }
+
+  for (let i = 0; i < newLines.length; i++) {
+    if (newHashes[i]) continue;
+    const queue = removedByContent.get(canon(newLines[i]!));
+    if (!queue || queue.pos >= queue.hashes.length) continue;
+    newHashes[i] = queue.hashes[queue.pos]!;
+    queue.pos += 1;
   }
 
   for (let i = 0; i < newLines.length; i++) {
@@ -258,6 +286,7 @@ function mapStableHashes(
     const baseIdx = xxh32(c) >>> 14;
     newHashes[i] = assignHash(used, baseIdx, hint);
   }
+
   return newHashes;
 }
 

package/src/hashline/index.ts

@@ -5,7 +5,6 @@ export {
 	HASH_CLASS,
 	HASH_SPACE,
 	MAX_HASH_LINES,
-	HL_PREFIX_RE,
 	HL_PREFIX_PLUS_RE,
 	HL_PREFIX_MINUS_RE,
 	DIFF_MINUS_RE,
@@ -40,5 +39,4 @@ export {
 	applyEdits,
 	fmtRegion,
 	changedRange,
-	fmtBoundaryWarning,
 } from "./apply";

package/src/hashline/parse.ts

@@ -6,6 +6,7 @@ import {
 	DIFF_MINUS_RE,
 } from "./hash";
 import { CONTENT_LINES_NOT_STRING_MSG } from "../constants";
+import { clipLine } from "../utils";
 
 export type Anchor = { hash: string };
 
@@ -51,7 +52,7 @@ function assertNoPrefixes(lines: string[]): void {
 			DIFF_MINUS_RE.test(line)
 		) {
 			throw new Error(
-			`[E_INVALID_PATCH] "content_lines" must contain literal file content. Offending line looks like a diff preview row (e.g. +HASH│ or -HASH│): ${JSON.stringify(line)}. Use literal file content only — plain + or - lines are written literally.`
+			`[E_INVALID_PATCH] "content_lines" must contain literal file content. Offending line looks like a diff preview row (e.g. +HASH│ or -HASH│): ${JSON.stringify(clipLine(line))}. Use literal file content only — plain + or - lines are written literally.`
 			);
 		}
 	}

package/src/hashline/resolve.ts

@@ -1,4 +1,4 @@
-import { abortIf, rejectUnknownFields, lastNonEmpty, firstNonEmpty } from "../utils";
+import { abortIf, rejectUnknownFields, lastNonEmpty, firstNonEmpty, clipLine } from "../utils";
 import { HL_BARE_PREFIX_RE } from "./hash";
 import { parseHashRef, parseText, type Anchor } from "./parse";
 import { CONTENT_LINES_NOT_STRING_MSG } from "../constants";
@@ -109,7 +109,7 @@ export function fmtMismatch(
           : "";
       const lines = sample
         .map((line) => {
-          const content = fileLines[line - 1] ?? "";
+          const content = clipLine(fileLines[line - 1] ?? "");
           return `    ${line}: ${fileHashes[line - 1]}│${content}`;
         })
         .join("\n");
@@ -223,7 +223,7 @@ export function assertNoBarePrefix(
   const matched = suspects.filter((s) => fileHashSet.has(s.hash));
   const matchedCount = matched.length;
 
-  const exampleLine = `${suspects[0]!.hash}│${suspects[0]!.line}`;
+  const exampleLine = `${suspects[0]!.hash}│${clipLine(suspects[0]!.line)}`;
 
   const linesHint =
     matchedCount === 0

package/src/replace-response.ts

@@ -1,6 +1,6 @@
 import type { ReplaceDetails } from "./replace";
 import { genDiff } from "./replace-diff";
-import { visLines } from "./utils";
+import { visLines, clipLine } from "./utils";
 
 type TResult = {
 	content: Array<{ type: "text"; text: string }>;
@@ -102,7 +102,7 @@ export function buildNoop(input: NoopInput): TResult {
 		? noopEdits
 				.map(
 					(edit) =>
-						`Edit ${edit.editIndex}: replacement for ${edit.loc} is identical to current content:\n  ${edit.loc}: ${edit.currentContent}`,
+						`Edit ${edit.editIndex}: replacement for ${edit.loc} is identical to current content:\n  ${edit.loc}: ${clipLine(edit.currentContent)}`,
 				)
 				.join("\n")
 		: "The edits produced identical content.";

package/src/utils.ts

@@ -82,3 +82,8 @@ export function firstNonEmpty(lines: string[]): string | undefined {
 	const idx = firstNonEmptyIndex(lines);
 	return idx >= 0 ? lines[idx] : undefined;
 }
+
+export function clipLine(line: string, maxLen = 200): string {
+	const flat = line.replace(/\n/g, "\\n");
+	return flat.length > maxLen ? `${flat.slice(0, maxLen)}...` : flat;
+}