pi-hashline-edit-pro 4.2.7 → 4.2.9

package/package.json

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

@@ -152,13 +152,14 @@ interface SessionState {
 	served: Map<string, Map<string, string>>;
 	everMinted: AnchorMintedSet;
 	probe: number;
+	allocatedChecksum: Map<string, string>;
 }
 
 const SIDECAR_SUFFIX = ".registry.jsonl";
 const SIDECAR_COMPACT_LINES = 5000;
 const SIDECAR_COMPACT_BYTES = 1024 * 1024;
-const SIDECAR_COMPACT_CHUNK = 5000;
-const SIDECAR_HEADER_BYTES = 64 * 1024;
+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>();
@@ -174,7 +175,7 @@ function newSessionState(seed?: string): SessionState {
 			probe = (probe * 256 + byte) % ANCHOR_COUNT;
 		}
 	}
-	return { owned: new Map(), served: new Map(), everMinted: new Set(), probe };
+	return { owned: new Map(), served: new Map(), everMinted: new Set(), probe, allocatedChecksum: new Map() };
 }
 
 function seedServedFromOwned(state: SessionState): void {
@@ -246,6 +247,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) {
@@ -255,18 +295,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);
@@ -299,7 +339,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 });
@@ -476,6 +516,7 @@ export function clearRegistry(): void {
 	if (!state) return;
 	state.owned.clear();
 	state.served.clear();
+	state.allocatedChecksum.clear();
 	appendEvent({ kind: "clear" });
 }
 
@@ -532,6 +573,7 @@ export function shadowStateFrom(state: SessionState): SessionState {
 		served: new Map(),
 		everMinted: new ShadowMintedSet(state.everMinted),
 		probe: state.probe,
+		allocatedChecksum: state.allocatedChecksum,
 	};
 }
 
@@ -743,6 +785,11 @@ export function alignOwnership(
   return { anchors, freed: freed.map((f) => f.anchor), minted: minted.map((m) => m.anchor) };
 }
 
+function snapshotMatchesAllocation(state: SessionState | undefined, path: string, checksum: string): boolean {
+  const allocated = state?.allocatedChecksum.get(path);
+  return allocated === undefined || allocated === checksum;
+}
+
 export async function allocateFileAnchors(
   store: HashStore,
   path: string,
@@ -754,12 +801,14 @@ export async function allocateFileAnchors(
   },
 ): Promise<string[]> {
   ensureRegistry();
+  const registry = current();
   const shadow = options?.shadow === true;
   const lines = splitLines(content);
   const checksums = lines.map((line) => contentChecksum(hashSource(line)));
   if (options?.previous?.spans) {
     const prevChecksums = splitLines(options.previous.content).map((line) => contentChecksum(hashSource(line)));
     const aligned = alignOwnershipWithSpans(path, options.previous.hashes, prevChecksums, checksums, options.previous.spans, { shadow });
+    if (!shadow && registry) registry.allocatedChecksum.set(path, contentChecksum(content));
     if (!shadow && options.persist !== false) {
       persistSnapshot(store, path, content, aligned.anchors, checksums);
     }
@@ -772,7 +821,7 @@ export async function allocateFileAnchors(
     prevChecksums = splitLines(options.previous.content).map((line) => contentChecksum(hashSource(line)));
   } else {
     const previousState = getAllocatedState(store, path, !shadow);
-    if (previousState) {
+    if (previousState && snapshotMatchesAllocation(registry, path, previousState.contentChecksum)) {
       prevAnchors = previousState.anchors;
       prevChecksums = previousState.checksums;
       if (!prevChecksums && previousState.contentChecksum === contentChecksum(content)) {
@@ -800,6 +849,7 @@ export async function allocateFileAnchors(
         }
         return { anchors, freed: [], minted: anchors };
       })();
+  if (!shadow && registry) registry.allocatedChecksum.set(path, contentChecksum(content));
   if (!shadow && options?.persist !== false) {
     persistSnapshot(store, path, content, aligned.anchors, checksums);
   }
@@ -835,7 +885,7 @@ export function resetRegistryForTests(): void {
   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 {
@@ -844,16 +894,31 @@ 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 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;
@@ -884,9 +949,9 @@ export async function gcRegistrySidecars(): Promise<void> {
     if (!name.endsWith(SIDECAR_SUFFIX)) continue;
     const sidecar = join(sessionClaimsDir(), name);
     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);