pi-hashline-edit-pro 0.19.0 → 0.19.1

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "0.19.0",
+  "version": "0.19.1",
   "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",

package/src/hashline/hash.ts

@@ -180,15 +180,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 +196,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 +209,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 +289,7 @@ function mapStableHashes(
     const baseIdx = xxh32(c) >>> 14;
     newHashes[i] = assignHash(used, baseIdx, hint);
   }
+
   return newHashes;
 }