pi-hashline-edit-pro 0.18.4 → 0.19.0

package/README.md

@@ -103,16 +103,28 @@ On first run after upgrading, a one-time migration imports the previous `hash-st
 ### Chained edits
 
 After a successful replace, the response confirms with `Successfully replaced in {path}. Added X line(s), removed Y line(s).` (warnings are still shown if present). When auto-read is enabled, fresh anchors are appended automatically. Otherwise call `read` to get fresh anchors for follow-up edits.
-### Auto-read after write and replace
+### Auto-read after write, replace, and undo
 
-Auto-read is **disabled by default**. When enabled, after a successful `write` or `replace` the extension automatically reads the file and appends a `--- Auto-read (hashline anchors) ---` block to the result. This gives the model immediate `HASH│content` anchors for the file without requiring a separate `read` call. The workflow becomes:
+Auto-read is **disabled by default**. When enabled, after a successful `write`, `replace`, or `undo_last_replace` the extension automatically reads the file and appends a `--- Auto-read (hashline anchors) ---` block to the result. This gives the model immediate `HASH│content` anchors for the file without requiring a separate `read` call. The workflow becomes:
 
 1. `write` a file, result includes hashline anchors
 2. `replace` using those anchors directly
 
 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

@@ -87,8 +87,11 @@ export default function (pi: ExtensionAPI): void {
       }
     }
     if (!autoRead) return;
-    if (event.toolName !== "write" && event.toolName !== "replace") return;
-
+    if (
+      event.toolName !== "write" &&
+      event.toolName !== "replace" &&
+      event.toolName !== "undo_last_replace"
+    ) return;
     const filePath = (event.input as Record<string, unknown>)?.path;
     if (typeof filePath !== "string") return;
 
@@ -98,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.4",
+  "version": "0.19.0",
   "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,7 +46,7 @@
   "scripts": {
     "test": "vitest run",
     "test:watch": "vitest",
-    "lint": "eslint 'src/**/*.ts' 'index.ts'",
+    "lint": "eslint 'src/**/*.ts' 'index.ts' 'test/**/*.ts'",
     "typecheck": "tsc --noEmit"
   },
   "devDependencies": {

package/src/config.ts

@@ -21,6 +21,14 @@ function parseConfig(content: string): Config {
     autoRead: parsed.autoRead === true,
   };
 }
+
+function envDefaultConfig(): Partial<Config> {
+  const autoReadValue = process.env.PI_HASHLINE_AUTO_READ;
+  return autoReadValue === "1" || autoReadValue === "true"
+    ? { autoRead: true }
+    : {};
+}
+
 export async function readConfig(): Promise<Config> {
   try {
     const content = await readFile(configPath(), "utf-8");
@@ -29,7 +37,7 @@ export async function readConfig(): Promise<Config> {
     if (errCode(error) !== "ENOENT") {
       console.error("Config file corrupted, using defaults:", error);
     }
-    return { ...DEFAULT_CONFIG };
+    return { ...DEFAULT_CONFIG, ...envDefaultConfig() };
   }
 }
 export async function writeConfig(config: Config): Promise<void> {

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

@@ -183,7 +183,6 @@ function hashToIndex(hash: string): number {
 function findNearestCandidate(
   candidates: { index: number; hash: string }[],
   target: number,
-  removedHashes?: Set<string>,
 ): number {
   let lo = 0;
   let hi = candidates.length;
@@ -192,33 +191,17 @@ function findNearestCandidate(
     if (candidates[mid]!.index < 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]!.index <=
+        candidates[right]!.index - target)
+  ) {
+    return left;
   }
-  return -1;
+  return right < candidates.length ? right : -1;
 }
 
 function mapStableHashes(
@@ -243,7 +226,9 @@ function mapStableHashes(
   const oldLines = splitLines(oldContent);
   for (let i = 0; i < oldLines.length; i++) {
     const line = oldLines[i]!;
-    const entry = { index: i, hash: oldHashes[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);
@@ -251,13 +236,12 @@ function mapStableHashes(
       contentMap.set(line, [entry]);
     }
   }
-
   for (let i = 0; i < newLines.length; i++) {
     const line = newLines[i]!;
     const candidates = contentMap.get(line);
     if (!candidates || candidates.length === 0) continue;
 
-    const bestIdx = findNearestCandidate(candidates, i, removedHashes);
+    const bestIdx = findNearestCandidate(candidates, i);
     if (bestIdx < 0) continue;
     const match = candidates.splice(bestIdx, 1)[0]!;
     newHashes[i] = match.hash;

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,
             }),