pi-hashline-edit-pro 2.5.1 → 2.5.3

package/README.md

@@ -1,5 +1,7 @@
 # pi-hashline-edit-pro
 
+[![npm version](https://img.shields.io/npm/v/pi-hashline-edit-pro.svg)](https://www.npmjs.com/package/pi-hashline-edit-pro) [![npm downloads](https://img.shields.io/npm/dm/pi-hashline-edit-pro.svg)](https://www.npmjs.com/package/pi-hashline-edit-pro)
+
 Hash-anchored `read` and `replace` tools for [pi-coding-agent](https://github.com/badlogic/pi-mono/tree/main/packages/coding-agent). Every line of a file gets a unique 3-character hash, and you edit by hash. No line numbers, no fuzzy matching, no edits landing on the wrong line.
 
 Fork of [pi-hashline-edit](https://github.com/RimuruW/pi-hashline-edit) by RimuruW, extended with 3-character hashes and collision resolution.
@@ -68,7 +70,7 @@ Edge cases:
 - UTF-16 and UTF-32 text (detected via BOM) is rejected, since editing it would corrupt the file.
 - Empty files come back 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]`.
+- Files over 238,328 lines or 100MB are rejected with `[E_FILE_TOO_LARGE]`.
 
 ## The replace tool
 
@@ -169,7 +171,7 @@ A no-op replace never changes the file, so anchors remain valid. On first run af
 | `[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_RANGE_STALE]` | A line in the replaced range no longer matches what was last shown (the file changed on disk, or the line was never shown). The edit was refused; the current range is returned with fresh anchors. |
-| `[E_FILE_TOO_LARGE]` | The file exceeds the 238,328-line hashline limit. |
+| `[E_FILE_TOO_LARGE]` | The file exceeds the 238,328-line hashline limit or the 100MB size limit. |
 
 ## Troubleshooting
 

package/index.ts

@@ -13,7 +13,7 @@ import {
   toggleAutoRead,
 } from "./src/config";
 import { loadHashStore, pruneMissing } from "./src/hash-store";
-import { recordServed, clearServed } from "./src/served";
+import { recordServedSafe, clearServed } from "./src/served";
 import { readNormFile } from "./src/file-reader";
 import { loadFileKindAndText } from "./src/file-kind";
 import { toCwd } from "./src/paths";
@@ -88,12 +88,7 @@ export default function (pi: ExtensionAPI): void {
           DEFAULT_MAX_BYTES,
           AUTO_READ_MAX,
         );
-        try {
-          const store = await loadHashStore();
-          recordServed(store, absolutePath, preview.servedHashes);
-        } catch (error) {
-          console.error("Failed to record served state from auto-read:", error);
-        }
+        await recordServedSafe(absolutePath, preview.servedHashes, "auto-read");
         return {
           content: [
             ...(event.content ?? []),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "2.5.1",
+  "version": "2.5.3",
   "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",

package/src/config.ts

@@ -1,6 +1,6 @@
 import { readFile } from "fs/promises";
 import { configPath } from "./paths";
-import { errCode } from "./utils";
+import { errCode, isRec } from "./utils";
 import { writeAtomic } from "./fs-write";
 
 export interface Config {
@@ -12,10 +12,12 @@ const DEFAULT_CONFIG: Config = {
 };
 
 function parseConfig(content: string): Config {
-  const parsed = JSON.parse(content) as Partial<Config>;
-  return {
-    autoRead: parsed.autoRead === true,
-  };
+  const parsed = JSON.parse(content) as unknown;
+  const autoRead = isRec(parsed) ? parsed.autoRead : undefined;
+  if (typeof autoRead !== "boolean") {
+    throw new Error("config.json must be an object with a boolean autoRead field");
+  }
+  return { autoRead };
 }
 
 

package/src/file-kind.ts

@@ -54,7 +54,8 @@ export type LFile =
   | { kind: "directory" }
   | { kind: "image"; mimeType: string }
   | { kind: "text"; text: string; hadUtf8DecodeErrors?: true }
-  | { kind: "binary"; description: string };
+  | { kind: "binary"; description: string }
+  | { kind: "too_large"; description: string };
 
 
 export interface LoadFileOptions {
@@ -78,8 +79,8 @@ export async function loadFileKindAndText(
   }
   if (pathStat.size > MAX_BYTES) {
     return {
-      kind: "binary",
-      description: `file exceeds ${MAX_BYTES} byte limit`
+      kind: "too_large",
+      description: `exceeds the ${MAX_BYTES / (1024 * 1024)}MB size limit`,
     };
   }
 

package/src/file-reader.ts

@@ -45,6 +45,18 @@ export async function fileSnap(absolutePath: string): Promise<SnapInfo> {
   };
 }
 
+export async function safeSnapId(
+  absolutePath: string,
+  context: string,
+): Promise<string | undefined> {
+  try {
+    return (await fileSnap(absolutePath)).snapshotId;
+  } catch (error) {
+    console.error(`Failed to compute snapshot (${context}):`, error);
+    return undefined;
+  }
+}
+
 export interface ReadNormOptions {
   signal?: AbortSignal;
   accessMode?: number;

package/src/hash-store.ts

@@ -49,6 +49,21 @@ export function isValidHashList(value: unknown): value is string[] {
   return true;
 }
 
+export function parseHashList(raw: string, onInvalid: () => void): string[] | undefined {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    onInvalid();
+    return undefined;
+  }
+  if (!isValidHashList(parsed)) {
+    onInvalid();
+    return undefined;
+  }
+  return parsed;
+}
+
 function isValidSnapshot(value: unknown): value is LegacySnapshot {
   if (typeof value !== "object" || value === null) return false;
   const v = value as Record<string, unknown>;
@@ -271,7 +286,11 @@ async function openStore(storePath: string): Promise<HashStore> {
   const { db, stmts } = opened;
 
   if (!existed) {
-    await migrateLegacy(db);
+    try {
+      await migrateLegacy(db);
+    } catch (error) {
+      console.error("Hash store migration failed; continuing without legacy import:", error);
+    }
   }
   cachedDb = { path: storePath, db, stmts };
 
@@ -313,20 +332,19 @@ export function shutdownHashStore(): void {
 }
 
 function withStore(fn: () => void): void {
-  if (cachedDb) {
-    withBusyRetry(() => {
-      cachedDb!.db.exec("BEGIN IMMEDIATE");
-      try {
-        fn();
-        cachedDb!.db.exec("COMMIT");
-      } catch (e) {
-        try { cachedDb!.db.exec("ROLLBACK"); } catch {}
-        throw e;
-      }
-    });
-  } else {
-    fn();
+  if (!cachedDb) {
+    throw new Error("Hash store is not open; transactional update aborted");
   }
+  withBusyRetry(() => {
+    cachedDb!.db.exec("BEGIN IMMEDIATE");
+    try {
+      fn();
+      cachedDb!.db.exec("COMMIT");
+    } catch (e) {
+      try { cachedDb!.db.exec("ROLLBACK"); } catch {}
+      throw e;
+    }
+  });
 }
 
 async function migrateLegacy(db: DatabaseSync): Promise<void> {
@@ -373,17 +391,19 @@ async function migrateLegacy(db: DatabaseSync): Promise<void> {
     ]);
   }
   if (rows.length > 0) {
-    db.exec("BEGIN IMMEDIATE");
-    try {
-      const stmt = db.prepare(
-        "INSERT OR REPLACE INTO snapshots (path, checksum, line_count, hashes, updated_at) VALUES (?, ?, ?, ?, ?)"
-      );
-      for (const row of rows) stmt.run(...row);
-      db.exec("COMMIT");
-    } catch (e) {
-      db.exec("ROLLBACK");
-      throw e;
-    }
+    withBusyRetry(() => {
+      db.exec("BEGIN IMMEDIATE");
+      try {
+        const stmt = db.prepare(
+          "INSERT OR REPLACE INTO snapshots (path, checksum, line_count, hashes, updated_at) VALUES (?, ?, ?, ?, ?)"
+        );
+        for (const row of rows) stmt.run(...row);
+        db.exec("COMMIT");
+      } catch (e) {
+        try { db.exec("ROLLBACK"); } catch {}
+        throw e;
+      }
+    });
   }
 
   try {
@@ -418,21 +438,13 @@ export function getSnapshot(
   }
   const row = store.stmts.get(path, checksum, lineCount);
   if (!row) return undefined;
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(row.hashes as string);
-  } catch {
+  const parsed = parseHashList(row.hashes as string, () => {
     if (deleteCorrupt) store.stmts.deleteOne(path);
     snapshotCache.delete(path);
-    return undefined;
-  }
-  if (isValidHashList(parsed)) {
-    cacheSnapshot(path, checksum, lineCount, parsed);
-    return parsed;
-  }
-  if (deleteCorrupt) store.stmts.deleteOne(path);
-  snapshotCache.delete(path);
-  return undefined;
+  });
+  if (!parsed) return undefined;
+  cacheSnapshot(path, checksum, lineCount, parsed);
+  return parsed;
 }
 
 export function upsertSnapshot(
@@ -461,23 +473,15 @@ export function upsertUndo(store: HashStore, path: string, entry: UndoRecord): v
 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 (!isValidHashList(parsed)) {
-      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;
-  }
+  const parsed = parseHashList(row.hashes as string, () => store.stmts.undoDelete(path));
+  if (!parsed) return undefined;
+  return {
+    content: row.content as string,
+    bom: row.bom as string,
+    ending: row.ending as string,
+    hashes: parsed,
+    resultContent: row.result_content as string,
+  };
 }
 
 export function deleteUndo(store: HashStore, path: string): void {

package/src/hashline/index.ts

@@ -6,9 +6,6 @@ export {
 	HASH_SPACE,
 	HASH_PROBE_STRIDE,
 	MAX_HASH_LINES,
-	HL_PREFIX_PLUS_RE,
-	HL_PREFIX_MINUS_RE,
-	HL_BARE_PREFIX_RE,
 	lineHashes,
 	_lineHashesPure,
 	initHasher,
@@ -22,7 +19,6 @@ export {
 } from "./parse";
 
 export {
-	type RAnchor,
 	type HEdit,
 	type RHEdit,
 	type HTEdit,
@@ -34,7 +30,6 @@ export {
 	stripBarePrefixes,
 	stripDiffPrefixes,
 	swapReversedRanges,
-	fmtMismatch,
 	findNewEdge,
 	assertRangeServed,
 	RangeStaleError,

package/src/hashline/resolve.ts

@@ -133,14 +133,6 @@ export function fmtMismatchWithHashes(
   return { text: out.join("\n"), hashes };
 }
 
-export function fmtMismatch(
-  mismatches: HMismatch[],
-  fileLines: string[],
-  fileHashes: string[],
-  filePath?: string,
-): string {
-  return fmtMismatchWithHashes(mismatches, fileLines, fileHashes, filePath).text;
-}
 
 const ITEM_KS = new Set(["replacement_text", "remove_from", "remove_to"]);
 

package/src/read.ts

@@ -9,13 +9,11 @@ import {
 import { Type } from "typebox";
 import { MAX_READ_LINE_BYTES } from "./constants";
 import { loadFileKindAndText } from "./file-kind";
-import { readNormFile } from "./file-reader";
+import { readNormFile, safeSnapId } from "./file-reader";
 import { lineHashes, fmtRegion, HASH_SEP, MAX_HASH_LINES } from "./hashline";
 import { toCwd } from "./paths";
-import { abortIf, isRec, normalizeFilePath, visLines } from "./utils";
-import { fileSnap } from "./file-reader";
-import { loadHashStore } from "./hash-store";
-import { recordServed } from "./served";
+import { abortIf, makePrepareArguments, visLines } from "./utils";
+import { recordServedSafe } from "./served";
 import { loadP, loadGuide } from "./prompts";
 import { valAccess } from "./validation";
 
@@ -167,12 +165,7 @@ export function regRead(pi: ExtensionAPI): void {
 		description: R_DESC,
 		promptSnippet: R_SNIPPET,
 		promptGuidelines: readGuide(),
-		prepareArguments: (args: unknown) => {
-			if (!isRec(args)) return args as any;
-			const record = { ...args };
-			normalizeFilePath(record);
-			return record;
-		},
+		prepareArguments: makePrepareArguments(),
 		parameters: Type.Object({
 			path: Type.String({
 				description: "Path to the file to read (relative or absolute)",
@@ -223,18 +216,8 @@ export function regRead(pi: ExtensionAPI): void {
 				fileHashes,
 				resolvedPath,
 			);
-			try {
-				const store = await loadHashStore();
-				recordServed(store, resolvedPath, preview.servedHashes);
-			} catch (error) {
-				console.error("Failed to record served state from read:", error);
-			}
-			let snapshotId: string | undefined;
-			try {
-				snapshotId = (await fileSnap(absolutePath)).snapshotId;
-			} catch (error) {
-				console.error("Failed to compute snapshot for read:", error);
-			}
+			await recordServedSafe(resolvedPath, preview.servedHashes, "read");
+			const snapshotId = await safeSnapId(absolutePath, "read");
 			const previewText =
 				hadUtf8DecodeErrors
 					? `${preview.text}\n\n[Non-UTF-8 bytes shown as U+FFFD; editing rewrites the file as UTF-8.]`

package/src/replace-response.ts

@@ -101,7 +101,7 @@ export function buildNoop(input: NoopInput): TResult {
 		? `Replacement for ${noopEdit.loc} is identical to current content:\n  ${noopEdit.loc}: ${clipLine(noopEdit.currentContent)}`
 		: "The edit produced identical content.";
 
-	const text = `No changes made to ${path}\nClassification: noop\n${noopDetailsText}`;
+	const text = `No changes made to ${path}\nClassification: noop\n${noopDetailsText}${warnBlock(warnings)}`;
 
 	const metrics = buildMetrics({
 		classification: "noop",

package/src/replace-undo.ts

@@ -8,7 +8,7 @@ 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 { cntDiff, splitLines, errCode, isRec, normalizeFilePath } from "./utils";
+import { cntDiff, splitLines, errCode, makePrepareArguments } from "./utils";
 import { loadP, loadGuide } from "./prompts";
 import { buildMetrics } from "./replace-response";
 import { changedRange, lineHashes } from "./hashline";
@@ -92,12 +92,7 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
     description: loadP("../prompts/undo-last-replace.md"),
     promptSnippet: loadP("../prompts/undo-last-replace-snippet.md"),
     promptGuidelines: loadGuide("../prompts/undo-last-replace-guidelines.md"),
-    prepareArguments: (args: unknown) => {
-      if (!isRec(args)) return args as any;
-      const record = { ...args };
-      normalizeFilePath(record);
-      return record;
-    },
+    prepareArguments: makePrepareArguments(),
     parameters: Type.Object({
       path: Type.String({
         description: "Path to the file to undo",

package/src/replace.ts

@@ -11,9 +11,9 @@ import {
   restoreEndings,
   type LineEnding,
 } from "./replace-diff";
-import { readNormFile } from "./file-reader";
+import { readNormFile, safeSnapId } from "./file-reader";
 import { normReq } from "./replace-normalize";
-import { isRec, rejectUnknownFields, abortIf, normalizeFilePath } from "./utils";
+import { isRec, rejectUnknownFields, abortIf, makePrepareArguments } from "./utils";
 import { resolveTarget, writeAtomic } from "./fs-write";
 import { applyEdit,
   lineHashes,
@@ -26,7 +26,6 @@ import { applyEdit,
   type NEdit,
 } from "./hashline";
 import { toCwd } from "./paths";
-import { fileSnap } from "./file-reader";
 import {
   buildChanged,
   buildNoop,
@@ -47,7 +46,7 @@ import {
 import { loadP, loadGuide } from "./prompts";
 import { saveUndo } from "./replace-undo";
 import { loadHashStore, findSnapshotPaths, type HashStore } from "./hash-store";
-import { getServed, recordServed, recordServedDiff } from "./served";
+import { getServed, recordServedSafe, recordServedDiffSafe } from "./served";
 
 const replacementTextSchema = Type.String({
   description:
@@ -249,17 +248,9 @@ export async function execPipeline(
   } catch (error) {
     if (options?.noPersist !== true) {
       if (error instanceof RangeStaleError) {
-        try {
-          recordServed(hashStore, absolutePath, error.rangeHashes);
-        } catch (recordError) {
-          console.error("Failed to record served state from range-stale feedback:", recordError);
-        }
+        await recordServedSafe(absolutePath, error.rangeHashes, "range-stale feedback");
       } else if (error instanceof AnchorMismatchError) {
-        try {
-          recordServed(hashStore, absolutePath, error.feedbackHashes);
-        } catch (recordError) {
-          console.error("Failed to record served state from anchor-mismatch feedback:", recordError);
-        }
+        await recordServedSafe(absolutePath, error.feedbackHashes, "anchor-mismatch feedback");
       }
     }
     throw error;
@@ -361,12 +352,7 @@ export function buildToolDef(): ToolDef {
     parameters,
     promptSnippet: E_SNIPPET,
     promptGuidelines: E_GUIDE,
-    prepareArguments: (args: unknown) => {
-      if (!isRec(args)) return args as any;
-      const record = { ...args };
-      normalizeFilePath(record);
-      return record;
-    },
+    prepareArguments: makePrepareArguments(),
     renderShell: "default",
     renderCall(args, theme, context) {
       const previewInput = getPreviewInput(args);
@@ -512,12 +498,7 @@ export function buildToolDef(): ToolDef {
 
         const editsAttempted = 1;
         if (originalNormalized === result) {
-          let noopSnapshotId: string | undefined;
-          try {
-            noopSnapshotId = (await fileSnap(absolutePath)).snapshotId;
-          } catch (error) {
-            console.error("Failed to compute snapshot for noop edit:", error);
-          }
+          const noopSnapshotId = await safeSnapId(absolutePath, "noop edit");
           return buildNoop({
             path,
             noopEdit,
@@ -561,12 +542,7 @@ export function buildToolDef(): ToolDef {
           await undo.restore();
           throw error;
         }
-        let updatedSnapshotId: string | undefined;
-        try {
-          updatedSnapshotId = (await fileSnap(absolutePath)).snapshotId;
-        } catch (error) {
-          console.error("Failed to compute post-edit snapshot:", error);
-        }
+        const updatedSnapshotId = await safeSnapId(absolutePath, "post-edit");
 
         const editMeta: RMeta = {
           editsAttempted,
@@ -589,12 +565,7 @@ export function buildToolDef(): ToolDef {
         };
         const changed = buildChanged(successInput);
         if (changed.details.diff) {
-          try {
-            const store = await loadHashStore();
-            recordServedDiff(store, mutationTargetPath, changed.details.diff);
-          } catch (error) {
-            console.error("Failed to record served state from post-edit diff:", error);
-          }
+          await recordServedDiffSafe(mutationTargetPath, changed.details.diff, "post-edit diff");
         }
         return changed;
       });

package/src/served.ts

@@ -1,5 +1,4 @@
-import type { HashStore } from "./hash-store";
-import { isValidHashList } from "./hash-store";
+import { loadHashStore, parseHashList, type HashStore } from "./hash-store";
 import { HASH_CLASS } from "./hashline/alphabet";
 
 const SERVED_DIFF_ROW_RE = new RegExp(`^[+ ](${HASH_CLASS})│`);
@@ -16,17 +15,9 @@ export function servedHashesFromDiff(diff: string): string[] {
 export function getServed(store: HashStore, path: string): Set<string> | undefined {
   const row = store.stmts.servedGet(path);
   if (!row) return undefined;
-  try {
-    const parsed = JSON.parse(row.hashes as string);
-    if (!isValidHashList(parsed)) {
-      store.stmts.servedDelete(path);
-      return undefined;
-    }
-    return new Set(parsed);
-  } catch {
-    store.stmts.servedDelete(path);
-    return undefined;
-  }
+  const parsed = parseHashList(row.hashes as string, () => store.stmts.servedDelete(path));
+  if (!parsed) return undefined;
+  return new Set(parsed);
 }
 
 export function recordServed(store: HashStore, path: string, hashes: string[]): void {
@@ -50,3 +41,26 @@ export function recordServedDiff(store: HashStore, path: string, diff: string):
 export function clearServed(store: HashStore, path: string): void {
   store.stmts.servedDelete(path);
 }
+
+export async function recordServedSafe(
+  path: string,
+  hashes: string[],
+  context: string,
+): Promise<void> {
+  if (hashes.length === 0) return;
+  try {
+    const store = await loadHashStore();
+    recordServed(store, path, hashes);
+  } catch (error) {
+    console.error(`Failed to record served state (${context}):`, error);
+  }
+}
+
+export async function recordServedDiffSafe(
+  path: string,
+  diff: string,
+  context: string,
+): Promise<void> {
+  if (!diff) return;
+  await recordServedSafe(path, servedHashesFromDiff(diff), context);
+}

package/src/utils.ts

@@ -9,6 +9,15 @@ export function normalizeFilePath(record: Record<string, unknown>): void {
   }
 }
 
+export function makePrepareArguments(): (args: unknown) => any {
+  return (args) => {
+    if (!isRec(args)) return args;
+    const record = { ...args };
+    normalizeFilePath(record);
+    return record;
+  };
+}
+
 export function splitLines(text: string): string[] {
   if (text.length === 0) return [""];
   const lines = text.split("\n");
@@ -16,9 +25,7 @@ export function splitLines(text: string): string[] {
 }
 
 export function visLines(text: string): string[] {
-  if (text.length === 0) return [];
-  const lines = text.split("\n");
-  return text.endsWith("\n") ? lines.slice(0, -1) : lines;
+  return text.length === 0 ? [] : splitLines(text);
 }
 
 

package/src/validation.ts

@@ -36,5 +36,10 @@ export function valKind(file: LFile, path: string): asserts file is { kind: "tex
 	if (file.kind === "image") {
 		throw new Error(`[E_NOT_TEXT] Path is an image file: ${path}. Hashline edit only supports text files.`);
 	}
+	if (file.kind === "too_large") {
+		throw new Error(
+			`[E_FILE_TOO_LARGE] File is too large: ${path} (${file.description}). Hashline editing targets source-sized files; for very large files use write or a non-line-based approach.`,
+		);
+	}
 }