pi-hashline-edit-pro 3.0.4 → 4.0.0

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,13 +112,12 @@ 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);
@@ -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,17 +257,14 @@ 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 },
@@ -289,11 +273,11 @@ export function buildToolDef(): ToolDef {
           ? ["[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/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,54 +0,0 @@
-import { loadHashStore, findSnapshotPaths, findServedPaths, rankRecentPaths } 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: `[W_BAD_SHAPE] Missing "path" resolved to ${single}.` };
-  }
-  const ranked = rankRecentPaths(store, [...matches]);
-  const picked = ranked[0]!;
-  const shown = ranked.slice(0, 3);
-  const hidden = ranked.length - shown.length;
-  const listed = hidden > 0 ? `${shown.join(", ")}, ... (+${hidden} more)` : shown.join(", ");
-  return { path: picked, warning: `[W_BAD_SHAPE] Missing "path" resolved to ${picked} (picked most recent of ${ranked.length}: ${listed}).` };
-}
-
-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]);
-}