pi-hashline-edit-pro 2.5.0 → 2.5.2

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.
@@ -63,12 +65,12 @@ Lines up to 200KB are shown in full. Larger lines are replaced by a marker with
 
 Edge cases:
 
-- Images (JPEG, PNG, GIF, WebP) come back as visual attachments.
-- Binary files and directories are rejected with a descriptive error.
+- Images (JPEG, PNG, GIF, WebP, BMP) come back as visual attachments. Other image formats (for example AVIF, HEIC/HEIF, TIFF, ICO, JPEG 2000, JPEG XL, PSD, APNG) are rejected as binary, since the built-in renderer cannot attach them.
+- Binary files and directories are rejected with a descriptive error. A magic-signature match is ignored when the sampled bytes contain no NUL bytes and decode as UTF-8, so a text file whose first bytes happen to match a binary or image signature (for example starting with `BM` or `8BPS`) is still read as text.
 - 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
 
@@ -114,7 +116,6 @@ Notes:
 
 Enabled by default. After a successful `write` that changes the file, the extension reads the file and appends an `--- Auto-read (hashline anchors) ---` block to the result, so you get fresh `HASH│content` anchors without a separate `read` call.
 
-- After `replace` and `undo_last_replace`, the result shows the post-edit diff. The `+HASH│` and ` HASH│` rows carry the current hashes, so follow-up edits can anchor on the diff directly. Call `read` when you want the full file's anchors.
 - After `replace` and `undo_last_replace`, the result shows the post-edit diff. The `+HASH│` and ` HASH│` rows carry the current hashes, so follow-up edits can anchor on the diff directly. The `-HASH│` rows show removed lines with their old hashes, so you can see exactly which anchors were deleted (those hashes are stale after the edit). Call `read` when you want the full file's anchors.
 - 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.
@@ -170,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/package.json

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

package/src/file-kind.ts

@@ -3,9 +3,10 @@ import { fileTypeFromBuffer } from "file-type";
 import { SNIFF_BYTES, MAX_BYTES } from "./constants";
 
 const IMG_TYPES = new Set<string>([
+  "image/bmp",
+  "image/gif",
   "image/jpeg",
   "image/png",
-  "image/gif",
   "image/webp",
 ]);
 
@@ -39,11 +40,22 @@ function isTextType(mimeType: string): boolean {
   return mimeType.startsWith("text/") || TEXT_TYPES.has(mimeType);
 }
 
+function looksLikeText(sample: Uint8Array): boolean {
+  if (sample.includes(0)) return false;
+  try {
+    new TextDecoder("utf-8", { fatal: true }).decode(sample);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 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 {
@@ -67,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`,
     };
   }
 
@@ -96,7 +108,8 @@ export async function loadFileKindAndText(
     const detectedMimeType = (await fileTypeFromBuffer(sample))?.mime;
     if (
       detectedMimeType !== undefined &&
-      !isTextType(detectedMimeType)
+      !isTextType(detectedMimeType) &&
+      !looksLikeText(sample)
     ) {
       if (IMG_TYPES.has(detectedMimeType)) {
         return { kind: "image", mimeType: detectedMimeType };

package/src/hash-store.ts

@@ -2,7 +2,7 @@ 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, splitLines } from "./utils";
+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";
@@ -45,9 +45,25 @@ export function isValidHashList(value: unknown): value is string[] {
   for (const hash of value) {
     if (typeof hash !== "string" || !HASH_RE.test(hash)) return false;
   }
+  if (new Set(value).size !== value.length) return false;
   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>;
@@ -107,6 +123,13 @@ function openDbWithBusyRetry(storePath: string): { db: DatabaseSync; stmts: Prep
 let cachedDb: { path: string; db: DatabaseSync; stmts: Prepared } | null = null;
 let opening: { path: string; promise: Promise<HashStore> } | null = null;
 let exitHandlerRegistered = false;
+interface SnapshotCacheEntry {
+  checksum: string;
+  lineCount: number;
+  hashes: string[];
+}
+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,
@@ -301,6 +324,7 @@ export function shutdownHashStore(): void {
     shutdownDb(cachedDb.db);
     cachedDb = null;
   }
+  snapshotCache.clear();
 }
 
 function withStore(fn: () => void): void {
@@ -344,11 +368,17 @@ async function migrateLegacy(db: DatabaseSync): Promise<void> {
 
   const rows: [string, string, number, string, number][] = [];
   for (const [key, value] of Object.entries(raw)) {
-    if (!isValidSnapshot(value)) continue;
-    if (new Set(value.hashes).size !== value.hashes.length) {
-      console.warn(`Skipped legacy snapshot with duplicate hashes for ${key}; it will be re-hashed on next read.`);
+    if (
+      isRec(value) &&
+      Array.isArray(value.hashes) &&
+      new Set(value.hashes).size !== value.hashes.length
+    ) {
+      console.warn(
+        `Skipped legacy snapshot with duplicate hashes for ${key}; it will be re-hashed on next read.`,
+      );
       continue;
     }
+    if (!isValidSnapshot(value)) continue;
     rows.push([
       key,
       contentChecksum(value.content),
@@ -378,6 +408,15 @@ async function migrateLegacy(db: DatabaseSync): Promise<void> {
   }
 }
 
+function cacheSnapshot(path: string, checksum: string, lineCount: number, hashes: string[]): void {
+  snapshotCache.delete(path);
+  snapshotCache.set(path, { checksum, lineCount, hashes: hashes.slice() });
+  if (snapshotCache.size > SNAPSHOT_CACHE_LIMIT) {
+    const oldest = snapshotCache.keys().next().value;
+    if (oldest !== undefined) snapshotCache.delete(oldest);
+  }
+}
+
 export function getSnapshot(
   store: HashStore,
   path: string,
@@ -386,17 +425,21 @@ export function getSnapshot(
 ): string[] | undefined {
   const checksum = contentChecksum(content);
   const lineCount = splitLines(content).length;
+  const cached = snapshotCache.get(path);
+  if (cached && cached.checksum === checksum && cached.lineCount === lineCount) {
+    snapshotCache.delete(path);
+    snapshotCache.set(path, cached);
+    return cached.hashes.slice();
+  }
   const row = store.stmts.get(path, checksum, lineCount);
   if (!row) return undefined;
-  try {
-    const parsed = JSON.parse(row.hashes as string);
-    if (isValidHashList(parsed)) return parsed;
-    if (deleteCorrupt) store.stmts.deleteOne(path);
-    return undefined;
-  } catch {
+  const parsed = parseHashList(row.hashes as string, () => {
     if (deleteCorrupt) store.stmts.deleteOne(path);
-    return undefined;
-  }
+    snapshotCache.delete(path);
+  });
+  if (!parsed) return undefined;
+  cacheSnapshot(path, checksum, lineCount, parsed);
+  return parsed;
 }
 
 export function upsertSnapshot(
@@ -407,6 +450,7 @@ export function upsertSnapshot(
   hashes: string[],
 ): void {
   store.stmts.upsert(path, checksum, lineCount, JSON.stringify(hashes), Date.now());
+  cacheSnapshot(path, checksum, lineCount, hashes);
 }
 
 export function upsertUndo(store: HashStore, path: string, entry: UndoRecord): void {
@@ -424,23 +468,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 {
@@ -477,6 +513,7 @@ export async function pruneMissing(store: HashStore): Promise<void> {
   withStore(() => {
     for (const path of missing) {
       store.stmts.deleteOne(path);
+      snapshotCache.delete(path);
       store.stmts.undoDelete(path);
       store.stmts.servedDelete(path);
     }

package/src/replace-diff.ts

@@ -96,6 +96,7 @@ export function genDiff(
       let linesToShow: (string | symbol)[] = displayLines;
       let skipStart = 0;
       let skipMiddle = 0;
+      let skipTail = 0;
 
       if (!lastWasChange) {
         skipStart = Math.max(0, displayLines.length - contextLines);
@@ -104,8 +105,9 @@ export function genDiff(
         const tail = displayLines.slice(-contextLines);
         linesToShow = [...displayLines.slice(0, contextLines), ELLIPSIS_MARKER, ...tail];
         skipMiddle = displayLines.length - contextLines * 2;
-      } else if (linesToShow.length > contextLines) {
+      } else if (!nextPartIsChange && linesToShow.length > contextLines) {
         linesToShow = linesToShow.slice(0, contextLines);
+        skipTail = displayLines.length - contextLines;
       }
 
       if (skipStart > 0) {
@@ -125,6 +127,9 @@ export function genDiff(
         newLineNum++;
         oldLineNum++;
       }
+      if (skipTail > 0) {
+        output.push(" ...");
+      }
     } else {
       newLineNum += displayLines.length;
       oldLineNum += displayLines.length;

package/src/served.ts

@@ -1,5 +1,5 @@
 import type { HashStore } from "./hash-store";
-import { isValidHashList } from "./hash-store";
+import { parseHashList } from "./hash-store";
 import { HASH_CLASS } from "./hashline/alphabet";
 
 const SERVED_DIFF_ROW_RE = new RegExp(`^[+ ](${HASH_CLASS})│`);
@@ -16,17 +16,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 {

package/src/utils.ts

@@ -16,9 +16,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.`,
+		);
+	}
 }