pi-hashline-edit-pro 2.6.0 → 2.6.2

package/README.md

@@ -101,6 +101,8 @@ Notes:
 - Every line in the removed range must match what was last shown to you. The extension records the `HASH│content` rows it serves — `read` output, the auto-read block after `write`, the `+HASH│`/` HASH│` rows of post-edit diffs (replace and undo), the current-range rows of `[E_RANGE_STALE]` feedback, and the context rows of stale/ambiguous-anchor feedback — and verifies the whole range against that record before writing. If an interior line changed on disk since it was shown (external editor, formatter-on-save, code generation) or was never shown, the edit is refused with `[E_RANGE_STALE]` and the current range is returned with fresh anchors, so the retry needs no `read`. Edits outside the served record are only possible for files that were never read (for example right after a `write` with auto-read disabled); once the file has been served, every replaced line must have been shown.
 - After a successful edit you get the post-edit diff with fresh anchors, so you can keep editing without re-reading.
 - Do not issue multiple replace calls on the same file in one message; parallel edits split attention across the post-edit diffs and removed lines are easy to miss. Verify each diff before the next edit on that file.
+- Line endings and BOMs survive every edit. The file's line ending is detected from its first newline and restored on write; a file that mixes LF and CRLF (for example a WSL-edited file) is normalized to the first-seen ending.
+- Files with multiple hard links (`nlink > 1`) are rewritten in place rather than via a temp-file rename, so every link keeps seeing the same content; that write is direct rather than atomic.
 
 ## Undo
 
@@ -120,6 +122,14 @@ Enabled by default. After a successful `write` that changes the file, the extens
 - Auto-read keeps a 50KB display budget. Lines over 50KB are skipped with a marker instead of their content (use `read` for lines up to 200KB).
 - Toggle at runtime with `/toggle-auto-read`; the setting persists across sessions.
 
+## Tool result details
+
+All three tools return machine-readable metadata in `details` alongside the model-visible text:
+
+- `read`: `details.truncation` (set when the output was truncated), `details.snapshotId` (a `v2|path|ino|mtime|ctime|size` fingerprint of the file), `details.nextOffset` (use as the next `offset`), and `details.metrics` with `truncated` and `next_offset`.
+- `replace`: `details.diff` (the post-edit diff; `+HASH│` and ` HASH│` rows carry the current anchors), `details.patch` (a standard unified patch of the changes, for external tools), `details.firstChangedLine`, `details.snapshotId`, `details.classification` (`"noop"` when nothing changed), and `details.metrics`: `edits_attempted`, `edits_noop`, `warnings`, `classification` (`"applied"` or `"noop"`), `changed_lines` (`{ first, last }`), `added_lines`, `removed_lines`.
+- `undo_last_replace`: `details.diff` (the undo diff with the restored anchors), `details.patch` (a standard unified patch of the restored changes), and `details.metrics` (same shape as `replace`).
+
 ## Settings
 
 | Command | Description |
@@ -144,7 +154,7 @@ Unique anchors by construction. If a line's base hash collides with an already-a
 
 Hashes live in a persistent per-file store (`~/.config/pi-hashline-edit-pro/hash-store.sqlite`) that keeps the hashes of unchanged lines across edits. When a range is replaced, the runtime maps the old content onto the new content and copies hashes for lines that survived; only genuinely new lines get fresh hashes.
 
-The store also keeps a per-file record of the hashes the model was last served (`read` rows, auto-read blocks, post-edit diff rows). `replace` verifies every line of the resolved range against that record before writing; a line whose hash was never served means it either changed on disk after it was shown or was never shown, and the edit is refused with `[E_RANGE_STALE]`. A `write` clears the record, so edits after a write are verified against whatever the next `read` or auto-read block serves.
+The store also keeps a per-file record of the hashes the model was last served (`read` rows, auto-read blocks, post-edit diff rows), pruned to the file's current hashes on every update so removed lines' hashes do not accumulate. `replace` verifies every line of the resolved range against that record before writing; a line whose hash is missing from the record means it either changed on disk after it was shown or was never shown, and the edit is refused with `[E_RANGE_STALE]`. A `write` clears the record, so edits after a write are verified against whatever the next `read` or auto-read block serves.
 
 Two guarantees make this safe even with duplicated content:
 

package/index.ts

@@ -88,7 +88,7 @@ export default function (pi: ExtensionAPI): void {
           DEFAULT_MAX_BYTES,
           AUTO_READ_MAX,
         );
-        await recordServedSafe(absolutePath, preview.servedHashes, "auto-read");
+        await recordServedSafe(absolutePath, preview.servedHashes, "auto-read", new Set(fileHashes));
         return {
           content: [
             ...(event.content ?? []),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "2.6.0",
+  "version": "2.6.2",
   "type": "module",
   "description": "Hash-anchored read/replace/undo tools for pi-coding-agent. Every line gets a unique 3-char hash (A-Za-z0-9) that stays stable across edits; stale or ambiguous anchors are rejected, never fuzzy-matched. Undo persists across restarts.",
   "main": "index.ts",
@@ -53,6 +53,7 @@
   },
   "scripts": {
     "test": "vitest run",
+    "test:unit": "vitest run --config vitest.unit.config.ts",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage --coverage.thresholds.lines=90 --coverage.thresholds.statements=90 --coverage.thresholds.functions=85 --coverage.thresholds.branches=80",
     "lint": "eslint \"src/**/*.ts\" \"index.ts\" \"test/**/*.ts\"",

package/prompts/replace-guidelines.md

@@ -5,5 +5,4 @@
 - `replace`: when copying a line from read output, remove its HASH│ prefix and keep the leading whitespace exactly as shown.
 - `replace`: replacement_lines is an array of strings, one element per line. Mirror the removed lines exactly, blank lines included: use `[]` to delete the range, `[""]` for a single blank line, `["a", ""]` for a line followed by a blank line, and `["", ""]` for two blank lines. Do not embed `\n` inside an element — each element is exactly one line.
 - `replace`: when auto-read shows the post-edit diff, its rows are the fresh anchors for the new file — `+HASH│` and ` HASH│` rows carry current hashes and unchanged lines keep their previous hashes, so you can anchor follow-up edits on the diff without re-reading.
-- `replace`: `[E_RANGE_STALE]` means a line inside the replaced range changed on disk after it was last shown (or was never shown). Nothing was modified; the error lists the current range as `HASH│content` rows, so retry with those anchors and no `read`.
 - `replace`: do not issue multiple replace calls on the same file in one message. Issue the next edit only after verifying the previous diff.

package/src/file-kind.ts

@@ -119,7 +119,9 @@ export async function loadFileKindAndText(
         description: detectedMimeType,
       };
     }
-
+    if (detectedMimeType === undefined && sample.includes(0)) {
+      return { kind: "binary", description: "contains NUL bytes" };
+    }
 
     const decoder = new TextDecoder("utf-8", { fatal: false, ignoreBOM: true });
     let hadUtf8DecodeErrors = false;

package/src/hash-store.ts

@@ -1,13 +1,67 @@
 import { existsSync } from "fs";
 import { readFile, rename, mkdir, stat } from "fs/promises";
-import { DatabaseSync } from "node:sqlite";
 import { hashStorePath, hashStoreDir, legacyHashStorePath } from "./paths";
 import { errCode, isRec, splitLines } from "./utils";
 import { initHasher, contentChecksum } from "./hashline/hasher";
 import { HASH_RE } from "./hashline/alphabet";
 import { HASH_STORE_VERSION, HASH_STORE_BUSY_TIMEOUT } from "./constants";
+
 type SqlParams = (string | number)[];
 
+interface RawStatement {
+  get(...params: SqlParams): unknown;
+  all(...params: SqlParams): unknown;
+  run(...params: SqlParams): unknown;
+}
+interface RawDb {
+  exec(sql: string): void;
+  prepare(sql: string): RawStatement;
+  close(): void;
+  readonly isOpen: boolean;
+}
+export type SqliteEngine = "node:sqlite" | "bun:sqlite";
+
+interface BunDbLike {
+  exec(sql: string): void;
+  prepare(sql: string): {
+    get(...params: SqlParams): unknown;
+    all(...params: SqlParams): unknown[];
+    run(...params: SqlParams): unknown;
+  };
+  close(): void;
+}
+
+let openDbFn: (path: string) => RawDb;
+let sqliteEngine: SqliteEngine;
+
+if (typeof process !== "undefined" && (process.versions as Record<string, string | undefined>).bun) {
+  const specifier = "bun:sqlite";
+  const mod = await import(specifier) as { Database: new (path: string) => BunDbLike };
+  sqliteEngine = "bun:sqlite";
+  openDbFn = (path) => {
+    const db = new mod.Database(path);
+    db.exec(`PRAGMA busy_timeout = ${HASH_STORE_BUSY_TIMEOUT}`);
+    let closed = false;
+    return {
+      exec: (sql) => db.exec(sql),
+      prepare: (sql) => {
+        const stmt = db.prepare(sql);
+        return {
+          get: (...p) => stmt.get(...p) ?? undefined,
+          all: (...p) => stmt.all(...p),
+          run: (...p) => stmt.run(...p),
+        };
+      },
+      close: () => { if (!closed) { closed = true; db.close(); } },
+      get isOpen() { return !closed; },
+    };
+  };
+} else {
+  const { DatabaseSync } = await import("node:sqlite");
+  sqliteEngine = "node:sqlite";
+  openDbFn = (path) => new DatabaseSync(path, { timeout: HASH_STORE_BUSY_TIMEOUT }) as unknown as RawDb;
+}
+
 interface Prepared {
   get: (...params: SqlParams) => Record<string, unknown> | undefined;
   allPaths: (...params: SqlParams) => Record<string, unknown>[];
@@ -24,7 +78,7 @@ interface Prepared {
 
 export interface HashStore {
   readonly stmts: Prepared;
-  readonly engine: "node:sqlite";
+  readonly engine: SqliteEngine;
 }
 
 export interface UndoRecord {
@@ -116,11 +170,11 @@ function withBusyRetry<T>(fn: () => T): T {
   throw lastError;
 }
 
-function openDbWithBusyRetry(storePath: string): { db: DatabaseSync; stmts: Prepared } {
+function openDbWithBusyRetry(storePath: string): { db: RawDb; stmts: Prepared } {
   return withBusyRetry(() => openDb(storePath));
 }
 
-let cachedDb: { path: string; db: DatabaseSync; stmts: Prepared } | null = null;
+let cachedDb: { path: string; db: RawDb; stmts: Prepared } | null = null;
 let opening: { path: string; promise: Promise<HashStore> } | null = null;
 let exitHandlerRegistered = false;
 interface SnapshotCacheEntry {
@@ -130,10 +184,8 @@ interface SnapshotCacheEntry {
 }
 const snapshotCache = new Map<string, SnapshotCacheEntry>();
 export const SNAPSHOT_CACHE_LIMIT = 256;
-function openDb(storePath: string): { db: DatabaseSync; stmts: Prepared } {
-  const db = new DatabaseSync(storePath, {
-    timeout: HASH_STORE_BUSY_TIMEOUT,
-  });
+function openDb(storePath: string): { db: RawDb; stmts: Prepared } {
+  const db = openDbFn(storePath);
   try {
     return buildStore(db);
   } catch (error) {
@@ -145,8 +197,8 @@ function openDb(storePath: string): { db: DatabaseSync; stmts: Prepared } {
 }
 
 function buildStore(
-  db: DatabaseSync,
-): { db: DatabaseSync; stmts: Prepared } {
+  db: RawDb,
+): { db: RawDb; stmts: Prepared } {
   db.exec("PRAGMA journal_mode = WAL");
   db.exec("PRAGMA synchronous = NORMAL");
   db.exec(
@@ -229,7 +281,7 @@ function buildStore(
   return { db, stmts };
 }
 
-function isHealthy(db: DatabaseSync): boolean {
+function isHealthy(db: RawDb): boolean {
   try {
     const row = db.prepare("PRAGMA quick_check").get() as { quick_check?: string } | undefined;
     return row?.quick_check === "ok";
@@ -252,7 +304,7 @@ async function quarantineStore(storePath: string): Promise<void> {
   }
 }
 
-function shutdownDb(db: DatabaseSync): void {
+function shutdownDb(db: RawDb): void {
   try {
     db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
   } catch {
@@ -267,7 +319,7 @@ async function openStore(storePath: string): Promise<HashStore> {
   await mkdir(hashStoreDir(), { recursive: true });
 
   let existed = existsSync(storePath);
-  let opened: { db: DatabaseSync; stmts: Prepared };
+  let opened: { db: RawDb; stmts: Prepared };
   try {
     opened = openDbWithBusyRetry(storePath);
   } catch (error) {
@@ -305,13 +357,13 @@ async function openStore(storePath: string): Promise<HashStore> {
     }
   }
 
-  return { stmts, engine: "node:sqlite" };
+  return { stmts, engine: sqliteEngine };
 }
 
 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" });
+    return Promise.resolve({ stmts: cachedDb.stmts, engine: sqliteEngine });
   }
   if (opening && opening.path === storePath) {
     return opening.promise;
@@ -347,7 +399,7 @@ function withStore(fn: () => void): void {
   });
 }
 
-async function migrateLegacy(db: DatabaseSync): Promise<void> {
+async function migrateLegacy(db: RawDb): Promise<void> {
   const legacyPath = legacyHashStorePath();
   let content: string;
   try {

package/src/hashline/hash.ts

@@ -258,7 +258,7 @@ function mapStableHashes(
 
   const removedByContent = new Map<string, { hashes: string[]; pos: number }>();
   for (const entry of removedEntries) {
-    const key = canon(oldLines[entry.index]!);
+    const key = oldLines[entry.index]!;
     let queue = removedByContent.get(key);
     if (!queue) {
       queue = { hashes: [], pos: 0 };
@@ -269,7 +269,7 @@ function mapStableHashes(
 
   for (let i = 0; i < newLines.length; i++) {
     if (newHashes[i]) continue;
-    const queue = removedByContent.get(canon(newLines[i]!));
+    const queue = removedByContent.get(newLines[i]!);
     if (!queue || queue.pos >= queue.hashes.length) continue;
     newHashes[i] = queue.hashes[queue.pos]!;
     queue.pos += 1;

package/src/hashline/resolve.ts

@@ -455,11 +455,6 @@ export function valEdit(
 		}
 		return { resolved: undefined, mismatches, boundaryDups };
 	}
-	if (startResolved.line > endResolved.line) {
-		throw new Error(
-			`[E_BAD_OP] Range start line ${startResolved.line} must be <= end line ${endResolved.line} (anchors ${edit.hash_bounds[0].hash} and ${edit.hash_bounds[1].hash}).`,
-		);
-	}
 	const endLine = endResolved.line;
 	const rangeLines = fileLines.slice(startResolved.line - 1, endLine);
 	const canonLines = fileLines.map((line) => canon(line));

package/src/read.ts

@@ -216,7 +216,7 @@ export function regRead(pi: ExtensionAPI): void {
 				fileHashes,
 				resolvedPath,
 			);
-			await recordServedSafe(resolvedPath, preview.servedHashes, "read");
+			await recordServedSafe(resolvedPath, preview.servedHashes, "read", new Set(fileHashes));
 			const snapshotId = await safeSnapId(absolutePath, "read");
 			const previewText =
 				hadUtf8DecodeErrors

package/src/replace-diff.ts

@@ -139,3 +139,14 @@ export function genDiff(
 
   return { diff: output.join("\n"), firstChangedLine };
 }
+
+export function genPatch(
+  path: string,
+  oldContent: string,
+  newContent: string,
+): string {
+  return Diff.createTwoFilesPatch(path, path, oldContent, newContent, undefined, undefined, {
+    context: 4,
+    headerOptions: Diff.FILE_HEADERS_ONLY,
+  });
+}

package/src/replace-response.ts

@@ -1,5 +1,5 @@
 import type { ReplaceDetails } from "./replace";
-import { genDiff } from "./replace-diff";
+import { genDiff, genPatch } from "./replace-diff";
 import { visLines, clipLine } from "./utils";
 
 type TResult = {
@@ -114,6 +114,7 @@ export function buildNoop(input: NoopInput): TResult {
 		content: [{ type: "text", text }],
 		details: {
 			diff: "",
+			patch: "",
 			firstChangedLine: undefined,
 			snapshotId,
 			classification: "noop" as const,
@@ -154,6 +155,7 @@ export function buildChanged(input: SuccessInput): TResult {
     content: [{ type: "text", text }],
     details: {
       diff: diffResult.diff,
+      patch: genPatch(path, originalNormalized, result),
       firstChangedLine:
         editMeta.firstChangedLine ?? diffResult.firstChangedLine,
       snapshotId,

package/src/replace-undo.ts

@@ -7,7 +7,7 @@ import { recordServedDiff } from "./served";
 import { contentChecksum } from "./hashline/hasher";
 import { resolveTarget, writeAtomic } from "./fs-write";
 import { toCwd } from "./paths";
-import { toLF, stripBOM, genDiff, restoreEndings, type LineEnding } from "./replace-diff";
+import { toLF, stripBOM, genDiff, genPatch, restoreEndings, type LineEnding } from "./replace-diff";
 import { cntDiff, splitLines, errCode, makePrepareArguments } from "./utils";
 import { loadP, loadGuide } from "./prompts";
 import { buildMetrics } from "./replace-response";
@@ -170,7 +170,7 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
         try {
           const store = await loadHashStore();
           upsertSnapshot(store, mutationTargetPath, contentChecksum(undo.content), splitLines(undo.content).length, undo.hashes);
-          recordServedDiff(store, mutationTargetPath, undoDiff);
+          recordServedDiff(store, mutationTargetPath, undoDiff, new Set(undo.hashes));
         } catch (error) {
           console.error("Failed to restore hash store snapshot after undo:", error);
         }
@@ -198,6 +198,7 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
           ],
           details: {
             diff: undoDiff,
+            patch: genPatch(path, currentNormalized, undo.content),
             metrics: buildMetrics({
               classification: "applied",
               editsAttempted: 1,

package/src/replace.ts

@@ -85,6 +85,7 @@ export type ReqParams = {
 
 export type ReplaceDetails = {
   diff: string;
+  patch?: string;
   firstChangedLine?: number;
   snapshotId?: string;
   classification?: "noop";
@@ -255,9 +256,9 @@ export async function execPipeline(
   } catch (error) {
     if (options?.noPersist !== true) {
       if (error instanceof RangeStaleError) {
-        await recordServedSafe(absolutePath, error.rangeHashes, "range-stale feedback");
+        await recordServedSafe(absolutePath, error.rangeHashes, "range-stale feedback", new Set(originalHashes));
       } else if (error instanceof AnchorMismatchError) {
-        await recordServedSafe(absolutePath, error.feedbackHashes, "anchor-mismatch feedback");
+        await recordServedSafe(absolutePath, error.feedbackHashes, "anchor-mismatch feedback", new Set(originalHashes));
       }
     }
     throw error;
@@ -572,7 +573,7 @@ export function buildToolDef(): ToolDef {
         };
         const changed = buildChanged(successInput);
         if (changed.details.diff) {
-          await recordServedDiffSafe(mutationTargetPath, changed.details.diff, "post-edit diff");
+          await recordServedDiffSafe(mutationTargetPath, changed.details.diff, "post-edit diff", new Set(resultHashes));
         }
         return changed;
       });

package/src/served.ts

@@ -20,22 +20,41 @@ export function getServed(store: HashStore, path: string): Set<string> | undefin
   return new Set(parsed);
 }
 
-export function recordServed(store: HashStore, path: string, hashes: string[]): void {
-  if (hashes.length === 0) return;
-  const existing = getServed(store, path) ?? new Set<string>();
+export function recordServed(
+  store: HashStore,
+  path: string,
+  hashes: string[],
+  scope?: ReadonlySet<string>,
+): void {
+  const existing = getServed(store, path);
+  if (!existing && hashes.length === 0) return;
+  const set = existing ?? new Set<string>();
   let changed = false;
+  if (scope) {
+    for (const hash of set) {
+      if (!scope.has(hash)) {
+        set.delete(hash);
+        changed = true;
+      }
+    }
+  }
   for (const hash of hashes) {
-    if (!existing.has(hash)) {
-      existing.add(hash);
+    if (!set.has(hash)) {
+      set.add(hash);
       changed = true;
     }
   }
   if (!changed) return;
-  store.stmts.servedUpsert(path, JSON.stringify([...existing]), Date.now());
+  store.stmts.servedUpsert(path, JSON.stringify([...set]), Date.now());
 }
 
-export function recordServedDiff(store: HashStore, path: string, diff: string): void {
-  recordServed(store, path, servedHashesFromDiff(diff));
+export function recordServedDiff(
+  store: HashStore,
+  path: string,
+  diff: string,
+  scope?: ReadonlySet<string>,
+): void {
+  recordServed(store, path, servedHashesFromDiff(diff), scope);
 }
 
 export function clearServed(store: HashStore, path: string): void {
@@ -46,11 +65,12 @@ export async function recordServedSafe(
   path: string,
   hashes: string[],
   context: string,
+  scope?: ReadonlySet<string>,
 ): Promise<void> {
-  if (hashes.length === 0) return;
+  if (hashes.length === 0 && !scope) return;
   try {
     const store = await loadHashStore();
-    recordServed(store, path, hashes);
+    recordServed(store, path, hashes, scope);
   } catch (error) {
     console.error(`Failed to record served state (${context}):`, error);
   }
@@ -60,7 +80,8 @@ export async function recordServedDiffSafe(
   path: string,
   diff: string,
   context: string,
+  scope?: ReadonlySet<string>,
 ): Promise<void> {
   if (!diff) return;
-  await recordServedSafe(path, servedHashesFromDiff(diff), context);
+  await recordServedSafe(path, servedHashesFromDiff(diff), context, scope);
 }