pi-hashline-edit-pro 1.0.4 → 1.0.5

package/README.md

@@ -66,6 +66,7 @@ Edge cases:
 
 - **Images** (JPEG, PNG, GIF, WebP) are passed through as visual attachments and don't participate in the hashline protocol.
 - **Binary and directory paths** are rejected with a descriptive error.
+- **UTF-16/UTF-32 encoded text** (detected via BOM) is rejected with `[E_NOT_TEXT]` — editing such a file would decode it as `U+FFFD` garbage and rewrite it as corrupted UTF-8.
 - **Empty files** are returned as a single empty-line hash (`HASH│`); use `replace` on that hash to insert content.
 - **BOMs** are stripped for display; **non-UTF-8 bytes** are shown as `U+FFFD` (editing such a file rewrites it as UTF-8, with a warning).
 - **Files over 238,328 lines** are rejected with `[E_FILE_TOO_LARGE]` (see [Hashing](#hashing)).
@@ -120,13 +121,14 @@ Enabled by default. After a successful `write`, `replace`, or `undo_last_replace
 - After `replace` / `undo_last_replace`, the block covers the changed span plus 2 lines of context above and below — the rest of the file keeps its anchors from the persistent store.
 - After `write`, the block dumps from the top of the file. For files over 2000 lines, the dump is truncated with a pagination hint — use `read` with `offset` to continue.
 - Toggle at runtime with `/toggle-auto-read`; the setting persists across sessions.
+- If the auto-read itself fails (e.g. the file was deleted between the operation and the read), a short `--- Auto-read failed: ... ---` notice is appended instead of the anchor block, so the model knows the anchors are missing.
 
 ## 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 anchors.
 
 - History is per-file and single-level: only the most recent replace can be reverted.
-- History is in-memory and is lost when the session ends or the extension reloads.
+- 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.
 - 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.
@@ -160,7 +162,7 @@ Settings live in `~/.config/pi-hashline-edit-pro/config.json`, created automatic
 | `[E_WOULD_EMPTY]` | An edit would empty a non-empty file; use `write` instead. |
 | `[E_NOT_FOUND]` | The path does not exist. |
 | `[E_ACCESS]` | The file is not readable or writable. |
-| `[E_NOT_TEXT]` | The path is a directory, binary file, or image; hashline editing only supports text files. |
+| `[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_FILE_TOO_LARGE]` | The file exceeds the 238,328-line hashline limit. |
 
@@ -176,7 +178,7 @@ The alphabet is sized for an LLM consumer: the model tokenizes rather than squin
 
 - **Stale anchors fail, per line.** A hash mismatch means that line's content changed since the last `read`. The error says so and, when only one anchor of a pair is stale, shows the current lines around the still-valid anchor so the range can be re-located without a full re-read. Mismatched anchors are never silently relocated to a "close enough" line — correctness over convenience.
 - **Autocorrection only when the intent is unambiguous**, and always visible: hash-prefix and diff-row stripping produce a warning; the boundary-duplication fix is silent because the duplicate never reaches the file. Literal content is never silently altered when the intent is ambiguous (numbered deletion rows and unified-diff lines are written verbatim).
-- **Byte-exact preservation.** UTF-8 BOMs, CRLF vs LF endings, file permissions, and trailing newlines survive edits and undo.
+- **Byte-exact preservation.** UTF-8 BOMs, CRLF, LF, and CR-only line endings, file permissions, and trailing newlines survive edits and undo.
 - **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.
 

package/index.ts

@@ -59,7 +59,7 @@ export default function (pi: ExtensionAPI): void {
       const writtenPath = (event.input as Record<string, unknown>)?.path;
       if (typeof writtenPath === "string") {
         try {
-          clearUndo(await resolveTarget(toCwd(writtenPath, ctx.cwd)));
+          await clearUndo(await resolveTarget(toCwd(writtenPath, ctx.cwd)));
         } catch (error) {
           console.error("Failed to clear undo after write:", error);
         }
@@ -108,6 +108,13 @@ export default function (pi: ExtensionAPI): void {
       };
     } catch (error) {
       console.error("Auto-read after write/replace failed:", error);
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        content: [
+          ...(event.content ?? []),
+          { type: "text", text: `\n\n--- Auto-read failed: ${message} ---` },
+        ],
+      };
     }
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "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/prompts/read.md

@@ -1 +1 @@
-Read a text file; each line returned as HASH│content with a 3-char alphanumeric hash. No line numbers — use the HASH as the anchor in replace calls. Images → visual attachments; Binary/directory → rejected; empty → HASH│ (replace to insert); pageable with offset/limit; BOM stripped; non-UTF-8 shown as U+FFFD.
+Read a text file; each line returned as HASH│content with a 3-char alphanumeric hash. No line numbers — use the HASH as the anchor in replace calls. Images → visual attachments; Binary/directory → rejected; UTF-16/UTF-32 (BOM) → rejected; empty → HASH│ (replace to insert); pageable with offset/limit; BOM stripped; non-UTF-8 shown as U+FFFD.

package/src/file-kind.ts

@@ -15,6 +15,26 @@ const TEXT_TYPES = new Set<string>([
   "application/x-ms-regedit",
 ]);
 
+function detectTextBom(sample: Uint8Array): string | undefined {
+  if (
+    sample.length >= 4 &&
+    sample[0] === 0xff &&
+    sample[1] === 0xfe &&
+    sample[2] === 0x00 &&
+    sample[3] === 0x00
+  ) return "UTF-32LE";
+  if (
+    sample.length >= 4 &&
+    sample[0] === 0x00 &&
+    sample[1] === 0x00 &&
+    sample[2] === 0xfe &&
+    sample[3] === 0xff
+  ) return "UTF-32BE";
+  if (sample.length >= 2 && sample[0] === 0xff && sample[1] === 0xfe) return "UTF-16LE";
+  if (sample.length >= 2 && sample[0] === 0xfe && sample[1] === 0xff) return "UTF-16BE";
+  return undefined;
+}
+
 function isTextType(mimeType: string): boolean {
   return mimeType.startsWith("text/") || TEXT_TYPES.has(mimeType);
 }
@@ -66,6 +86,13 @@ export async function loadFileKindAndText(
     }
 
     const sample = buffer.subarray(0, bytesRead);
+    const textBom = detectTextBom(sample);
+    if (textBom) {
+      return {
+        kind: "binary",
+        description: `${textBom} encoded text`
+      };
+    }
     const detectedMimeType = (await fileTypeFromBuffer(sample))?.mime;
     if (
       detectedMimeType !== undefined &&

package/src/file-reader.ts

@@ -4,7 +4,7 @@ import { lineHashes } from "./hashline";
 import { loadFileKindAndText, type LFile } from "./file-kind";
 import { resolveTarget } from "./fs-write";
 import { toCwd } from "./paths";
-import { detectEnding, toLF, stripBOM } from "./replace-diff";
+import { detectEnding, toLF, stripBOM, type LineEnding } from "./replace-diff";
 import { abortIf } from "./utils";
 import { valKind, valAccess } from "./validation";
 import { visLines } from "./utils";
@@ -13,7 +13,7 @@ export interface NormFile {
   absolutePath: string;
   normalized: string;
   bom: string;
-  originalEnding: "\r\n" | "\n";
+  originalEnding: LineEnding;
   fileHashes: string[];
   hadUtf8DecodeErrors: boolean;
 }

package/src/hash-store.ts

@@ -12,6 +12,9 @@ interface Prepared {
   allPaths: (...params: SqlParams) => Record<string, unknown>[];
   deleteOne: (...params: SqlParams) => void;
   upsert: (...params: SqlParams) => void;
+  undoUpsert: (...params: SqlParams) => void;
+  undoGet: (...params: SqlParams) => Record<string, unknown> | undefined;
+  undoDelete: (...params: SqlParams) => void;
 }
 
 export interface HashStore {
@@ -19,6 +22,14 @@ export interface HashStore {
   readonly engine: "node:sqlite";
 }
 
+export interface UndoRecord {
+  content: string;
+  bom: string;
+  ending: string;
+  hashes: string[];
+  resultContent: string;
+}
+
 interface LegacySnapshot {
   content: string;
   hashes: string[];
@@ -72,27 +83,49 @@ function buildStore(
       "value TEXT NOT NULL" +
     ")"
   );
+  db.exec(
+    "CREATE TABLE IF NOT EXISTS undo (" +
+      "path TEXT PRIMARY KEY, " +
+      "content TEXT NOT NULL, " +
+      "bom TEXT NOT NULL, " +
+      "ending TEXT NOT NULL, " +
+      "hashes TEXT NOT NULL, " +
+      "result_content TEXT NOT NULL, " +
+      "updated_at INTEGER 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.exec("DELETE FROM undo");
   }
   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 allStmt = db.prepare("SELECT path FROM snapshots UNION SELECT path FROM undo");
   const delStmt = db.prepare("DELETE FROM snapshots WHERE path = ?");
   const upsertStmt = db.prepare(
     "INSERT INTO snapshots (path, checksum, line_count, hashes, updated_at) VALUES (?, ?, ?, ?, ?) " +
     "ON CONFLICT(path) DO UPDATE SET checksum = excluded.checksum, line_count = excluded.line_count, hashes = excluded.hashes, updated_at = excluded.updated_at"
   );
-
+  const undoUpsertStmt = db.prepare(
+    "INSERT INTO undo (path, content, bom, ending, hashes, result_content, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?) " +
+    "ON CONFLICT(path) DO UPDATE SET content = excluded.content, bom = excluded.bom, ending = excluded.ending, hashes = excluded.hashes, result_content = excluded.result_content, updated_at = excluded.updated_at"
+  );
+  const undoGetStmt = db.prepare(
+    "SELECT content, bom, ending, hashes, result_content FROM undo WHERE path = ?"
+  );
+  const undoDelStmt = db.prepare("DELETE FROM undo WHERE path = ?");
   const stmts: Prepared = {
     get: (...params) => getStmt.get(...params) as Record<string, unknown> | undefined,
     allPaths: (...params) => allStmt.all(...params) as Record<string, unknown>[],
     deleteOne: (...params) => { delStmt.run(...params); },
     upsert: (...params) => { upsertStmt.run(...params); },
+    undoUpsert: (...params) => { undoUpsertStmt.run(...params); },
+    undoGet: (...params) => undoGetStmt.get(...params) as Record<string, unknown> | undefined,
+    undoDelete: (...params) => { undoDelStmt.run(...params); },
   };
 
   return { db, stmts };
@@ -295,6 +328,44 @@ export function deleteSnapshot(store: HashStore, path: string): void {
   store.stmts.deleteOne(path);
 }
 
+export function upsertUndo(store: HashStore, path: string, entry: UndoRecord): void {
+  store.stmts.undoUpsert(
+    path,
+    entry.content,
+    entry.bom,
+    entry.ending,
+    JSON.stringify(entry.hashes),
+    entry.resultContent,
+    Date.now(),
+  );
+}
+
+export function getUndoEntry(store: HashStore, path: string): UndoRecord | undefined {
+  const row = store.stmts.undoGet(path);
+  if (!row) return undefined;
+  try {
+    const parsed = JSON.parse(row.hashes as string);
+    if (!Array.isArray(parsed) || !parsed.every((h) => typeof h === "string")) {
+      store.stmts.undoDelete(path);
+      return undefined;
+    }
+    return {
+      content: row.content as string,
+      bom: row.bom as string,
+      ending: row.ending as string,
+      hashes: parsed as string[],
+      resultContent: row.result_content as string,
+    };
+  } catch {
+    store.stmts.undoDelete(path);
+    return undefined;
+  }
+}
+
+export function deleteUndo(store: HashStore, path: string): void {
+  store.stmts.undoDelete(path);
+}
+
 export async function pruneMissing(store: HashStore): Promise<void> {
   const rows = store.stmts.allPaths() as { path: string }[];
   const missing: string[] = [];
@@ -307,6 +378,9 @@ export async function pruneMissing(store: HashStore): Promise<void> {
   }
   if (missing.length === 0) return;
   withStore(() => {
-    for (const path of missing) store.stmts.deleteOne(path);
+    for (const path of missing) {
+      store.stmts.deleteOne(path);
+      store.stmts.undoDelete(path);
+    }
   });
 }

package/src/replace-diff.ts

@@ -5,10 +5,15 @@ import {
   HASH_SEP,
 } from "./hashline";
 
-export function detectEnding(content: string): "\r\n" | "\n" {
-  const crlfIdx = content.indexOf("\r\n");
+export type LineEnding = "\r\n" | "\n" | "\r";
+
+export function detectEnding(content: string): LineEnding {
   const lfIdx = content.indexOf("\n");
-  if (lfIdx === -1 || crlfIdx === -1) return "\n";
+  if (lfIdx === -1) {
+    return content.indexOf("\r") >= 0 ? "\r" : "\n";
+  }
+  const crlfIdx = content.indexOf("\r\n");
+  if (crlfIdx === -1) return "\n";
   return crlfIdx < lfIdx ? "\r\n" : "\n";
 }
 
@@ -18,9 +23,11 @@ export function toLF(text: string): string {
 
 export function restoreEndings(
   text: string,
-  ending: "\r\n" | "\n",
+  ending: LineEnding,
 ): string {
-  return ending === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
+  if (ending === "\r\n") return text.replace(/\n/g, "\r\n");
+  if (ending === "\r") return text.replace(/\n/g, "\r");
+  return text;
 }
 
 export function stripBOM(content: string): { bom: string; text: string } {

package/src/replace-undo.ts

@@ -2,11 +2,11 @@ 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 } from "./hash-store";
+import { loadHashStore, upsertSnapshot, upsertUndo, getUndoEntry, deleteUndo } from "./hash-store";
 import { contentChecksum } from "./hashline/hasher";
 import { resolveTarget, writeAtomic } from "./fs-write";
 import { toCwd } from "./paths";
-import { toLF, stripBOM, genDiff, restoreEndings } from "./replace-diff";
+import { toLF, stripBOM, genDiff, restoreEndings, type LineEnding } from "./replace-diff";
 import { cntDiff, splitLines, errCode } from "./utils";
 import { loadP, loadGuide } from "./prompts";
 import { buildMetrics } from "./replace-response";
@@ -14,26 +14,60 @@ import { changedRange } from "./hashline";
 export interface UndoEntry {
   content: string;
   bom: string;
-  originalEnding: "\r\n" | "\n";
+  originalEnding: LineEnding;
   hashes: string[];
   resultContent: string;
 }
 
-const undoMap = new Map<string, UndoEntry>();
-
-export function saveUndo(path: string, entry: UndoEntry): void {
-  undoMap.set(path, entry);
+export async function saveUndo(path: string, entry: UndoEntry): Promise<boolean> {
+  try {
+    const store = await loadHashStore();
+    upsertUndo(store, path, {
+      content: entry.content,
+      bom: entry.bom,
+      ending: entry.originalEnding,
+      hashes: entry.hashes,
+      resultContent: entry.resultContent,
+    });
+    return true;
+  } catch (error) {
+    console.error("Failed to persist undo entry:", error);
+    return false;
+  }
 }
 
-export function getUndo(path: string): UndoEntry | undefined {
-  return undoMap.get(path);
+export async function getUndo(path: string): Promise<UndoEntry | undefined> {
+  try {
+    const store = await loadHashStore();
+    const record = getUndoEntry(store, path);
+    if (!record) return undefined;
+    const originalEnding = record.ending;
+    if (originalEnding !== "\r\n" && originalEnding !== "\n" && originalEnding !== "\r") {
+      await deleteUndo(store, path);
+      return undefined;
+    }
+    return {
+      content: record.content,
+      bom: record.bom,
+      originalEnding,
+      hashes: record.hashes,
+      resultContent: record.resultContent,
+    };
+  } catch (error) {
+    console.error("Failed to load undo entry:", error);
+    return undefined;
+  }
 }
 
-export function clearUndo(path: string): void {
-  undoMap.delete(path);
+export async function clearUndo(path: string): Promise<void> {
+  try {
+    const store = await loadHashStore();
+    deleteUndo(store, path);
+  } catch (error) {
+    console.error("Failed to clear undo entry:", error);
+  }
 }
 
-
 export function regReplaceUndo(pi: ExtensionAPI): void {
   pi.registerTool({
     name: "undo_last_replace",
@@ -52,7 +86,7 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
       const absolutePath = toCwd(path, ctx.cwd);
       const mutationTargetPath = await resolveTarget(absolutePath);
 
-      const undo = getUndo(mutationTargetPath);
+      const undo = await getUndo(mutationTargetPath);
       if (!undo) {
         return {
           content: [
@@ -118,7 +152,7 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
           console.error("Failed to restore hash store snapshot after undo:", error);
         }
 
-        clearUndo(mutationTargetPath);
+        await clearUndo(mutationTargetPath);
 
         const parts: string[] = [
           `Undone last replace on ${path}.`,

package/src/replace.ts

@@ -9,6 +9,7 @@ import { constants } from "fs";
 import {
   genDiff,
   restoreEndings,
+  type LineEnding,
 } from "./replace-diff";
 import { readNormFile } from "./file-reader";
 import { normReq, normalizeFilePath, tryParseContentLines } from "./replace-normalize";
@@ -86,7 +87,7 @@ interface PipelineResult {
   originalNormalized: string;
   result: string;
   bom: string;
-  originalEnding: "\r\n" | "\n";
+  originalEnding: LineEnding;
   hadUtf8DecodeErrors: boolean;
   warnings: string[];
   noopEdit?: NEdit;
@@ -465,13 +466,18 @@ export function buildToolDef(): ToolDef {
           absolutePath,
           bom + restoreEndings(result, originalEnding),
         );
-        saveUndo(mutationTargetPath, {
+        const undoPersisted = 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.",
+          );
+        }
         const updatedSnapshotId = (await fileSnap(absolutePath))
           .snapshotId;