pi-hashline-edit-pro 0.18.5 → 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.
@@ -112,7 +117,19 @@ Auto-read is **disabled by default**. When enabled, after a successful `write`,
 
 Toggle at runtime with the `/toggle-auto-read` command. The setting persists across sessions in the config file (`~/.config/pi-hashline-edit-pro/config.json`). Set `PI_HASHLINE_AUTO_READ=1` to enable by default on first run.
 
-For large files (>2000 lines), the auto-read output is truncated with a pagination hint. Use `read` with `offset` to see more.
+After a `replace` or `undo_last_replace`, the block is limited to the changed span plus 2 lines of context above and below it. Because the persistent hash store keeps anchors for unchanged lines stable across edits, the model's previously read anchors for the rest of the file remain valid — only the edited region needs fresh anchors. `write` dumps from the top of the file, since the model has no prior anchors for that state.
+
+For `write` on files over 2000 lines, the dump from the top is truncated with a pagination hint — use `read` with `offset` to see more. `replace` and `undo_last_replace` windows are small by construction (the changed span plus context), so they are not truncated except when the changed span itself exceeds 2000 lines.
+
+### Undo
+
+`undo_last_replace` reverts the most recent successful `replace` on a file, restoring the exact previous content (BOM and line endings included) and the previous hash anchors. It is meant for immediate recovery from a bad edit:
+
+- Undo history is per-file and single-level: each successful `replace` replaces the previous undo entry, so only the most recent edit can be reverted.
+- Undo history is in-memory and is lost when the session ends or the extension reloads.
+- A successful `write` clears the undo history for that file — the write becomes the new source of truth, and reverting past it would be ambiguous.
+- After an undo, the hash-store snapshot is restored to match the reverted content, so anchors read from the previous state are valid again.
+- Call `read` after an undo to get fresh anchors for follow-up edits.
 
 ### Diff for the host
 

package/index.ts

@@ -101,7 +101,25 @@ export default function (pi: ExtensionAPI): void {
       );
       if (visLines(normalized).length === 0) return;
 
-      const preview = await fmtReadPreview(normalized, { limit: AUTO_READ_MAX }, fileHashes, absolutePath);
+      const changedLines =
+        event.toolName === "replace" || event.toolName === "undo_last_replace"
+          ? (event.details as
+              | { metrics?: { changed_lines?: { first: number; last: number } } }
+              | undefined)?.metrics?.changed_lines
+          : undefined;
+      let offset: number | undefined;
+      let limit = AUTO_READ_MAX;
+      if (changedLines) {
+        offset = Math.max(1, changedLines.first - 2);
+        limit = Math.min(changedLines.last + 2 - offset + 1, AUTO_READ_MAX);
+      }
+
+      const preview = await fmtReadPreview(
+        normalized,
+        { offset, limit },
+        fileHashes,
+        absolutePath,
+      );
 
       return {
         content: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "0.18.5",
+  "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/hash-store.ts

@@ -36,6 +36,7 @@ function isValidSnapshot(value: unknown): value is LegacySnapshot {
 }
 
 let cachedDb: { path: string; db: DatabaseSync; stmts: Prepared } | null = null;
+let opening: { path: string; promise: Promise<HashStore> } | null = null;
 let exitHandlerRegistered = false;
 function openDb(storePath: string): { db: DatabaseSync; stmts: Prepared } {
   const db = new DatabaseSync(storePath, {
@@ -101,12 +102,7 @@ function shutdownDb(db: DatabaseSync): void {
   db.close();
 }
 
-export async function loadHashStore(): Promise<HashStore> {
-  const storePath = hashStorePath();
-  if (cachedDb && cachedDb.path === storePath && cachedDb.db.isOpen) {
-    return { stmts: cachedDb.stmts, engine: "node:sqlite" };
-  }
-
+async function openStore(storePath: string): Promise<HashStore> {
   shutdownHashStore();
 
   await initHasher();
@@ -149,6 +145,21 @@ export async function loadHashStore(): Promise<HashStore> {
   return { stmts, engine: "node:sqlite" };
 }
 
+export function loadHashStore(): Promise<HashStore> {
+  const storePath = hashStorePath();
+  if (cachedDb && cachedDb.path === storePath && cachedDb.db.isOpen) {
+    return Promise.resolve({ stmts: cachedDb.stmts, engine: "node:sqlite" });
+  }
+  if (opening && opening.path === storePath) {
+    return opening.promise;
+  }
+  const promise = openStore(storePath).finally(() => {
+    if (opening?.path === storePath) opening = null;
+  });
+  opening = { path: storePath, promise };
+  return promise;
+}
+
 export function shutdownHashStore(): void {
   if (cachedDb) {
     shutdownDb(cachedDb.db);
@@ -233,7 +244,15 @@ export function getSnapshot(
   const checksum = contentChecksum(content);
   const lineCount = splitLines(content).length;
   const row = store.stmts.get(path, checksum, lineCount);
-  return row ? (JSON.parse(row.hashes as string) as string[]) : undefined;
+  if (!row) return undefined;
+  try {
+    const parsed = JSON.parse(row.hashes as string);
+    return Array.isArray(parsed) && parsed.every((h) => typeof h === "string")
+      ? (parsed as string[])
+      : undefined;
+  } catch {
+    return undefined;
+  }
 }
 
 export function upsertSnapshot(
@@ -243,16 +262,11 @@ export function upsertSnapshot(
   lineCount: number,
   hashes: string[],
 ): void {
-  const hashesJson = JSON.stringify(hashes);
-  withStore(() => {
-    store.stmts.upsert(path, checksum, lineCount, hashesJson, Date.now());
-  });
+  store.stmts.upsert(path, checksum, lineCount, JSON.stringify(hashes), Date.now());
 }
 
 export function deleteSnapshot(store: HashStore, path: string): void {
-  withStore(() => {
-    store.stmts.deleteOne(path);
-  });
+  store.stmts.deleteOne(path);
 }
 
 export async function pruneMissing(store: HashStore): Promise<void> {

package/src/hashline/apply.ts

@@ -389,52 +389,33 @@ export function changedRange(
 		};
 	}
 
-	if (result.startsWith(original) && original.endsWith("\n")) {
-		return {
-			firstChangedLine: splitLines(original).length + 1,
-			lastChangedLine: splitLines(result).length,
-		};
-	}
+	const originalLines = splitLines(original);
+	const resultLines = splitLines(result);
 
-	let firstDiff = 0;
-	const minLen = Math.min(original.length, result.length);
-	while (firstDiff < minLen && original[firstDiff] === result[firstDiff]) {
-		firstDiff++;
+	if (
+		originalLines.length === resultLines.length &&
+		originalLines.every((line, index) => line === resultLines[index])
+	) {
+		return null;
 	}
-	if (firstDiff === minLen && original.length === result.length) return null;
 
-	let lastOrig = original.length - 1;
-	let lastRes = result.length - 1;
+	const minLen = Math.min(originalLines.length, resultLines.length);
+	let first = 0;
+	while (first < minLen && originalLines[first] === resultLines[first]) {
+		first++;
+	}
+	let lastOrig = originalLines.length - 1;
+	let lastRes = resultLines.length - 1;
 	while (
-		lastOrig >= firstDiff &&
-		lastRes >= firstDiff &&
-		original[lastOrig] === result[lastRes]
+		lastOrig >= first &&
+		lastRes >= first &&
+		originalLines[lastOrig] === resultLines[lastRes]
 	) {
 		lastOrig--;
 		lastRes--;
 	}
-
-	function idxToLine(charIdx: number, text: string): number {
-		let line = 1;
-		for (let i = 0; i < charIdx && i < text.length; i++) {
-			if (text[i] === "\n") line++;
-		}
-		return line;
-	}
-
-	const firstChangedLine = idxToLine(firstDiff + 1, result);
-	let lastChangedLine: number;
-	if (lastRes < firstDiff) {
-		lastChangedLine = result.length === 0 ? 1 : splitLines(result).length;
-	} else if (
-		firstDiff === 0 &&
-		original.length > 0 &&
-		result.endsWith(original)
-	) {
-		lastChangedLine = firstChangedLine;
-	} else {
-		lastChangedLine = idxToLine(lastRes + 1, result);
-	}
-
-	return { firstChangedLine, lastChangedLine };
+	return {
+		firstChangedLine: first + 1,
+		lastChangedLine: Math.max(first, lastRes) + 1,
+	};
 }

package/src/hashline/hash.ts

@@ -180,45 +180,27 @@ function hashToIndex(hash: string): number {
   return idx;
 }
 
-function findNearestCandidate(
-  candidates: { index: number; hash: string }[],
+function nearestNew(
+  candidates: number[],
   target: number,
-  removedHashes?: Set<string>,
 ): 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;
   }
-  let left = lo - 1;
-  let right = lo;
-  while (left >= 0 || right < candidates.length) {
-    let bestPos = -1;
-    let bestDist = Infinity;
-    if (left >= 0) {
-      const candidate = candidates[left]!;
-      if (!removedHashes?.has(candidate.hash)) {
-        bestPos = left;
-        bestDist = target - candidate.index;
-      }
-    }
-    if (right < candidates.length) {
-      const candidate = candidates[right]!;
-      if (!removedHashes?.has(candidate.hash)) {
-        const dist = candidate.index - target;
-        if (dist < bestDist) {
-          bestPos = right;
-          bestDist = dist;
-        }
-      }
-    }
-    if (bestPos >= 0) return bestPos;
-    left--;
-    right++;
+  const left = lo - 1;
+  const right = lo;
+  if (
+    left >= 0 &&
+    (right >= candidates.length ||
+      target - candidates[left]! <= candidates[right]! - target)
+  ) {
+    return left;
   }
-  return -1;
+  return right < candidates.length ? right : -1;
 }
 
 function mapStableHashes(
@@ -227,45 +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>();
+
+  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);
+  }
 
-  if (removedHashes) {
-    for (const hash of removedHashes) {
-      const idx = hashToIndex(hash);
-      if (idx >= 0) setBit(used, idx);
-    }
+  const removedIndexes = new Set<number>();
+  for (const hash of removed) {
+    const idx = oldHashIndex.get(hash);
+    if (idx !== undefined) removedIndexes.add(idx);
   }
 
-  const contentMap = new Map<string, { index: number; hash: string }[]>();
-  const oldLines = splitLines(oldContent);
+  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 entry = { index: i, hash: oldHashes[i]! };
-    const list = contentMap.get(line);
-    if (list) {
-      list.push(entry);
-    } else {
-      contentMap.set(line, [entry]);
-    }
+    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, removedHashes);
-    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++) {
@@ -274,6 +289,7 @@ function mapStableHashes(
     const baseIdx = xxh32(c) >>> 14;
     newHashes[i] = assignHash(used, baseIdx, hint);
   }
+
   return newHashes;
 }
 

package/src/replace-undo.ts

@@ -10,6 +10,7 @@ import { toLF, stripBOM, genDiff, restoreEndings } from "./replace-diff";
 import { cntDiff, splitLines } from "./utils";
 import { loadP, loadGuide } from "./prompts";
 import { buildMetrics } from "./replace-response";
+import { changedRange } from "./hashline";
 export interface UndoEntry {
   content: string;
   bom: string;
@@ -77,6 +78,7 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
         const diffResult = genDiff(undo.content, currentNormalized, 0);
         const linesAddedByReplace = cntDiff(diffResult.diff, "+");
         const linesRemovedByReplace = cntDiff(diffResult.diff, "-");
+        const restoredRange = changedRange(currentNormalized, undo.content);
 
         await writeAtomic(
           mutationTargetPath,
@@ -113,6 +115,8 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
               editsAttempted: 1,
               noopEditsCount: 0,
               warningsCount: 0,
+              firstChangedLine: restoredRange?.firstChangedLine,
+              lastChangedLine: restoredRange?.lastChangedLine,
               addedLines: linesRemovedByReplace,
               removedLines: linesAddedByReplace,
             }),