pi-hashline-edit-pro 2.8.1 → 2.8.3

package/src/hashline/resolve.ts

@@ -2,6 +2,7 @@ import { abortIf, rejectUnknownFields, firstNonEmptyIndex, lastNonEmptyIndex, cl
 import { HASH_SEP, HASH_RUN, stripRowPrefix, canon } from "./hash";
 import { parseHashRef, parseText, type Anchor } from "./parse";
 import { NEW_CONTENT_NOT_ARRAY_MSG, MAX_RANGE_STALE_LINES } from "../constants";
+import { contentChecksum } from "./hasher";
 
 export type RAnchor = {
 	line: number;
@@ -90,14 +91,13 @@ export function fmtMismatchWithHashes(
   fileLines: string[],
   fileHashes: string[],
   filePath?: string,
-): { text: string; hashes: string[] } {
+): { text: string; hashes: string[]; servedMap: Map<string, string> } {
   assertAligned(fileLines, fileHashes, "fmtMismatch");
-
   const out: string[] = [];
   const hashes: string[] = [];
+  const servedMap = new Map<string, string>();
   const notFound = mismatches.filter((m) => m.kind === "not_found");
   const ambiguous = mismatches.filter((m) => m.kind === "ambiguous");
-
   const refList = notFound.map((m) => `"${m.ref.hash}"`).join(", ");
   if (notFound.length > 0) {
     out.push(
@@ -110,8 +110,11 @@ export function fmtMismatchWithHashes(
       const to = Math.min(fileLines.length, ctx.line + 1);
       const rows: string[] = [];
       for (let ln = from; ln <= to; ln++) {
-        hashes.push(fileHashes[ln - 1]!);
-        rows.push(`    ${ln}: ${fileHashes[ln - 1]}│${clipLine(fileLines[ln - 1] ?? "")}`);
+        const h = fileHashes[ln - 1]!;
+        const c = fileLines[ln - 1] ?? "";
+        hashes.push(h);
+        servedMap.set(h, contentChecksum(c));
+        rows.push(`    ${ln}: ${h}│${clipLine(c)}`);
       }
       out.push("");
       out.push(`  Current context around resolved anchor "${ctx.hash}" (line ${ctx.line}):\n${rows.join("\n")}`);
@@ -128,7 +131,12 @@ export function fmtMismatchWithHashes(
         (m.candidates?.length ?? 0) > sample.length
           ? `, ... (+${(m.candidates?.length ?? 0) - sample.length} more)`
           : "";
-      for (const line of sample) hashes.push(fileHashes[line - 1]!);
+      for (const line of sample) {
+        const h = fileHashes[line - 1]!;
+        const c = fileLines[line - 1] ?? "";
+        hashes.push(h);
+        servedMap.set(h, contentChecksum(c));
+      }
       const lines = sample
         .map((line) => {
           const content = clipLine(fileLines[line - 1] ?? "");
@@ -140,8 +148,7 @@ export function fmtMismatchWithHashes(
         );
     }
   }
-
-  return { text: out.join("\n"), hashes };
+  return { text: out.join("\n"), hashes, servedMap };
 }
 
 
@@ -482,45 +489,49 @@ export function valEdit(
 }
 
 export function resolveAnchorLine(
-	ref: Anchor,
-	fileLines: string[],
-	fileHashes: string[],
-	filePath?: string,
+  ref: Anchor,
+  fileLines: string[],
+  fileHashes: string[],
+  filePath?: string,
 ): number {
-	const { resolved, mismatches } = valEdit(
-		{ hash_bounds: [ref, ref], content_lines: [] },
-		fileLines,
-		fileHashes,
-		[],
-		undefined,
-	);
-	if (mismatches.length > 0 || !resolved) {
-		const feedback = fmtMismatchWithHashes(
-			mismatches,
-			fileLines,
-			fileHashes,
-			filePath,
-		);
-		throw new AnchorMismatchError(feedback.text, feedback.hashes);
-	}
-	return resolved.hash_bounds[0].line;
+  const { resolved, mismatches } = valEdit(
+    { hash_bounds: [ref, ref], content_lines: [] },
+    fileLines,
+    fileHashes,
+    [],
+    undefined,
+  );
+  if (mismatches.length > 0 || !resolved) {
+    const feedback = fmtMismatchWithHashes(
+      mismatches,
+      fileLines,
+      fileHashes,
+      filePath,
+    );
+    throw new AnchorMismatchError(feedback.text, feedback.hashes, feedback.servedMap);
+  }
+  return resolved.hash_bounds[0].line;
 }
 
 export class RangeStaleError extends Error {
   readonly rangeHashes: string[];
-  constructor(message: string, rangeHashes: string[]) {
+  readonly rangeServedMap: Map<string, string>;
+  constructor(message: string, rangeHashes: string[], rangeServedMap: Map<string, string>) {
     super(message);
     this.name = "RangeStaleError";
     this.rangeHashes = rangeHashes;
+    this.rangeServedMap = rangeServedMap;
   }
 }
 
 export class AnchorMismatchError extends Error {
   readonly feedbackHashes: string[];
-  constructor(message: string, feedbackHashes: string[]) {
+  readonly feedbackMap: Map<string, string>;
+  constructor(message: string, feedbackHashes: string[], feedbackMap: Map<string, string>) {
     super(message);
     this.name = "AnchorMismatchError";
     this.feedbackHashes = feedbackHashes;
+    this.feedbackMap = feedbackMap;
   }
 }
 
@@ -528,7 +539,7 @@ export function assertRangeServed(
   resolved: RHEdit,
   fileLines: string[],
   fileHashes: string[],
-  served: ReadonlySet<string>,
+  served: ReadonlyMap<string, string> | undefined,
   filePath?: string,
 ): void {
   assertAligned(fileLines, fileHashes, "assertRangeServed");
@@ -536,18 +547,23 @@ export function assertRangeServed(
   const endLine = resolved.hash_bounds[1].line;
   const mismatchLines: number[] = [];
   for (let line = startLine; line <= endLine; line++) {
-    if (!served.has(fileHashes[line - 1]!)) mismatchLines.push(line);
+    const hash = fileHashes[line - 1]!;
+    const content = fileLines[line - 1]!;
+    const servedContent = served?.get(hash);
+    if (servedContent === undefined || servedContent !== contentChecksum(content)) mismatchLines.push(line);
   }
   if (mismatchLines.length === 0) return;
-
   const rangeLength = endLine - startLine + 1;
   const shownLength = Math.min(rangeLength, MAX_RANGE_STALE_LINES);
   const rows: string[] = [];
   const shownHashes: string[] = [];
+  const shownMap = new Map<string, string>();
   for (let line = startLine; line < startLine + shownLength; line++) {
     const hash = fileHashes[line - 1]!;
+    const content = fileLines[line - 1]!;
     shownHashes.push(hash);
-    rows.push(fmtRow(hash, clipLine(fileLines[line - 1])));
+    shownMap.set(hash, contentChecksum(content));
+    rows.push(fmtRow(hash, clipLine(content)));
   }
   const location = filePath ? ` in ${filePath}` : "";
   const first = mismatchLines[0]!;
@@ -561,7 +577,7 @@ export function assertRangeServed(
       : "";
   const message =
     `[E_RANGE_STALE] ${mismatchText} what was shown. Nothing was modified. Current range with fresh anchors:\n\n${rows.join("\n")}${capHint}`;
-  throw new RangeStaleError(message, shownHashes);
+  throw new RangeStaleError(message, shownHashes, shownMap);
 }
 
 export { warnUnicodeEsc };

package/src/read.ts

@@ -13,8 +13,8 @@ import { MAX_OVERSIZED_WARNING_LINES } from "./constants";
 import { readNormFile, safeSnapId } from "./file-reader";
 import { lineHashes, fmtRegion, fmtRow, HASH_SEP, MAX_HASH_LINES } from "./hashline";
 import { toCwd } from "./paths";
-import { abortIf, makePrepareArguments, numberedRead, visLines } from "./utils";
-import { recordServedSafe } from "./served";
+import { abortIf, makePrepareArguments, numberedRead, visLines, splitLines } from "./utils";
+import { recordServedSafe, buildServedMap } from "./served";
 import { loadP, loadGuide } from "./prompts";
 import { valAccess } from "./validation";
 import { Text } from "@earendil-works/pi-tui";
@@ -236,7 +236,9 @@ export function regRead(pi: ExtensionAPI): void {
 				fileHashes,
 				resolvedPath,
 			);
-			await recordServedSafe(resolvedPath, preview.servedHashes, "read", new Set(fileHashes));
+			const fileLines = splitLines(normalized);
+			const servedMap = buildServedMap(fileHashes, fileLines, preview.servedHashes);
+			await recordServedSafe(resolvedPath, servedMap, "read", new Set(fileHashes));
 			const snapshotId = await safeSnapId(absolutePath, "read");
 			const previewText =
 				hadUtf8DecodeErrors

package/src/replace-undo.ts

@@ -4,11 +4,11 @@ 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 { 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 } from "./utils";
+import { cntDiff, errCode, makePrepareArguments, splitLines } from "./utils";
 import { loadP, loadGuide } from "./prompts";
 import { buildMetrics } from "./replace-response";
 import { renderEditResult } from "./replace-render";
@@ -172,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

@@ -119,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(

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/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);
 }