pi-hashline-edit-pro 2.8.0 → 2.8.2

package/src/replace-undo.ts

@@ -1,12 +1,14 @@
-import { readFile } from "fs/promises";
+import { constants } from "fs";
+import { open } from "fs/promises";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { loadHashStore, persistSnapshot, upsertUndo, getUndoEntry, deleteUndo, type UndoRecord } from "./hash-store";
-import { recordServedDiff } from "./served";
-import { resolveInCwd, writeAtomic } from "./fs-write";
-import { toLF, stripBOM, genDiff, genPatch, restoreEndings, type LineEnding } from "./replace-diff";
-import { cntDiff, errCode, makePrepareArguments } from "./utils";
+import { recordServed, buildServedMap, servedHashesFromDiff } from "./served";
+import { resolveInCwd, writeAtomic, type FileIdentity } from "./fs-write";
+import { toLF, stripBOM, restoreEndings, type LineEnding } from "./normalize";
+import { genDiff, genPatch } from "./replace-diff";
+import { cntDiff, errCode, makePrepareArguments, splitLines } from "./utils";
 import { loadP, loadGuide } from "./prompts";
 import { buildMetrics } from "./replace-response";
 import { renderEditResult } from "./replace-render";
@@ -121,8 +123,17 @@ export function regUndo(pi: ExtensionAPI): void {
 
       return withFileMutationQueue(mutationTargetPath, async () => {
         let currentRaw: string | undefined;
+        let currentIdentity: FileIdentity | undefined;
         try {
-          currentRaw = await readFile(mutationTargetPath, "utf-8");
+          const noFollow = process.platform === "win32" ? 0 : constants.O_NOFOLLOW;
+          const handle = await open(mutationTargetPath, constants.O_RDONLY | noFollow);
+          try {
+            const { dev, ino } = await handle.stat();
+            currentIdentity = { dev, ino };
+            currentRaw = await handle.readFile("utf-8");
+          } finally {
+            await handle.close();
+          }
         } catch (error) {
           if (errCode(error) !== "ENOENT") throw error;
         }
@@ -146,6 +157,7 @@ export function regUndo(pi: ExtensionAPI): void {
         await writeAtomic(
           mutationTargetPath,
           undo.bom + restoreEndings(undo.content, undo.originalEnding),
+          currentIdentity,
         );
 
         const currentNormalized = currentRaw === undefined ? "" : toLF(stripBOM(currentRaw).text);
@@ -160,7 +172,10 @@ export function regUndo(pi: ExtensionAPI): void {
         try {
           const store = await loadHashStore();
           persistSnapshot(store, mutationTargetPath, undo.content, undo.hashes);
-          recordServedDiff(store, mutationTargetPath, undoDiff, new Set(undo.hashes));
+          const diffHashes = servedHashesFromDiff(undoDiff);
+          const undoLines = splitLines(undo.content);
+          const servedMap = buildServedMap(undo.hashes, undoLines, diffHashes);
+          recordServed(store, mutationTargetPath, servedMap, new Set(undo.hashes));
         } catch (error) {
           console.error("Failed to restore hash store snapshot after undo:", error);
         }

package/src/replace.ts

@@ -2,7 +2,6 @@ import type {
   ExtensionAPI,
   ToolDefinition,
 } from "@earendil-works/pi-coding-agent";
-import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import { constants } from "fs";
 import {
   genDiff,
@@ -10,9 +9,9 @@ import {
 } from "./replace-diff";
 import { readNormFile, type NormFile } from "./file-reader";
 import { editToolSchema, type ReqParams, assertReq, normReq } from "./payload-contract";
-import { isRec, abortIf, makePrepareArguments } from "./utils";
+import { isRec } from "./utils";
 import { loadP, loadGuide } from "./prompts";
-import { resolveInCwd } from "./fs-write";
+import { type FileIdentity } from "./fs-write";
 import { applyEdit,
   lineHashes,
   resEdit,
@@ -26,14 +25,13 @@ import { applyEdit,
 import { commitEdit } from "./commit";
 import type { RMetrics } from "./replace-response";
 import {
-  makeRenderCall,
-  renderEditResult,
   type RPreview,
   type RRState,
 } from "./replace-render";
 import { loadHashStore, findSnapshotPaths, findServedPaths, type HashStore } from "./hash-store";
 import { getServed, recordServedSafe } from "./served";
 import { noopPayloadKey, markBoundaryNoop, consumeBoundaryBypass, clearBoundaryBypass } from "./boundary-bypass";
+import { queuedEdit, editToolBase, editRenderCallWrapper, editRenderResultWrapper } from "./edit-common";
 
 export { editToolSchema, type ReqParams, assertReq };
 
@@ -65,6 +63,7 @@ export interface PipelineResult {
   totalRemovedLines: number;
   hadBoundaryDedup: boolean;
   boundaryRemovedLines: number;
+  identity: FileIdentity;
 }
 
 async function resolveMissingPath(
@@ -120,8 +119,8 @@ function hashSpan(hashes: string[], from: string, to: string): [number, number]
 }
 async function noteAnchorError(absolutePath: string, error: unknown, scopeHashes: string[], noPersist?: boolean): Promise<void> {
   if (noPersist === true) return;
-  if (error instanceof RangeStaleError) await recordServedSafe(absolutePath, error.rangeHashes, "range-stale feedback", new Set(scopeHashes));
-  else if (error instanceof AnchorMismatchError) await recordServedSafe(absolutePath, error.feedbackHashes, "anchor-mismatch feedback", new Set(scopeHashes));
+  if (error instanceof RangeStaleError) await recordServedSafe(absolutePath, error.rangeServedMap, "range-stale feedback", new Set(scopeHashes));
+  else if (error instanceof AnchorMismatchError) await recordServedSafe(absolutePath, error.feedbackMap, "anchor-mismatch feedback", new Set(scopeHashes));
 }
 
 function collectRemovedHashes(
@@ -170,7 +169,7 @@ export async function execPipeline(
   );
 
   const hashStore = options?.store ?? await loadHashStore();
-  const { normalized: originalNormalized, bom, originalEnding, fileHashes: originalHashes, hadUtf8DecodeErrors, absolutePath } = await readNormFile(
+  const { normalized: originalNormalized, bom, originalEnding, fileHashes: originalHashes, hadUtf8DecodeErrors, absolutePath, identity } = await readNormFile(
     path, cwd, { signal: options?.signal, accessMode: options?.accessMode, maxLines: MAX_HASH_LINES, store: hashStore, noPersist: options?.noPersist, preloadedNorm: options?.preloadedNorm },
   );
 
@@ -227,6 +226,7 @@ export async function execPipeline(
     totalRemovedLines,
     hadBoundaryDedup: (anchorResult.autoFixes?.length ?? 0) > 0,
     boundaryRemovedLines: anchorResult.autoFixes?.length ?? 0,
+    identity,
   };
 }
 
@@ -277,22 +277,9 @@ export function buildToolDef(): ToolDef {
     parameters,
     promptSnippet: E_SNIPPET,
     promptGuidelines: E_GUIDE,
-    prepareArguments: makePrepareArguments(),
-    executionMode: "sequential",
-    renderShell: "default",
-    renderCall: makeRenderCall(compPreview),
-    renderResult(result, { isPartial, expanded }, theme, context) {
-      return renderEditResult(
-        result as {
-          content?: Array<{ type: string; text?: string }>;
-          details?: ReplaceDetails;
-        },
-        { isPartial, expanded },
-        theme,
-        context,
-      );
-    },
-
+    ...editToolBase,
+    renderCall: editRenderCallWrapper(compPreview),
+    renderResult: editRenderResultWrapper,
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
       const canonical = normReq(params);
       const resolution = isRec(canonical) ? await resolveMissingPath(canonical) : undefined;
@@ -300,14 +287,11 @@ export function buildToolDef(): ToolDef {
         canonical.path = resolution.path;
       }
       assertReq(canonical);
-
       const normalizedParams = canonical;
       const path = normalizedParams.path;
-      const { absolute: absolutePath, resolved: mutationTargetPath } = await resolveInCwd(path, ctx.cwd);
-      const noopPayload = noopPayloadKey(mutationTargetPath, normalizedParams.remove_from, normalizedParams.remove_to, normalizedParams.replacement_lines);
-      const boundaryBypass = consumeBoundaryBypass(mutationTargetPath, noopPayload);
-      return withFileMutationQueue(mutationTargetPath, async () => {
-        abortIf(signal);
+      return queuedEdit(path, ctx.cwd, signal, async (absolutePath, mutationTargetPath) => {
+        const noopPayload = noopPayloadKey(mutationTargetPath, normalizedParams.remove_from, normalizedParams.remove_to, normalizedParams.replacement_lines);
+        const boundaryBypass = consumeBoundaryBypass(mutationTargetPath, noopPayload);
         const pipe = await execPipeline(
           normalizedParams,
           ctx.cwd,

package/src/served.ts

@@ -1,5 +1,6 @@
-import { loadHashStore, parseStoredHashes, STORE_NOT_OPEN_MESSAGE, withStore, type HashStore } from "./hash-store";
+import { loadHashStore, parseStoredServed, STORE_NOT_OPEN_MESSAGE, withStore, type HashStore } from "./hash-store";
 import { HASH_CLASS } from "./hashline/alphabet";
+import { contentChecksum } from "./hashline/hasher";
 
 const SERVED_DIFF_ROW_RE = new RegExp(`^[+ ](${HASH_CLASS})│`);
 
@@ -12,60 +13,88 @@ export function servedHashesFromDiff(diff: string): string[] {
   return hashes;
 }
 
-export function getServed(store: HashStore, path: string): Set<string> | undefined {
+export function servedMapFromDiff(diff: string): Map<string, string> {
+  const map = new Map<string, string>();
+  for (const line of diff.split("\n")) {
+    const match = SERVED_DIFF_ROW_RE.exec(line);
+    if (!match) continue;
+    const hash = match[1]!;
+    const content = line.slice(match[0].length);
+    map.set(hash, contentChecksum(content));
+  }
+  return map;
+}
+
+export function buildServedMap(fileHashes: string[], fileLines: string[], wantedHashes: string[]): Map<string, string> {
+  const index = new Map<string, number>();
+  for (let i = 0; i < fileHashes.length; i++) index.set(fileHashes[i]!, i);
+  const map = new Map<string, string>();
+  for (const h of wantedHashes) {
+    const idx = index.get(h);
+    if (idx !== undefined) map.set(h, contentChecksum(fileLines[idx]!));
+  }
+  return map;
+}
+
+export function getServed(store: HashStore, path: string): Map<string, string> | undefined {
   const row = store.stmts.servedGet(path);
-  const parsed = parseStoredHashes(row, () => store.stmts.servedDelete(path));
+  const parsed = parseStoredServed(row, () => store.stmts.servedDelete(path));
   if (!parsed) return undefined;
-  return new Set(parsed);
+  return parsed;
 }
 
 function computeUpdate(
   store: HashStore,
   path: string,
-  hashes: string[],
+  entries: Map<string, string>,
   scope?: ReadonlySet<string>,
-): Set<string> | undefined {
+): Map<string, string> | undefined {
   const existing = getServed(store, path);
-  if (!existing && hashes.length === 0) return undefined;
-  const set = existing ?? new Set<string>();
+  if (!existing && entries.size === 0 && !scope) return undefined;
+  const map = existing ? new Map(existing) : new Map<string, string>();
   let changed = false;
   if (scope) {
-    for (const hash of set) {
+    for (const hash of [...map.keys()]) {
       if (!scope.has(hash)) {
-        set.delete(hash);
+        map.delete(hash);
         changed = true;
       }
     }
   }
-  for (const hash of hashes) {
-    if (!set.has(hash)) {
-      set.add(hash);
+  for (const [hash, content] of entries) {
+    const prev = map.get(hash);
+    if (prev !== content) {
+      map.set(hash, content);
       changed = true;
     }
   }
-  if (!changed) return undefined;
-  return set;
+  if (!changed && existing) return undefined;
+  if (map.size === 0 && (!existing || existing.size === 0)) return undefined;
+  if (!changed) return existing;
+  return map;
 }
 
 export function recordServed(
   store: HashStore,
   path: string,
-  hashes: string[],
+  entries: Map<string, string>,
   scope?: ReadonlySet<string>,
 ): void {
   try {
     withStore(() => {
-      const set = computeUpdate(store, path, hashes, scope);
-      if (!set) return;
-      store.stmts.servedUpsert(path, JSON.stringify([...set]), Date.now());
+      const map = computeUpdate(store, path, entries, scope);
+      if (!map) return;
+      const obj = Object.fromEntries(map);
+      store.stmts.servedUpsert(path, JSON.stringify(obj), Date.now());
     });
     return;
   } catch (error) {
     if (!(error instanceof Error && error.message === STORE_NOT_OPEN_MESSAGE)) throw error;
   }
-  const set = computeUpdate(store, path, hashes, scope);
-  if (!set) return;
-  store.stmts.servedUpsert(path, JSON.stringify([...set]), Date.now());
+  const map = computeUpdate(store, path, entries, scope);
+  if (!map) return;
+  const obj = Object.fromEntries(map);
+  store.stmts.servedUpsert(path, JSON.stringify(obj), Date.now());
 }
 
 export function recordServedDiff(
@@ -74,7 +103,7 @@ export function recordServedDiff(
   diff: string,
   scope?: ReadonlySet<string>,
 ): void {
-  recordServed(store, path, servedHashesFromDiff(diff), scope);
+  recordServed(store, path, servedMapFromDiff(diff), scope);
 }
 
 export function clearServed(store: HashStore, path: string): void {
@@ -83,14 +112,14 @@ export function clearServed(store: HashStore, path: string): void {
 
 export async function recordServedSafe(
   path: string,
-  hashes: string[],
+  entries: Map<string, string>,
   context: string,
   scope?: ReadonlySet<string>,
 ): Promise<void> {
-  if (hashes.length === 0 && !scope) return;
+  if (entries.size === 0 && !scope) return;
   try {
     const store = await loadHashStore();
-    recordServed(store, path, hashes, scope);
+    recordServed(store, path, entries, scope);
   } catch (error) {
     console.error(`Failed to record served state (${context}):`, error);
   }
@@ -103,5 +132,5 @@ export async function recordServedDiffSafe(
   scope?: ReadonlySet<string>,
 ): Promise<void> {
   if (!diff) return;
-  await recordServedSafe(path, servedHashesFromDiff(diff), context, scope);
+  await recordServedSafe(path, servedMapFromDiff(diff), context, scope);
 }

package/src/validation.ts

@@ -1,6 +1,7 @@
 import { constants } from "fs";
 import { access as fsAccess } from "fs/promises";
 import type { LFile } from "./file-kind";
+import type { FileIdentity } from "./fs-write";
 import { errCode } from "./utils";
 
 export async function valAccess(
@@ -26,7 +27,7 @@ export async function valAccess(
 	}
 }
 
-export function valKind(file: LFile, path: string): asserts file is { kind: "text"; text: string; hadUtf8DecodeErrors?: true } {
+export function valKind(file: LFile, path: string): asserts file is { kind: "text"; text: string; identity?: FileIdentity; hadUtf8DecodeErrors?: true } {
 	if (file.kind === "directory") {
 		throw new Error(`[E_NOT_TEXT] Path is a directory: ${path}. Use ls to inspect directories.`);
 	}
@@ -42,4 +43,3 @@ export function valKind(file: LFile, path: string): asserts file is { kind: "tex
 		);
 	}
 }
-

package/src/write-hook.ts

@@ -8,19 +8,19 @@ import { abortIf, splitLines, isRec, normalizeFilePath } from "./utils";
 
 const HASH_ECHO_RE = new RegExp(`^(${HASH_CLASS})${HASH_SEP}`);
 
-function searchEcho(lines: string[], served: ReadonlySet<string>): { line: number; hash: string } | undefined {
+function searchEcho(lines: string[], served: ReadonlyMap<string, string> | ReadonlySet<string>): { line: number; hash: string } | undefined {
   for (let i = 0; i < lines.length; i++) {
     const match = HASH_ECHO_RE.exec(lines[i]!);
-    if (match && served.has(match[1]!)) return { line: i + 1, hash: match[1]! };
+    if (match && served.has(match[1]! as never)) return { line: i + 1, hash: match[1]! };
   }
   return undefined;
 }
 
-export function findServedHashEcho(content: string, served: ReadonlySet<string>): { line: number; hash: string } | undefined {
+export function findServedHashEcho(content: string, served: ReadonlyMap<string, string> | ReadonlySet<string>): { line: number; hash: string } | undefined {
   return searchEcho(splitLines(content), served);
 }
 
-export function findEditHashEcho(lines: string[], served: ReadonlySet<string>): { line: number; hash: string } | undefined {
+export function findEditHashEcho(lines: string[], served: ReadonlyMap<string, string> | ReadonlySet<string>): { line: number; hash: string } | undefined {
   return searchEcho(lines, served);
 }