pi-hashline-edit-pro 1.0.6 → 1.0.7

package/README.md

@@ -132,6 +132,7 @@ Enabled by default. After a successful `write`, `replace`, or `undo_last_replace
 
 - History is per-file and single-level: only the most recent replace can be reverted.
 - History is persisted in the hash store (`~/.config/pi-hashline-edit-pro/hash-store.sqlite`) and survives session restarts; a failed `write` does not clear it.
+- **Undo is a precondition, not a convenience.** The undo record is persisted *before* the edit is written; if it cannot be persisted, the `replace` is refused with `[E_UNDO_UNAVAILABLE]` and the file is not touched, so every applied edit is undoable. If the file write itself then fails, the previous undo record is restored, so a refused edit never destroys earlier undo history.
 - A successful `write` clears the history for that file.
 - Call `read` after an undo to get fresh anchors for follow-up edits.
 - **Safety guard.** If the file was modified or deleted since the last replace, `undo_last_replace` refuses with `[E_UNDO_STALE]` rather than overwriting those changes.
@@ -167,6 +168,7 @@ Settings live in `~/.config/pi-hashline-edit-pro/config.json`, created automatic
 | `[E_ACCESS]` | The file is not readable or writable. |
 | `[E_NOT_TEXT]` | The path is a directory, binary file, image, or UTF-16/UTF-32 encoded text; hashline editing only supports text files. |
 | `[E_UNDO_STALE]` | `undo_last_replace` refused: the file was modified or deleted after the last replace. |
+| `[E_UNDO_UNAVAILABLE]` | Undo history could not be persisted to the hash store; the `replace` was refused and the file was left unchanged. |
 | `[E_FILE_TOO_LARGE]` | The file exceeds the 238,328-line hashline limit. |
 
 ## Hashing
@@ -185,6 +187,14 @@ The alphabet is sized for an LLM consumer: the model tokenizes rather than squin
 - **Atomic and ordered writes.** Files are written via temp-file-then-rename; symlink chains are resolved so the target is updated without replacing the symlink; hard-linked files are updated in place; concurrent edits to the same underlying file serialize through a per-target mutation queue.
 - **One edit per call.** The request shape stays `{path, hash_range_inclusive, content_lines}` from schema through validation to application; there is no batching dialect.
 
+## Troubleshooting
+
+- **Stale anchors.** `[E_STALE_ANCHOR]` / `[E_AMBIGUOUS_ANCHOR]` mean the file changed since the anchors were read, or an earlier `read` never happened. Call `read` for fresh anchors and retry.
+- **Reset the hash store.** Anchors live in `~/.config/pi-hashline-edit-pro/hash-store.sqlite` (with `-wal`/`-shm` sidecars). Quit pi, delete those three files, and the store is rebuilt on the next session. Anchor history is lost, but no project files are touched.
+- **Corrupt store.** If the store fails its health check it is renamed to `hash-store.sqlite.corrupt-<timestamp>` (plus `-wal`/`-shm` variants) and rebuilt automatically; the quarantined files can be deleted once a healthy store exists.
+- **Legacy migration.** On first run after upgrading from an older version, the previous `hash-store.json` is imported once and renamed to `hash-store.json.bak`, which can be deleted.
+- **`[E_UNDO_UNAVAILABLE]`.** The edit was refused because the undo record could not be written — check disk space and that the config directory is writable, then retry.
+
 ## Development
 
 Requires [Node.js](https://nodejs.org) ≥ 22.13 and npm.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "type": "module",
   "description": "Strict hashline read/replace tool for pi-coding-agent with hash-anchored edits (3-char, 62-symbol, perfect hashing)",
   "main": "index.ts",

package/src/hashline/hash.ts

@@ -234,6 +234,16 @@ function mapStableHashes(
     if (idx !== undefined) removedIndexes.add(idx);
   }
 
+  let spanStart = oldLines.length;
+  let spanEnd = -1;
+  for (const idx of removedIndexes) {
+    if (idx < spanStart) spanStart = idx;
+    if (idx > spanEnd) spanEnd = idx;
+  }
+  const spanLen = spanEnd >= spanStart ? spanEnd - spanStart + 1 : 0;
+  const replacementLen = newLines.length - oldLines.length + spanLen;
+  const shiftAfterSpan = spanEnd >= spanStart ? replacementLen - spanLen : 0;
+
   const survivors: { index: number; hash: string }[] = [];
   const removedEntries: { index: number; hash: string }[] = [];
   for (let i = 0; i < oldLines.length; i++) {
@@ -261,7 +271,8 @@ function mapStableHashes(
   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);
+    const target = entry.index > spanEnd ? entry.index + shiftAfterSpan : entry.index;
+    const pos = nearestNew(candidates, target);
     if (pos < 0) continue;
     const newIdx = candidates.splice(pos, 1)[0]!;
     newHashes[newIdx] = entry.hash;

package/src/hashline/resolve.ts

@@ -225,7 +225,7 @@ export function stripBarePrefixes(
 			? "none of the stripped hashes match current file lines"
 			: `${matchedCount} of ${stripped.length} stripped hash(es) match current file lines`;
 	warnings.push(
-		`Autocorrected: stripped "HASH│" prefix copied from read output in ${locations} (${evidence}).`
+		`[E_BARE_HASH_PREFIX] Autocorrected: stripped "HASH│" prefix copied from read output in ${locations} (${evidence}).`
 	);
 	return { ...edit, content_lines: contentLines };
 }
@@ -251,7 +251,7 @@ export function stripDiffPrefixes(
 	if (stripped.length === 0) return edit;
 	const locations = stripped.map((i) => `content_lines[${i}]`).join(", ");
 	warnings.push(
-		`Autocorrected: stripped diff-preview marker copied from the diff preview in ${locations}.`
+		`[E_INVALID_PATCH] Autocorrected: stripped diff-preview marker copied from the diff preview in ${locations}.`
 	);
 	return { ...edit, content_lines: contentLines };
 }
@@ -276,7 +276,7 @@ export function swapReversedRanges(
 		return edit;
 	}
 	warnings.push(
-		`Autocorrected: hash_range_inclusive was reversed (start ${startRef.hash} is after end ${endRef.hash}); swapped the pair.`
+		`[E_BAD_OP] Autocorrected: hash_range_inclusive was reversed (start ${startRef.hash} is after end ${endRef.hash}); swapped the pair.`
 	);
 	return { ...edit, hash_range_inclusive: [endRef, startRef] as [Anchor, Anchor] };
 }

package/src/replace-render.ts

@@ -16,6 +16,7 @@ export type RRState = {
 	argsKey?: string;
 	preview?: RPreview;
 	previewGeneration?: number;
+	previewTimer?: ReturnType<typeof setTimeout>;
 };
 
 export function getPreviewInput(

package/src/replace-undo.ts

@@ -2,7 +2,7 @@ import { readFile } from "fs/promises";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { loadHashStore, upsertSnapshot, upsertUndo, getUndoEntry, deleteUndo } from "./hash-store";
+import { loadHashStore, upsertSnapshot, upsertUndo, getUndoEntry, deleteUndo, type UndoRecord } from "./hash-store";
 import { contentChecksum } from "./hashline/hasher";
 import { resolveTarget, writeAtomic } from "./fs-write";
 import { toCwd } from "./paths";
@@ -19,9 +19,14 @@ export interface UndoEntry {
   resultContent: string;
 }
 
-export async function saveUndo(path: string, entry: UndoEntry): Promise<boolean> {
+export async function saveUndo(
+  path: string,
+  entry: UndoEntry,
+): Promise<{ persisted: boolean; restore: () => Promise<void> }> {
+  let previous: UndoRecord | undefined;
   try {
     const store = await loadHashStore();
+    previous = getUndoEntry(store, path);
     upsertUndo(store, path, {
       content: entry.content,
       bom: entry.bom,
@@ -29,11 +34,22 @@ export async function saveUndo(path: string, entry: UndoEntry): Promise<boolean>
       hashes: entry.hashes,
       resultContent: entry.resultContent,
     });
-    return true;
   } catch (error) {
     console.error("Failed to persist undo entry:", error);
-    return false;
+    return { persisted: false, restore: async () => undefined };
   }
+  return {
+    persisted: true,
+    restore: async () => {
+      try {
+        const store = await loadHashStore();
+        if (previous) upsertUndo(store, path, previous);
+        else deleteUndo(store, path);
+      } catch (error) {
+        console.error("Failed to restore previous undo entry:", error);
+      }
+    },
+  };
 }
 
 export async function getUndo(path: string): Promise<UndoEntry | undefined> {
@@ -109,6 +125,7 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
         }
 
         if (currentRaw === undefined) {
+          await clearUndo(mutationTargetPath);
           return {
             content: [
               {
@@ -121,6 +138,7 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
           };
         }
         if (currentRaw !== undo.bom + restoreEndings(undo.resultContent, undo.originalEnding)) {
+          await clearUndo(mutationTargetPath);
           return {
             content: [
               {

package/src/replace.ts

@@ -99,6 +99,8 @@ interface PipelineResult {
   totalRemovedLines: number;
 }
 
+const PREVIEW_DEBOUNCE_MS = 150;
+
 const ROOT_KS = new Set(["path", "content_lines", "hash_range_inclusive"]);
 
 const LEGACY_KS = ["oldText", "newText", "old_text", "new_text", "old_range", "start", "end", "lines", "changes"];
@@ -318,12 +320,20 @@ export function buildToolDef(): ToolDef {
     renderShell: "default",
     renderCall(args, theme, context) {
       const previewInput = getPreviewInput(args);
+      const cancelPendingPreview = () => {
+        if (context.state.previewTimer) {
+          clearTimeout(context.state.previewTimer);
+          context.state.previewTimer = undefined;
+        }
+      };
       if (context.executionStarted) {
+        cancelPendingPreview();
         context.state.argsKey = undefined;
         context.state.preview = undefined;
         context.state.previewGeneration =
           (context.state.previewGeneration ?? 0) + 1;
       } else if (!context.argsComplete || !previewInput) {
+        cancelPendingPreview();
         context.state.argsKey = undefined;
         context.state.preview = undefined;
         context.state.previewGeneration =
@@ -331,31 +341,35 @@ export function buildToolDef(): ToolDef {
       } else {
         const argsKey = JSON.stringify(previewInput);
         if (context.state.argsKey !== argsKey) {
+          cancelPendingPreview();
           context.state.argsKey = argsKey;
           context.state.preview = undefined;
           const previewGeneration = (context.state.previewGeneration ?? 0) + 1;
           context.state.previewGeneration = previewGeneration;
-          compPreview(args, context.cwd)
-            .then((preview) => {
-              if (
-                context.state.argsKey === argsKey &&
-                context.state.previewGeneration === previewGeneration
-              ) {
-                context.state.preview = preview;
-                context.invalidate();
-              }
-            })
-            .catch((err: unknown) => {
-              if (
-                context.state.argsKey === argsKey &&
-                context.state.previewGeneration === previewGeneration
-              ) {
-                context.state.preview = {
-                  error: err instanceof Error ? err.message : String(err),
-                };
-                context.invalidate();
-              }
-            });
+          context.state.previewTimer = setTimeout(() => {
+            context.state.previewTimer = undefined;
+            compPreview(args, context.cwd)
+              .then((preview) => {
+                if (
+                  context.state.argsKey === argsKey &&
+                  context.state.previewGeneration === previewGeneration
+                ) {
+                  context.state.preview = preview;
+                  context.invalidate();
+                }
+              })
+              .catch((err: unknown) => {
+                if (
+                  context.state.argsKey === argsKey &&
+                  context.state.previewGeneration === previewGeneration
+                ) {
+                  context.state.preview = {
+                    error: err instanceof Error ? err.message : String(err),
+                  };
+                  context.invalidate();
+                }
+              });
+          }, PREVIEW_DEBOUNCE_MS);
         }
       }
       const text =
@@ -384,6 +398,10 @@ export function buildToolDef(): ToolDef {
 
       const renderState = context.state as RRState | undefined;
       if (renderState) {
+        if (renderState.previewTimer) {
+          clearTimeout(renderState.previewTimer);
+          renderState.previewTimer = undefined;
+        }
         renderState.preview = undefined;
         renderState.previewGeneration = (renderState.previewGeneration ?? 0) + 1;
       }
@@ -458,21 +476,27 @@ export function buildToolDef(): ToolDef {
         }
 
         abortIf(signal);
-        await writeAtomic(
-          absolutePath,
-          bom + restoreEndings(result, originalEnding),
-        );
-        const undoPersisted = await saveUndo(mutationTargetPath, {
+        const undo = await saveUndo(mutationTargetPath, {
           content: originalNormalized,
           bom,
           originalEnding,
           hashes: originalHashes,
           resultContent: result,
         });
-        if (!undoPersisted) {
-          warnings.push(
-            "Undo history could not be persisted; undo_last_replace will not be available for this edit.",
+        if (!undo.persisted) {
+          throw new Error(
+            `[E_UNDO_UNAVAILABLE] Cannot persist undo history to the hash store; the edit was NOT applied and ${path} is unchanged. Retry the replace, or use write if the store cannot be recovered.`
+          );
+        }
+        try {
+          abortIf(signal);
+          await writeAtomic(
+            absolutePath,
+            bom + restoreEndings(result, originalEnding),
           );
+        } catch (error) {
+          await undo.restore();
+          throw error;
         }
         const updatedSnapshotId = (await fileSnap(absolutePath))
           .snapshotId;