pi-hashline-edit-pro 3.0.3 → 4.0.0

package/src/replace-render.ts

@@ -2,6 +2,7 @@ import { Markdown, Text } from "@earendil-works/pi-tui";
 import { keyHint, type Theme } from "@earendil-works/pi-coding-agent";
 import type { ReplaceDetails } from "./replace";
 import { withLineNumbers } from "./utils";
+import { isDedupRow } from "./replace-response";
 import { getPreviewInput } from "./payload-contract";
 export { getPreviewInput };
 
@@ -19,14 +20,16 @@ export type RRState = {
 	previewGeneration?: number;
 	previewTimer?: ReturnType<typeof setTimeout>;
 	previewAbort?: AbortController;
+	resolvedPath?: string;
 };
 
 type DiffRowKind = "added" | "removed" | "context";
 
 function diffRowKind(line: string): DiffRowKind {
-	const stripped = line.replace(/^\s*\d+\s+│\s*/, "");
-	if (stripped.startsWith("+") && !stripped.startsWith("+++")) return "added";
-	if (stripped.startsWith("-") && !stripped.startsWith("---")) return "removed";
+	const withoutGutter = line.replace(/^\s*\d+\s+│\s*/, "");
+	if (isDedupRow(withoutGutter) || isDedupRow(withoutGutter.replace(/^\s*│\s*/, ""))) return "removed";
+	if (withoutGutter.startsWith("+") && !withoutGutter.startsWith("+++")) return "added";
+	if (withoutGutter.startsWith("-") && !withoutGutter.startsWith("---")) return "removed";
 	return "context";
 }
 
@@ -71,7 +74,7 @@ export function fmtCall(
   toolName = "replace",
 ): string {
   const previewPath = state.preview && "path" in state.preview ? state.preview.path : undefined;
-  const path = args?.path ?? previewPath;
+  const path = args?.path ?? state.resolvedPath ?? previewPath;
   const anchorFallback = typeof args?.remove_from === "string" && typeof args?.remove_to === "string" ? `${args.remove_from}→${args.remove_to}` : typeof args?.anchor === "string" ? args.anchor : undefined;
   const pathDisplay =
     typeof path === "string" && path.length > 0
@@ -237,12 +240,20 @@ export function reuseMarkdown(context: any, content: string, theme: any): Markdo
 
 export function makeRenderCall(
 	preview: (args: unknown, cwd: string, signal?: AbortSignal) => Promise<RPreview>,
-  options: { getInput?: (args: unknown) => { path?: string; remove_from?: string; remove_to?: string; anchor?: string } | null; toolName?: string } = {},
+  options: {
+    getInput?: (args: unknown) => { path?: string; remove_from?: string; remove_to?: string; anchor?: string } | null;
+    toolName?: string;
+    resolveTarget?: (input: { remove_from?: string; remove_to?: string; anchor?: string }) => string | undefined;
+  } = {},
 ) {
 	const getInput = options.getInput ?? getPreviewInput;
 	const toolName = options.toolName ?? "replace";
 	return (args: any, theme: CallT, context: any): Text => {
 		const previewInput = getInput(args);
+		if (!context.executionStarted && previewInput) {
+			const resolved = options.resolveTarget?.(previewInput);
+			context.state.resolvedPath = resolved;
+		}
 		const cancelPendingPreview = () => {
 			if (context.state.previewTimer) {
 				clearTimeout(context.state.previewTimer);

package/src/replace-response.ts

@@ -137,6 +137,10 @@ export function fmtDedupRow(line: string): string {
   return `${DEDUP_ANCHOR}${HASH_SEP}[Row is ${size}, exceeds ${limit}; content not shown. Use read to see the full line.]`;
 }
 
+export function isDedupRow(line: string): boolean {
+  return line.startsWith(`${DEDUP_ANCHOR}${HASH_SEP}`);
+}
+
 export function isChangeRow(line: string): boolean {
   return line.startsWith("+") || line.startsWith("-");
 }

package/src/replace-undo.ts

@@ -4,7 +4,10 @@ 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 { recordServed, buildServedMap, servedHashesFromDiff } from "./served";
+import { servedHashesFromDiff, buildServedMap } from "./served";
+import { contentChecksum } from "./hashline/hasher";
+import { hashSource } from "./hashline";
+import { markServed as markServedScoped, freeAnchors, adoptAnchors } from "./anchor-registry";
 import { resolveInCwd, writeAtomic, type FileIdentity } from "./fs-write";
 import { toLF, stripBOM, restoreEndings, type LineEnding } from "./normalize";
 import { genDiff, genPatch } from "./replace-diff";
@@ -180,11 +183,18 @@ export function regUndo(pi: ExtensionAPI): void {
 
         try {
           const store = await loadHashStore();
-          persistSnapshot(store, mutationTargetPath, undo.content, 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));
+          persistSnapshot(store, mutationTargetPath, undo.content, undo.hashes);
+          freeAnchors(mutationTargetPath);
+          adoptAnchors(
+            mutationTargetPath,
+            new Map(undoLines.map((line, i) => [undo.hashes[i]!, contentChecksum(hashSource(line))])),
+          );
+          markServedScoped(
+            mutationTargetPath,
+            buildServedMap(undo.hashes, undoLines, servedHashesFromDiff(undoDiff)),
+            new Set(undo.hashes),
+          );
         } catch (error) {
           console.error("Failed to restore hash store snapshot after undo:", error);
         }

package/src/replace.ts

@@ -3,13 +3,14 @@ import type {
   ToolDefinition,
 } from "@earendil-works/pi-coding-agent";
 import { constants } from "fs";
+import { relative } from "path";
 import {
   genDiff,
   type LineEnding,
 } from "./replace-diff";
 import { readNormFile, type NormFile } from "./file-reader";
 import { editToolSchema, type ReqParams, assertReq, normReq } from "./payload-contract";
-import { decodeStringArray, isRec } from "./utils";
+import { decodeStringArray } from "./utils";
 import { loadP, loadGuide } from "./prompts";
 import { type FileIdentity } from "./fs-write";
 import { applyEdit,
@@ -28,10 +29,11 @@ import {
   type RRState,
 } from "./replace-render";
 import { loadHashStore, type HashStore } from "./hash-store";
-import { resolveReplacePath } from "./missing-path";
-import { getServed, recordServedSafe } from "./served";
+import { adoptAnchors, servedForPath } from "./anchor-registry";
+import { resolveTarget } from "./fs-write";
+import { toCwd } from "./paths";
 import { noopPayloadKey, markBoundaryNoop, consumeBoundaryBypass, clearBoundaryBypass } from "./boundary-bypass";
-import { queuedEdit, editToolBase, editRenderCallWrapper, editRenderResultWrapper } from "./edit-common";
+import { queuedEdit, editToolBase, editRenderCallWrapper, editRenderResultWrapper, resolveEditTarget } from "./edit-common";
 
 export { editToolSchema, type ReqParams, assertReq };
 
@@ -79,7 +81,7 @@ export interface ExecPipelineOptions {
   preloadedNorm?: NormFile;
 }
 
-function hashSpan(hashes: string[], from: string, to: string): [number, number] | undefined {
+export function hashSpan(hashes: string[], from: string, to: string): [number, number] | undefined {
   const a = hashes.indexOf(from);
   const b = hashes.indexOf(to);
   if (a < 0 || b < 0) return undefined;
@@ -87,20 +89,11 @@ 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.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(
-  edit: HEdit,
-  originalHashes: string[],
-): Set<string> {
-  const span = hashSpan(originalHashes, edit.hash_bounds[0].hash, edit.hash_bounds[1].hash);
-  const removedHashes = new Set<string>();
-  if (span) {
-    for (let i = span[0]; i <= span[1]; i++) removedHashes.add(originalHashes[i]!);
+  if (error instanceof RangeStaleError) {
+    adoptAnchors(absolutePath, error.rangeServedMap);
+  } else if (error instanceof AnchorMismatchError) {
+    adoptAnchors(absolutePath, error.feedbackMap);
   }
-  return removedHashes;
 }
 
 function countLineChanges(
@@ -119,18 +112,17 @@ function countLineChanges(
 }
 
 export async function execPipeline(
+  targetPath: string,
   params: ReqParams,
   cwd: string,
   options?: ExecPipelineOptions,
 ): Promise<PipelineResult> {
 
-  const path = params.path;
-
   const editWarnings: string[] = [];
   let replacementLines = params.replacement_lines;
   const expandedReplacement = decodeStringArray(replacementLines);
   if (expandedReplacement) {
-    editWarnings.push('[E_BAD_SHAPE] Unwrapped JSON array syntax from a replacement_lines element.');
+    editWarnings.push('[W_BAD_SHAPE] Unwrapped JSON array syntax from a replacement_lines element.');
     replacementLines = expandedReplacement;
   }
   const edit = resEdit(
@@ -143,11 +135,13 @@ export async function execPipeline(
   );
 
   const hashStore = options?.store ?? await loadHashStore();
+  const preResolvedPath = await resolveTarget(toCwd(targetPath, cwd));
+  const served = servedForPath(preResolvedPath);
   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 },
+    targetPath, cwd, { signal: options?.signal, accessMode: options?.accessMode, maxLines: MAX_HASH_LINES, store: hashStore, noPersist: options?.noPersist, allocation: options?.noPersist ? "shadow" : "real", preloadedNorm: options?.preloadedNorm },
   );
+  const displayPath = relative(cwd, absolutePath).replace(/\\/g, "/") || targetPath;
 
-  const served = await getServed(hashStore, absolutePath);
   let anchorResult: ReturnType<typeof applyEdit>;
   try {
     anchorResult = applyEdit(
@@ -155,7 +149,7 @@ export async function execPipeline(
       edit,
       options?.signal,
       originalHashes,
-      path,
+      displayPath,
       served,
       options?.skipBoundaryDedup,
     );
@@ -167,17 +161,12 @@ export async function execPipeline(
   const result = anchorResult.content;
   const isNoop = result === originalNormalized;
 
-  const noPersist = options?.noPersist;
-  const removedHashes = isNoop
-    ? undefined
-    : collectRemovedHashes(edit, originalHashes);
   const resultHashes = isNoop
     ? originalHashes
     : await lineHashes(result, absolutePath, {
         content: originalNormalized,
         hashes: originalHashes,
-        removedHashes,
-      }, hashStore, noPersist !== true);
+      }, hashStore, false, true);
   const warnings = [...editWarnings, ...(anchorResult.warnings ?? [])];
   const { totalAddedLines, totalRemovedLines } = countLineChanges(
     edit, originalHashes, isNoop, anchorResult.autoFixes?.length ?? 0,
@@ -187,7 +176,7 @@ export async function execPipeline(
   const aboveFixes = sortedFixes.filter((fix) => fix.kind === "leading" || fix.kind === "last-new-before");
   const belowFixes = sortedFixes.filter((fix) => fix.kind === "trailing" || fix.kind === "first-new-after");
   return {
-    path,
+    path: displayPath,
     originalNormalized,
     result,
     bom,
@@ -230,12 +219,10 @@ export async function compPreview(
 ): Promise<RPreview> {
   try {
     const normalized = normReq(request);
-    if (isRec(normalized)) {
-      const resolution = await resolveReplacePath(normalized);
-      if (resolution) normalized.path = resolution.path;
-    }
     assertReq(normalized);
+    const targetPath = resolveEditTarget(normalized.remove_from, normalized.remove_to);
     const pipe = await execPipeline(
+      targetPath,
       normalized,
       cwd,
       { accessMode: constants.R_OK, noPersist: true, signal },
@@ -270,30 +257,27 @@ export function buildToolDef(): ToolDef {
     renderResult: editRenderResultWrapper,
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
       const canonical = normReq(params);
-      const resolution = isRec(canonical) ? await resolveReplacePath(canonical) : undefined;
-      if (resolution && isRec(canonical)) {
-        canonical.path = resolution.path;
-      }
       assertReq(canonical);
       const normalizedParams = canonical;
-      const path = normalizedParams.path;
-      return queuedEdit(path, ctx.cwd, signal, async (absolutePath, mutationTargetPath) => {
+      const targetPath = resolveEditTarget(normalizedParams.remove_from, normalizedParams.remove_to);
+      return queuedEdit(targetPath, 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(
+          targetPath,
           normalizedParams,
           ctx.cwd,
           { accessMode: constants.R_OK | constants.W_OK, signal, skipBoundaryDedup: boundaryBypass },
         );
         const appliedWarnings = boundaryBypass
-          ? ["[E_BOUNDARY_BYPASS] Boundary dedup was off for this call and is back on."]
+          ? ["[W_BOUNDARY_BYPASS] Boundary dedup was off for this call and is back on."]
           : [];
         return commitEdit(pipe, {
-          path,
+          path: pipe.path,
           absolutePath,
           mutationTargetPath,
+          editAnchors: [normalizedParams.remove_from, normalizedParams.remove_to],
           signal,
-          prefixWarnings: resolution ? [resolution.warning] : [],
           appliedWarnings,
           onApplied: () => clearBoundaryBypass(mutationTargetPath),
           onNoopDedup: () => markBoundaryNoop(mutationTargetPath, noopPayload),

package/src/served.ts

@@ -1,7 +1,5 @@
-import { loadHashStore, parseStoredServed, STORE_NOT_OPEN_MESSAGE, withStore, type HashStore } from "./hash-store";
-import { touchSession } from "./hash-store/cache";
-import { withBusyRetry } from "./hash-store/retry";
 import { HASH_CLASS } from "./hashline/alphabet";
+import { hashSource } from "./hashline";
 import { contentChecksum } from "./hashline/hasher";
 
 const SERVED_DIFF_ROW_RE = new RegExp(`^[+ ](${HASH_CLASS})│`);
@@ -15,125 +13,20 @@ export function servedHashesFromDiff(diff: string): string[] {
   return hashes;
 }
 
-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> {
+export function buildServedMap(
+  fileHashes: string[],
+  fileLines: string[],
+  wantedHashes: string[],
+): Array<[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 = withBusyRetry(() => store.stmts.servedGet(path));
-  const parsed = parseStoredServed(row, () => store.stmts.servedDelete(path));
-  if (!parsed) return undefined;
-  return parsed;
-}
-
-function computeUpdate(
-  store: HashStore,
-  path: string,
-  entries: Map<string, string>,
-  scope?: ReadonlySet<string>,
-): Map<string, string> | undefined {
-  const existing = getServed(store, path);
-  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 [...map.keys()]) {
-      if (!scope.has(hash)) {
-        map.delete(hash);
-        changed = true;
-      }
-    }
-  }
-  for (const [hash, content] of entries) {
-    const prev = map.get(hash);
-    if (prev !== content) {
-      map.set(hash, content);
-      changed = true;
-    }
+  for (let i = 0; i < fileHashes.length; i++) {
+    const existing = index.get(fileHashes[i]!);
+    if (existing === undefined) index.set(fileHashes[i]!, i);
   }
-  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,
-  entries: Map<string, string>,
-  scope?: ReadonlySet<string>,
-): void {
-  touchSession(path);
-  try {
-    withStore(() => {
-      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 entries: Array<[string, string]> = [];
+  for (const hash of wantedHashes) {
+    const idx = index.get(hash);
+    if (idx !== undefined) entries.push([hash, contentChecksum(hashSource(fileLines[idx]!))]);
   }
-  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(
-  store: HashStore,
-  path: string,
-  diff: string,
-  scope?: ReadonlySet<string>,
-): void {
-  recordServed(store, path, servedMapFromDiff(diff), scope);
-}
-
-export function clearServed(store: HashStore, path: string): void {
-  store.stmts.servedDelete(path);
-}
-
-export async function recordServedSafe(
-  path: string,
-  entries: Map<string, string>,
-  context: string,
-  scope?: ReadonlySet<string>,
-): Promise<void> {
-  if (entries.size === 0 && !scope) return;
-  try {
-    const store = await loadHashStore();
-    recordServed(store, path, entries, scope);
-  } catch (error) {
-    console.error(`Failed to record served state (${context}):`, error);
-  }
-}
-
-export async function recordServedDiffSafe(
-  path: string,
-  diff: string,
-  context: string,
-  scope?: ReadonlySet<string>,
-): Promise<void> {
-  if (!diff) return;
-  await recordServedSafe(path, servedMapFromDiff(diff), context, scope);
+  return entries;
 }

package/src/utils.ts

@@ -9,11 +9,23 @@ export function normalizeFilePath(record: Record<string, unknown>): void {
   }
 }
 
+export function normalizeAnchors(record: Record<string, unknown>): void {
+  if (typeof record.remove_from !== "string" && typeof record.replace_from === "string") {
+    record.remove_from = record.replace_from;
+    delete record.replace_from;
+  }
+  if (typeof record.remove_to !== "string" && typeof record.replace_to === "string") {
+    record.remove_to = record.replace_to;
+    delete record.replace_to;
+  }
+}
+
 export function makePrepareArguments(): (args: unknown) => any {
   return (args) => {
     if (!isRec(args)) return args;
     const record = { ...args };
     normalizeFilePath(record);
+    normalizeAnchors(record);
     return record;
   };
 }

package/src/write-hook.ts

@@ -1,8 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { HASH_CLASS } from "./hashline/alphabet";
 import { HASH_SEP } from "./hashline/hash";
-import { loadHashStore } from "./hash-store";
-import { getServed } from "./served";
+import { ownersForPath } from "./anchor-registry";
 import { resolveInCwd } from "./fs-write";
 import { abortIf, splitLines, isRec, normalizeFilePath } from "./utils";
 
@@ -28,8 +27,7 @@ export async function servedHashEchoDenial(rawPath: string, content: string, cwd
   abortIf(signal);
   const { resolved } = await resolveInCwd(rawPath, cwd);
   abortIf(signal);
-  const store = await loadHashStore();
-  const served = getServed(store, resolved);
+  const served = ownersForPath(resolved);
   if (!served || served.size === 0) return undefined;
   const echo = findServedHashEcho(content, served);
   if (!echo) return undefined;

package/src/missing-path.ts

@@ -1,51 +0,0 @@
-import { loadHashStore, findSnapshotPaths, findServedPaths, pickRecentPath } from "./hash-store";
-import { parseHashRef } from "./hashline/parse";
-import { stripAnchorRow } from "./hashline/resolve";
-
-export async function resolvePathFromHashes(hashes: string[]): Promise<{ path: string; warning: string } | undefined> {
-  let store;
-  try {
-    store = await loadHashStore();
-  } catch {
-    return undefined;
-  }
-  const matches = [...new Set([...findSnapshotPaths(store, hashes), ...findServedPaths(store, hashes)])];
-  if (matches.length === 0) return undefined;
-  if (matches.length === 1) {
-    const single = matches[0]!;
-    return { path: single, warning: `[E_BAD_SHAPE] Missing "path" resolved to ${single}.` };
-  }
-  const sorted = [...matches].sort();
-  const picked = pickRecentPath(store, sorted);
-  return { path: picked, warning: `[E_BAD_SHAPE] Missing "path" resolved to ${picked} (picked most recent of ${sorted.length}: ${sorted.join(", ")}).` };
-}
-
-export async function resolveReplacePath(request: Record<string, unknown>): Promise<{ path: string; warning: string } | undefined> {
-  if (typeof request.path === "string") return undefined;
-  const from = request.remove_from;
-  const to = request.remove_to;
-  if (typeof from !== "string" || typeof to !== "string") return undefined;
-  const hashes: string[] = [];
-  for (const ref of [from, to]) {
-    try {
-      hashes.push(parseHashRef(ref).hash);
-    } catch {
-      return undefined;
-    }
-  }
-  return resolvePathFromHashes(hashes);
-}
-
-export async function resolveInsertPath(request: Record<string, unknown>): Promise<{ path: string; warning: string } | undefined> {
-  if (typeof request.path === "string") return undefined;
-  const anchor = request.anchor;
-  if (typeof anchor !== "string") return undefined;
-  let hash: string;
-  try {
-    const stripped = stripAnchorRow(anchor.trim(), "anchor entry");
-    hash = parseHashRef(stripped).hash;
-  } catch {
-    return undefined;
-  }
-  return resolvePathFromHashes([hash]);
-}