pi-hashline-edit-pro 1.1.0 → 1.1.2

package/README.md

@@ -199,7 +199,7 @@ The alphabet is sized for an LLM consumer: the model tokenizes rather than squin
 
 ## Development
 
-Requires [Node.js](https://nodejs.org) ≥ 22.13 and npm.
+Requires [Node.js](https://nodejs.org) ≥ 22.19 and npm.
 
 ```bash
 npm install

package/index.ts

@@ -13,8 +13,10 @@ import {
 } from "./src/config";
 import { loadHashStore, pruneMissing } from "./src/hash-store";
 import { readNormFile } from "./src/file-reader";
+import { loadFileKindAndText } from "./src/file-kind";
 import { toCwd } from "./src/paths";
 import { resolveTarget } from "./src/fs-write";
+import { valAccess } from "./src/validation";
 
 export default function (pi: ExtensionAPI): void {
   regRead(pi);
@@ -22,7 +24,6 @@ export default function (pi: ExtensionAPI): void {
   regReplace(pi);
   regReplaceUndo(pi);
 
-  const debugValue = process.env.PI_HASHLINE_DEBUG;
   let autoRead = true;
 
   pi.on("session_start", async (_event, ctx) => {
@@ -37,6 +38,7 @@ export default function (pi: ExtensionAPI): void {
     }
     const config = await readConfig();
     autoRead = config.autoRead;
+    const debugValue = process.env.PI_HASHLINE_DEBUG;
     if (debugValue === "1" || debugValue === "true") {
       ctx.ui.notify(`Hashline Edit mode active`, "info");
     }
@@ -66,8 +68,12 @@ export default function (pi: ExtensionAPI): void {
       if (!autoRead) return;
       if (typeof writtenPath !== "string") return;
       try {
+        const resolvedPath = await resolveTarget(toCwd(writtenPath, ctx.cwd));
+        await valAccess(resolvedPath, writtenPath);
+        const file = await loadFileKindAndText(resolvedPath, { maxLines: MAX_HASH_LINES, displayPath: writtenPath });
+        if (file.kind !== "text") return;
         const { normalized, fileHashes, absolutePath } = await readNormFile(
-          writtenPath, ctx.cwd, { maxLines: MAX_HASH_LINES },
+          writtenPath, ctx.cwd, { maxLines: MAX_HASH_LINES, preloadedFile: file },
         );
         const preview = await fmtReadPreview(
           normalized,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "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",
@@ -34,15 +34,15 @@
   "dependencies": {
     "diff": "^8.0.2",
     "file-type": "^21.3.0",
-    "typebox": "^1.1.24",
+    "typebox": "^1.3.7",
     "xxhash-wasm": "^1.1.0"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": ">=0.74.0",
+    "@earendil-works/pi-coding-agent": ">=0.75.0",
     "@earendil-works/pi-tui": "*"
   },
   "engines": {
-    "node": ">=22.13.0"
+    "node": ">=22.19.0"
   },
   "scripts": {
     "test": "vitest run",
@@ -52,7 +52,7 @@
     "typecheck": "tsc --noEmit"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "^0.74.0",
+    "@earendil-works/pi-coding-agent": "^0.84.0",
     "@eslint/js": "^10.0.1",
     "@types/node": "^24.0.0",
     "@vitest/coverage-v8": "^4.1.10",

package/prompts/replace-guidelines.md

@@ -1,4 +1,6 @@
 - `replace`: hash_range_inclusive must use only anchors from the most recent read of the same file.
+- `replace`: hash_range_inclusive marks the exact lines that are REMOVED, and content_lines is their complete replacement applied in order; nothing outside the range changes. Every line inside the range that is not reproduced byte-exact in content_lines is deleted from the file — including closing braces and other structural lines.
+- `replace`: minimize the replaced range — anchor only the lines that actually change, so few unchanged lines must be reproduced byte-exact.
+- `replace`: to replace a single line, repeat its hash in both positions of hash_range_inclusive: ["<HASH>", "<HASH>"] — never extend the range to neighboring lines for a one-line edit.
 - `replace`: content_lines is a native JSON array of strings — never a serialized JSON string. When copying a line from read output, remove its HASH│ prefix and keep the leading whitespace exactly as shown.
-- `replace`: minimize the replaced range — anchor only the lines that actually change; for insertions use a single-line range (e.g. the line after the insertion point) instead of a whole block, so fewer unchanged lines must be reproduced byte-exact.
-- `replace`: content_lines entries are single lines — never embed a line break inside an entry; pass each line as its own array entry.
+- `replace`: content_lines entries are single lines — never embed a line break inside an entry; pass each line as its own array entry.

package/src/file-kind.ts

@@ -46,8 +46,14 @@ export type LFile =
   | { kind: "binary"; description: string };
 
 
+export interface LoadFileOptions {
+  maxLines?: number;
+  displayPath?: string;
+}
+
 export async function loadFileKindAndText(
   filePath: string,
+  options?: LoadFileOptions,
 ): Promise<LFile> {
   const pathStat = await fsStat(filePath);
   if (pathStat.isDirectory()) {
@@ -104,6 +110,7 @@ export async function loadFileKindAndText(
 
     const decoder = new TextDecoder("utf-8", { fatal: false, ignoreBOM: true });
     let hadUtf8DecodeErrors = false;
+    let newlineCount = 0;
     const parts: string[] = [];
 
     function decodeChunk(chunk: Uint8Array, stream: boolean): string {
@@ -111,6 +118,16 @@ export async function loadFileKindAndText(
       if (!hadUtf8DecodeErrors && decoded.includes("\uFFFD")) {
         hadUtf8DecodeErrors = true;
       }
+      if (options?.maxLines !== undefined) {
+        for (let i = 0; i < decoded.length; i++) {
+          if (decoded.charCodeAt(i) === 10) newlineCount++;
+        }
+        if (newlineCount > options.maxLines) {
+          throw new Error(
+            `[E_FILE_TOO_LARGE] ${options.displayPath ?? filePath} has more than ${options.maxLines} lines, exceeding the ${options.maxLines}-line edit limit. Hashline editing targets source-sized files; for very large files use write or a non-line-based approach.`,
+          );
+        }
+      }
       return decoded;
     }
 

package/src/file-reader.ts

@@ -20,12 +20,17 @@ export interface NormFile {
 
 export type SnapInfo = {
   snapshotId: string;
+  ino: number;
   mtimeMs: number;
+  ctimeMs: number;
   size: number;
 };
 
-function fmtSnapId(canonicalPath: string, info: { mtimeMs: number; size: number }): string {
-  return `v1|${canonicalPath}|${info.mtimeMs}|${info.size}`;
+function fmtSnapId(
+  canonicalPath: string,
+  info: { ino: number; mtimeMs: number; ctimeMs: number; size: number },
+): string {
+  return `v2|${canonicalPath}|${info.ino}|${info.mtimeMs}|${info.ctimeMs}|${info.size}`;
 }
 
 export async function fileSnap(absolutePath: string): Promise<SnapInfo> {
@@ -33,7 +38,9 @@ export async function fileSnap(absolutePath: string): Promise<SnapInfo> {
   const stats = await stat(canonicalPath);
   return {
     snapshotId: fmtSnapId(canonicalPath, stats),
+    ino: stats.ino,
     mtimeMs: stats.mtimeMs,
+    ctimeMs: stats.ctimeMs,
     size: stats.size,
   };
 }
@@ -60,9 +67,8 @@ export async function readNormFile(
   await valAccess(resolvedPath, path, accessMode);
 
   abortIf(signal);
-  const file = options?.preloadedFile ?? (await loadFileKindAndText(resolvedPath));
+  const file = options?.preloadedFile ?? (await loadFileKindAndText(resolvedPath, { maxLines: options?.maxLines, displayPath: path }));
   valKind(file, path);
-
   abortIf(signal);
   const { bom, text: rawContent } = stripBOM(file.text);
   const originalEnding = detectEnding(rawContent);

package/src/hash-store.ts

@@ -46,6 +46,55 @@ function isValidSnapshot(value: unknown): value is LegacySnapshot {
   return true;
 }
 
+export function isCorruptionError(error: unknown): boolean {
+  if (error && typeof error === "object") {
+    const errcode = (error as { errcode?: unknown }).errcode;
+    if (typeof errcode === "number") {
+      return errcode === 11 || errcode === 24 || errcode === 26;
+    }
+    const code = (error as { code?: unknown }).code;
+    if (typeof code === "string" && /NOTADB|CORRUPT/.test(code)) return true;
+  }
+  return (
+    error instanceof Error &&
+    /corrupt|not a database|malformed|database disk image/i.test(error.message)
+  );
+}
+
+function isBusyError(error: unknown): boolean {
+  if (error && typeof error === "object") {
+    const errcode = (error as { errcode?: unknown }).errcode;
+    if (typeof errcode === "number") return errcode === 5 || errcode === 6;
+  }
+  return error instanceof Error && /busy|locked/i.test(error.message);
+}
+
+function sleepSync(ms: number): void {
+  const sab = new Int32Array(new SharedArrayBuffer(4));
+  Atomics.wait(sab, 0, 0, ms);
+}
+
+const BUSY_RETRIES = 3;
+const BUSY_RETRY_DELAY_MS = 100;
+
+function withBusyRetry<T>(fn: () => T): T {
+  let lastError: unknown;
+  for (let attempt = 0; attempt <= BUSY_RETRIES; attempt++) {
+    try {
+      return fn();
+    } catch (error) {
+      lastError = error;
+      if (!isBusyError(error) || attempt === BUSY_RETRIES) throw error;
+      sleepSync(BUSY_RETRY_DELAY_MS);
+    }
+  }
+  throw lastError;
+}
+
+function openDbWithBusyRetry(storePath: string): { db: DatabaseSync; stmts: Prepared } {
+  return withBusyRetry(() => openDb(storePath));
+}
+
 let cachedDb: { path: string; db: DatabaseSync; stmts: Prepared } | null = null;
 let opening: { path: string; promise: Promise<HashStore> } | null = null;
 let exitHandlerRegistered = false;
@@ -121,13 +170,12 @@ function buildStore(
   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); },
+    deleteOne: (...params) => { withBusyRetry(() => { delStmt.run(...params); }); },
+    upsert: (...params) => { withBusyRetry(() => { upsertStmt.run(...params); }); },
+    undoUpsert: (...params) => { withBusyRetry(() => { undoUpsertStmt.run(...params); }); },
     undoGet: (...params) => undoGetStmt.get(...params) as Record<string, unknown> | undefined,
-    undoDelete: (...params) => { undoDelStmt.run(...params); },
+    undoDelete: (...params) => { withBusyRetry(() => { undoDelStmt.run(...params); }); },
   };
-
   return { db, stmts };
 }
 
@@ -135,8 +183,9 @@ function isHealthy(db: DatabaseSync): boolean {
   try {
     const row = db.prepare("PRAGMA quick_check").get() as { quick_check?: string } | undefined;
     return row?.quick_check === "ok";
-  } catch {
-    return false;
+  } catch (error) {
+    if (isCorruptionError(error)) return false;
+    return true;
   }
 }
 
@@ -170,18 +219,19 @@ async function openStore(storePath: string): Promise<HashStore> {
   let existed = existsSync(storePath);
   let opened: { db: DatabaseSync; stmts: Prepared };
   try {
-    opened = openDb(storePath);
+    opened = openDbWithBusyRetry(storePath);
   } catch (error) {
+    if (!isCorruptionError(error)) throw error;
     console.error("Hash store failed to open, rebuilding:", error);
     await quarantineStore(storePath);
     existed = false;
-    opened = openDb(storePath);
+    opened = openDbWithBusyRetry(storePath);
   }
   if (!isHealthy(opened.db)) {
     shutdownDb(opened.db);
     await quarantineStore(storePath);
     existed = false;
-    opened = openDb(storePath);
+    opened = openDbWithBusyRetry(storePath);
   }
   const { db, stmts } = opened;
 
@@ -228,14 +278,16 @@ export function shutdownHashStore(): void {
 
 function withStore(fn: () => void): void {
   if (cachedDb) {
-    cachedDb.db.exec("BEGIN IMMEDIATE");
-    try {
-      fn();
-      cachedDb.db.exec("COMMIT");
-    } catch (e) {
-      cachedDb.db.exec("ROLLBACK");
-      throw e;
-    }
+    withBusyRetry(() => {
+      cachedDb!.db.exec("BEGIN IMMEDIATE");
+      try {
+        fn();
+        cachedDb!.db.exec("COMMIT");
+      } catch (e) {
+        try { cachedDb!.db.exec("ROLLBACK"); } catch {}
+        throw e;
+      }
+    });
   } else {
     fn();
   }

package/src/hashline/hash.ts

@@ -43,10 +43,10 @@ function hashAt(idx: number): string {
 }
 
 export const HL_PREFIX_PLUS_RE = new RegExp(
-	`^\\+\\s*${HASH_CLASS}│`,
+	`^\\+${HASH_CLASS}│`,
 );
 export const HL_PREFIX_MINUS_RE = new RegExp(
-	`^-(?:\\s*${HASH_CLASS}│| {${ANCHOR_LEN}}│)`,
+	`^-(?:${HASH_CLASS}│| {${ANCHOR_LEN}}│)`,
 );
 
 export const HL_BARE_PREFIX_RE = new RegExp(`^\\s*(${HASH_CLASS})│`);
@@ -157,19 +157,32 @@ export async function lineHashes(
       previous.removedHashes,
     );
     if (persist !== false) {
-      upsertSnapshot(hashStore, path, contentChecksum(content), splitLines(content).length, newHashes);
+      try {
+        upsertSnapshot(hashStore, path, contentChecksum(content), splitLines(content).length, newHashes);
+      } catch (error) {
+        console.error("Failed to persist hash snapshot:", error);
+      }
     }
     return newHashes;
   }
 
-  const cached = getSnapshot(hashStore, path, content);
+  let cached: string[] | undefined;
+  try {
+    cached = getSnapshot(hashStore, path, content);
+  } catch (error) {
+    console.error("Failed to read hash store snapshot:", error);
+  }
   if (cached) {
     return cached;
   }
 
   const newHashes = _lineHashesPure(content);
   if (persist !== false) {
-    upsertSnapshot(hashStore, path, contentChecksum(content), splitLines(content).length, newHashes);
+    try {
+      upsertSnapshot(hashStore, path, contentChecksum(content), splitLines(content).length, newHashes);
+    } catch (error) {
+      console.error("Failed to persist hash snapshot:", error);
+    }
   }
   return newHashes;
 }

package/src/read.ts

@@ -100,15 +100,15 @@ export async function fmtReadPreview(
 				: fmtRegion([selectedHashes[index]!], [selected[index]!]),
 		);
 		const skippedTruncation = truncateHead(rows.join("\n"), { maxBytes });
-		const shownRows = rowSizes.filter((row) => row.bytes <= maxBytes);
-		const lastShownLine = shownRows.at(-1)?.lineNumber ?? startLine - 1;
+		const shownRowCount = skippedTruncation.content === "" ? 0 : skippedTruncation.content.split("\n").length;
+		const lastShownLine = shownRowCount > 0 ? startLine + shownRowCount - 1 : startLine - 1;
 		const lineLabel = oversized.length === 1 ? `Line ${oversized[0]!.lineNumber}` : `Lines ${oversized.map((row) => row.lineNumber).join(", ")}`;
 		const verb = oversized.length === 1 ? "exceeds" : "exceed";
 		const addresses = oversized.map((row) => `${row.lineNumber}p`).join(";");
 		const warning = `[${lineLabel} ${verb} ${formatSize(maxBytes)}; content not shown because hashline anchors require full lines. Inspect with bash: sed -n '${addresses}' <path> | head -c ${maxBytes}]`;
 		let preview = skippedTruncation.content;
 		let nextOffset: number | undefined;
-		if (shownRows.length > 0 && (skippedTruncation.truncated || lastShownLine < totalLines)) {
+		if (shownRowCount > 0 && (skippedTruncation.truncated || lastShownLine < totalLines)) {
 			nextOffset = lastShownLine + 1;
 			preview += `\n\n${warning}\n${formatPaginationHint(startLine, lastShownLine, totalLines, nextOffset, skippedTruncation.truncated ? skippedTruncation.maxBytes : undefined)}`;
 		} else {
@@ -178,7 +178,7 @@ export function regRead(pi: ExtensionAPI): void {
 			await valAccess(absolutePath, rawPath);
 
 			abortIf(signal);
-			const file = await loadFileKindAndText(absolutePath);
+			const file = await loadFileKindAndText(absolutePath, { maxLines: MAX_HASH_LINES, displayPath: rawPath });
 			if (file.kind === "image") {
 				const builtinRead = createReadTool(ctx.cwd);
 				const executeBuiltinRead = builtinRead.execute as unknown as (

package/src/replace-response.ts

@@ -35,7 +35,7 @@ type NEditEntry = {
 export interface NoopInput {
 	path: string;
 	noopEdit: NEditEntry | undefined;
-	snapshotId: string;
+	snapshotId?: string;
 	editMeta: RMeta;
 	warnings: string[] | undefined;
 }
@@ -47,7 +47,7 @@ export interface SuccessInput {
   result: string;
   resultHashes: string[];
   warnings: string[] | undefined;
-  snapshotId: string;
+  snapshotId?: string;
   editMeta: RMeta;
 }
 

package/src/replace.ts

@@ -453,7 +453,12 @@ export function buildToolDef(): ToolDef {
 
         const editsAttempted = 1;
         if (originalNormalized === result) {
-          const noopSnapshotId = (await fileSnap(absolutePath)).snapshotId;
+          let noopSnapshotId: string | undefined;
+          try {
+            noopSnapshotId = (await fileSnap(absolutePath)).snapshotId;
+          } catch (error) {
+            console.error("Failed to compute snapshot for noop edit:", error);
+          }
           return buildNoop({
             path,
             noopEdit,
@@ -497,8 +502,12 @@ export function buildToolDef(): ToolDef {
           await undo.restore();
           throw error;
         }
-        const updatedSnapshotId = (await fileSnap(absolutePath))
-          .snapshotId;
+        let updatedSnapshotId: string | undefined;
+        try {
+          updatedSnapshotId = (await fileSnap(absolutePath)).snapshotId;
+        } catch (error) {
+          console.error("Failed to compute post-edit snapshot:", error);
+        }
 
         const editMeta: RMeta = {
           editsAttempted,

package/src/validation.ts

@@ -19,6 +19,9 @@ export async function valAccess(
 			const accessLabel = accessMode & constants.W_OK ? "not writable" : "not readable";
 			throw new Error(`[E_ACCESS] File is ${accessLabel}: ${path}`);
 		}
+		if (code === "ELOOP") {
+			throw new Error(`[E_ACCESS] Too many symbolic links while resolving: ${path}`);
+		}
 		throw new Error(`[E_ACCESS] Cannot access file: ${path}`);
 	}
 }