pi-hashline-edit-pro 4.2.8 → 4.2.10

package/README.md

@@ -199,7 +199,7 @@ The table is curated for tokenizers, not for humans. Every anchor is the concate
 
 Each line also carries a content checksum. The line is canonicalized (carriage returns stripped, trailing whitespace trimmed) and hashed with [xxhash-wasm](https://github.com/jungomi/xxhash-wasm). The canonicalization keeps the checksum stable across editor-save cycles that add or remove trailing whitespace. A line over 500 bytes is hashed from its first 500 bytes.
 
-Allocated anchors live in a persistent per-file snapshot (`~/.config/pi-hashline-edit-pro/hash-store.sqlite`) keyed by content checksum, so resume-after-restart and cross-session edits reuse ownership instead of minting duplicates. Each session also appends an ownership log (`allocate`/`free`/`clear` events) to a sidecar file under `~/.config/pi-hashline-edit-pro/sessions/`; the fold of that log is the session's source of truth, sidecars whose session file is gone are garbage-collected at startup, and the in-memory ownership of a session is released when that session shuts down and rebuilt from its sidecar on next use.
+Allocated anchors live in a persistent per-file snapshot (`~/.config/pi-hashline-edit-pro/hash-store.sqlite`) keyed by content checksum, so resume-after-restart and cross-session edits reuse ownership instead of minting duplicates. Each session also appends an ownership log (`allocate`/`free`/`clear` events) to a sidecar file under `~/.config/pi-hashline-edit-pro/sessions/`; the fold of that log is the session's source of truth, sidecars whose session file is gone are garbage-collected at startup (never the sidecar of a session that is currently loaded in this process), and the in-memory ownership of a session is released when that session shuts down and rebuilt from its sidecar on next use.
 
 When a range is edited, the mapping between old and new content is computed per span: lines whose content is unchanged keep their allocated anchors, anchors of removed lines are freed, and every genuinely new line is minted a fresh anchor. Anchors are never assigned by matching content; only positional survival across an edit preserves one.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "4.2.8",
+  "version": "4.2.10",
   "type": "module",
   "description": "Hash-anchored read/replace/insert/grep tools for pi-coding-agent. Every line gets a unique 4-char tokenizer-friendly anchor that stays stable across edits; stale or ambiguous anchors are rejected, never fuzzy-matched. Undo persists across restarts.",
   "main": "index.ts",

package/src/anchor-registry.ts

@@ -1,5 +1,5 @@
 import { chmod, mkdir, open, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
-import { appendFileSync, chmodSync } from "node:fs";
+import { appendFileSync, chmodSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { createHash } from "node:crypto";
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -158,11 +158,12 @@ interface SessionState {
 const SIDECAR_SUFFIX = ".registry.jsonl";
 const SIDECAR_COMPACT_LINES = 5000;
 const SIDECAR_COMPACT_BYTES = 1024 * 1024;
-const SIDECAR_COMPACT_CHUNK = 5000;
+export const SIDECAR_COMPACT_LINE_BYTES = 48 * 1024;
 export const SIDECAR_HEADER_BYTES = 64 * 1024;
 const SIDECAR_HEADER_CHUNK = 4096;
 let currentKey: string | undefined;
 const sidecarByKey = new Map<string, string>();
+const sessionFileByKey = new Map<string, string>();
 const pendingInits = new Map<string, Promise<void>>();
 const loadTokens = new Map<string, object>();
 const registries = new Map<string, SessionState>();
@@ -247,6 +248,45 @@ export function shouldCompactSidecar(raw: string): boolean {
   for (let i = 0; i < raw.length; i++) if (raw.charCodeAt(i) === 10) lines += 1;
   return lines >= SIDECAR_COMPACT_LINES;
 }
+
+function parseSessionFileLine(line: string): string | undefined {
+  const trimmed = line.trim();
+  if (trimmed.length === 0) return undefined;
+  try {
+    const event = JSON.parse(trimmed) as { kind?: unknown; sessionFile?: unknown };
+    if (event.kind === "session" && typeof event.sessionFile === "string" && event.sessionFile.length > 0) return event.sessionFile;
+  } catch {
+  }
+  return undefined;
+}
+
+function firstLineSessionFile(raw: string): string | undefined {
+  const newline = raw.indexOf("\n");
+  return parseSessionFileLine(newline >= 0 ? raw.slice(0, newline) : raw);
+}
+
+function chunkBySerializedBytes<T>(items: T[], wrap: (chunk: T[]) => unknown, maxBytes: number): T[][] {
+  const chunks: T[][] = [];
+  if (items.length === 0) return chunks;
+  const overhead = Buffer.byteLength(JSON.stringify(wrap([])), "utf-8");
+  let chunk: T[] = [];
+  let bytes = overhead;
+  for (const item of items) {
+    const itemBytes = Buffer.byteLength(JSON.stringify(item), "utf-8");
+    const nextBytes = bytes + itemBytes + (chunk.length > 0 ? 1 : 0);
+    if (chunk.length > 0 && nextBytes > maxBytes) {
+      chunks.push(chunk);
+      chunk = [item];
+      bytes = overhead + itemBytes;
+    } else {
+      chunk.push(item);
+      bytes = nextBytes;
+    }
+  }
+  chunks.push(chunk);
+  return chunks;
+}
+
 export function buildCompactedLog(sessionFile: string, state: SessionState): string {
   const byPath = new Map<string, Array<[string, string]>>();
   for (const [anchor, entry] of state.owned) {
@@ -256,18 +296,18 @@ export function buildCompactedLog(sessionFile: string, state: SessionState): str
   }
   const out: string[] = [JSON.stringify({ kind: "session", sessionFile })];
   for (const [path, rows] of byPath) {
-    for (let i = 0; i < rows.length; i += SIDECAR_COMPACT_CHUNK) {
-      out.push(JSON.stringify({ kind: "allocate", path, rows: rows.slice(i, i + SIDECAR_COMPACT_CHUNK) }));
+    for (const chunk of chunkBySerializedBytes(rows, (part) => ({ kind: "allocate", path, rows: part }), SIDECAR_COMPACT_LINE_BYTES)) {
+      out.push(JSON.stringify({ kind: "allocate", path, rows: chunk }));
     }
   }
   const freedHistory = [...state.everMinted].filter((anchor) => !state.owned.has(anchor));
-  for (let i = 0; i < freedHistory.length; i += SIDECAR_COMPACT_CHUNK) {
-    out.push(JSON.stringify({ kind: "minted", anchors: freedHistory.slice(i, i + SIDECAR_COMPACT_CHUNK) }));
+  for (const chunk of chunkBySerializedBytes(freedHistory, (part) => ({ kind: "minted", anchors: part }), SIDECAR_COMPACT_LINE_BYTES)) {
+    out.push(JSON.stringify({ kind: "minted", anchors: chunk }));
   }
   return out.join("\n") + "\n";
 }
-async function compactSidecarIfNeeded(sidecar: string, raw: string, sessionFile: string, state: SessionState): Promise<void> {
-  if (!shouldCompactSidecar(raw)) return;
+async function compactSidecarIfNeeded(sidecar: string, raw: string, sessionFile: string, state: SessionState, force = false): Promise<void> {
+  if (!force && !shouldCompactSidecar(raw)) return;
   const tmp = `${sidecar}.compact-${Date.now()}-${Math.random().toString(36).slice(2)}`;
   try {
     const compacted = buildCompactedLog(sessionFile, state);
@@ -300,7 +340,7 @@ async function loadRegistryState(key: string, sessionFile: string, token: object
   registries.set(key, folded);
   sidecarByKey.set(key, sidecar);
   if (rawLog.length > 0) {
-    await compactSidecarIfNeeded(sidecar, rawLog, sessionFile, folded);
+    await compactSidecarIfNeeded(sidecar, rawLog, sessionFile, folded, firstLineSessionFile(rawLog) !== sessionFile);
   }
   try {
     await mkdir(sessionClaimsDir(), { recursive: true, mode: 0o700 });
@@ -329,6 +369,7 @@ async function ensureRegistryForKey(key: string, sessionFile: string | undefined
       registries.set(key, newSessionState(key));
       return;
     }
+    sessionFileByKey.set(key, sessionFile);
     await loadRegistryState(key, sessionFile, token);
   })();
   pendingInits.set(key, promise);
@@ -384,12 +425,27 @@ function current(): SessionState | undefined {
   return registries.get(key);
 }
 
+function sidecarNeedsSessionRecord(sidecar: string): boolean {
+  try {
+    return statSync(sidecar).size === 0;
+  } catch {
+    return true;
+  }
+}
+
+function ensureSidecarSessionRecord(key: string, sidecar: string): void {
+  const sessionFile = sessionFileByKey.get(key);
+  if (sessionFile === undefined || !sidecarNeedsSessionRecord(sidecar)) return;
+  appendEvent({ kind: "session", sessionFile } satisfies RegistryEvent);
+}
+
 function appendEvent(event: RegistryEvent): void {
   const key = activeKey();
   if (!key) return;
   const sidecar = sidecarByKey.get(key);
   if (!sidecar) return;
   try {
+    if (event.kind !== "session") ensureSidecarSessionRecord(key, sidecar);
     appendFileSync(sidecar, JSON.stringify(event) + "\n", "utf-8");
     if (process.platform !== "win32") {
       try { chmodSync(sidecar, 0o600); } catch (error) { if (errCode(error) !== "ENOENT") console.error("Failed to secure anchor registry sidecar:", error); }
@@ -841,12 +897,13 @@ export function adoptAnchors(path: string, entries: Map<string, string>): void {
 export function resetRegistryForTests(): void {
   currentKey = undefined;
   sidecarByKey.clear();
+  sessionFileByKey.clear();
   pendingInits.clear();
   loadTokens.clear();
   registries.clear();
 }
 
-export async function readSidecarHeader(sidecar: string): Promise<string> {
+async function readSidecarWindow(sidecar: string): Promise<{ text: string; filled: boolean }> {
   const handle = await open(sidecar, "r");
   const buffer = Buffer.alloc(SIDECAR_HEADER_BYTES);
   try {
@@ -855,24 +912,47 @@ export async function readSidecarHeader(sidecar: string): Promise<string> {
       const { bytesRead } = await handle.read(buffer, readBytes, Math.min(SIDECAR_HEADER_CHUNK, buffer.length - readBytes), readBytes);
       if (bytesRead === 0) break;
       readBytes += bytesRead;
-      const text = buffer.subarray(0, readBytes).toString("utf-8");
-      const newline = text.indexOf("\n");
-      if (newline >= 0) return text.slice(0, newline);
     }
-    return readBytes === buffer.length ? "" : buffer.subarray(0, readBytes).toString("utf-8");
+    return { text: buffer.subarray(0, readBytes).toString("utf-8"), filled: readBytes === buffer.length };
   } finally {
     await handle.close();
   }
 }
 
+export async function readSidecarHeader(sidecar: string): Promise<string> {
+  const { text, filled } = await readSidecarWindow(sidecar);
+  const newline = text.indexOf("\n");
+  if (newline >= 0) return text.slice(0, newline);
+  return filled ? "" : text;
+}
+
+export async function readSidecarSessionFile(sidecar: string): Promise<string | undefined> {
+  const { text } = await readSidecarWindow(sidecar);
+  const lastNewline = text.lastIndexOf("\n");
+  const complete = lastNewline >= 0 ? text.slice(0, lastNewline).split("\n") : [];
+  for (const line of complete) {
+    const sessionFile = parseSessionFileLine(line);
+    if (sessionFile !== undefined) return sessionFile;
+  }
+  return parseSessionFileLine(lastNewline >= 0 ? text.slice(lastNewline + 1) : text);
+}
+
 export function releaseRegistrySession(key: string): void {
   loadTokens.delete(key);
   if (currentKey === key) currentKey = undefined;
   pendingInits.delete(key);
   sidecarByKey.delete(key);
+  sessionFileByKey.delete(key);
   registries.delete(key);
 }
 
+function isClaimedSidecar(sidecar: string): boolean {
+  for (const claimed of sidecarByKey.values()) {
+    if (claimed === sidecar) return true;
+  }
+  return false;
+}
+
 export async function gcRegistrySidecars(): Promise<void> {
   let names: string[];
   try {
@@ -894,10 +974,11 @@ export async function gcRegistrySidecars(): Promise<void> {
     }
     if (!name.endsWith(SIDECAR_SUFFIX)) continue;
     const sidecar = join(sessionClaimsDir(), name);
+    if (isClaimedSidecar(sidecar)) continue;
     try {
-      const header = JSON.parse(await readSidecarHeader(sidecar) || "{}") as { kind?: string; sessionFile?: string };
-      if (header.kind !== "session" || !header.sessionFile) continue;
-      await stat(header.sessionFile);
+      const sessionFile = await readSidecarSessionFile(sidecar);
+      if (sessionFile === undefined) continue;
+      await stat(sessionFile);
     } catch (error) {
       if (errCode(error) === "ENOENT") {
         await rm(sidecar, { force: true });

package/src/fs-write.ts

@@ -152,6 +152,7 @@ export async function writeAtomic(
   path: string,
   content: string,
   expectedIdentity?: FileIdentity,
+  restoreMode?: number,
 ): Promise<void> {
   const targetPath = await resolveTarget(path);
 
@@ -193,8 +194,9 @@ export async function writeAtomic(
   const tempHandle = await open(tempPath, "wx", 0o600);
   try {
     await tempHandle.writeFile(content, "utf-8");
-    if (existingStats) {
-      await tempHandle.chmod(existingStats.mode & 0o7777);
+    const mode = existingStats ? existingStats.mode & 0o7777 : restoreMode;
+    if (mode !== undefined) {
+      await tempHandle.chmod(mode);
     }
     await tempHandle.sync();
   } catch (error: unknown) {

package/src/hash-store/retry.ts

@@ -37,7 +37,7 @@ export async function withBusyRetryAsync<T>(fn: () => T): Promise<T> {
   throw lastError;
 }
 
-export function retriedWrite(stmt: { run(...params: (string | number)[]): unknown }): (...params: (string | number)[]) => void {
+export function retriedWrite(stmt: { run(...params: (string | number | null)[]): unknown }): (...params: (string | number | null)[]) => void {
   return (...params) => {
     withBusyRetry(() => { stmt.run(...params); });
   };

package/src/hash-store.ts

@@ -26,7 +26,7 @@ export { isValidHashList, isValidServedMap, parseHashList, parseServedMap, parse
 export { SNAPSHOT_CACHE_LIMIT };
 export const STORE_NOT_OPEN_MESSAGE = "Hash store is not open; transactional update aborted";
 
-type SqlParams = (string | number)[];
+type SqlParams = (string | number | null)[];
 
 interface RawStatement {
   get(...params: SqlParams): unknown;
@@ -140,6 +140,7 @@ export interface UndoRecord {
   ending: string;
   hashes: string[];
   resultContent: string;
+  mode?: number;
 }
 
 let cachedDb: { path: string; db: RawDb; stmts: Prepared } | null = null;
@@ -190,6 +191,9 @@ function buildStore(db: RawDb): { db: RawDb; stmts: Prepared } {
   try {
     db.exec("ALTER TABLE snapshots ADD COLUMN line_checksums TEXT");
   } catch {}
+  try {
+    db.exec("ALTER TABLE undo ADD COLUMN mode INTEGER");
+  } catch {}
   const versionRow = db.prepare("SELECT value FROM meta WHERE key = 'version'").get() as { value?: string } | undefined;
   if (versionRow && versionRow.value !== String(HASH_STORE_VERSION)) {
     db.exec("DELETE FROM snapshots");
@@ -209,11 +213,11 @@ function buildStore(db: RawDb): { db: RawDb; stmts: Prepared } {
     "ON CONFLICT(path) DO UPDATE SET checksum = excluded.checksum, line_count = excluded.line_count, hashes = excluded.hashes, line_checksums = excluded.line_checksums, updated_at = excluded.updated_at"
   );
   const undoUpsertStmt = db.prepare(
-    "INSERT INTO undo (path, content, bom, ending, hashes, result_content, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?) " +
-    "ON CONFLICT(path) DO UPDATE SET content = excluded.content, bom = excluded.bom, ending = excluded.ending, hashes = excluded.hashes, result_content = excluded.result_content, updated_at = excluded.updated_at"
+    "INSERT INTO undo (path, content, bom, ending, hashes, result_content, mode, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?) " +
+    "ON CONFLICT(path) DO UPDATE SET content = excluded.content, bom = excluded.bom, ending = excluded.ending, hashes = excluded.hashes, result_content = excluded.result_content, mode = excluded.mode, updated_at = excluded.updated_at"
   );
   const undoGetStmt = db.prepare(
-    "SELECT content, bom, ending, hashes, result_content FROM undo WHERE path = ?"
+    "SELECT content, bom, ending, hashes, result_content, mode FROM undo WHERE path = ?"
   );
   const undoDelStmt = db.prepare("DELETE FROM undo WHERE path = ?");
   const snapshotTimeStmt = db.prepare("SELECT updated_at FROM snapshots WHERE path = ?");
@@ -533,6 +537,7 @@ export function upsertUndo(store: HashStore, path: string, entry: UndoRecord): v
     entry.ending,
     JSON.stringify(entry.hashes),
     entry.resultContent,
+    typeof entry.mode === "number" ? entry.mode : null,
     Date.now(),
   );
   touchSession(path);
@@ -549,6 +554,7 @@ export function getUndoEntry(store: HashStore, path: string): UndoRecord | undef
     ending: row.ending as string,
     hashes: parsed,
     resultContent: row.result_content as string,
+    ...(typeof row.mode === "number" ? { mode: row.mode } : {}),
   };
 }
 

package/src/replace-undo.ts

@@ -1,5 +1,5 @@
 import { constants } from "node:fs";
-import { open } from "node:fs/promises";
+import { open, stat } from "node:fs/promises";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
@@ -24,6 +24,7 @@ export interface UndoEntry {
   originalEnding: LineEnding;
   hashes: string[];
   resultContent: string;
+  mode?: number;
 }
 
 export async function saveUndo(
@@ -34,12 +35,18 @@ export async function saveUndo(
   try {
     const store = await loadHashStore();
     previous = getUndoEntry(store, path);
+    let mode: number | undefined;
+    try {
+      mode = (await stat(path)).mode & 0o7777;
+    } catch {
+    }
     upsertUndo(store, path, {
       content: entry.content,
       bom: entry.bom,
       ending: entry.originalEnding,
       hashes: entry.hashes,
       resultContent: entry.resultContent,
+      ...(mode !== undefined ? { mode } : {}),
     });
   } catch (error) {
     console.error("Failed to persist undo entry:", error);
@@ -75,6 +82,7 @@ export async function getUndo(path: string): Promise<UndoEntry | undefined> {
       originalEnding,
       hashes: record.hashes,
       resultContent: record.resultContent,
+      ...(record.mode !== undefined ? { mode: record.mode } : {}),
     };
   } catch (error) {
     console.error("Failed to load undo entry:", error);
@@ -91,6 +99,10 @@ export async function clearUndo(path: string): Promise<void> {
   }
 }
 
+function fallbackFileMode(): number {
+  return 0o666 & ~process.umask();
+}
+
 export function regUndo(pi: ExtensionAPI): void {
   pi.registerTool({
     name: "undo_last_change",
@@ -172,6 +184,7 @@ export function regUndo(pi: ExtensionAPI): void {
             mutationTargetPath,
             undo.bom + restoreEndings(undo.content, undo.originalEnding),
             currentIdentity,
+            undo.mode ?? fallbackFileMode(),
           );
 
           const currentNormalized = currentRaw === undefined ? "" : toLF(stripBOM(currentRaw).text);