pi-hashline-edit-pro 2.5.0 → 2.5.1

package/README.md

@@ -63,8 +63,8 @@ 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.
@@ -114,7 +114,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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "2.5.0",
+  "version": "2.5.1",
   "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,6 +40,16 @@ 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 }
@@ -96,7 +107,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,6 +45,7 @@ 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;
 }
 
@@ -107,6 +108,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 +309,7 @@ export function shutdownHashStore(): void {
     shutdownDb(cachedDb.db);
     cachedDb = null;
   }
+  snapshotCache.clear();
 }
 
 function withStore(fn: () => void): void {
@@ -344,11 +353,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 +393,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 +410,29 @@ 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;
+  let parsed: unknown;
   try {
-    const parsed = JSON.parse(row.hashes as string);
-    if (isValidHashList(parsed)) return parsed;
-    if (deleteCorrupt) store.stmts.deleteOne(path);
-    return undefined;
+    parsed = JSON.parse(row.hashes as string);
   } catch {
     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;
 }
 
 export function upsertSnapshot(
@@ -407,6 +443,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 {
@@ -477,6 +514,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;