pi-hashline-edit-pro 4.1.0 → 4.2.1

package/src/insert.ts

@@ -3,43 +3,17 @@ import { Type } from "typebox";
 import { constants } from "fs";
 import { execPipeline, type ReqParams, type ReplaceDetails, previewFromPipe, previewError } from "./replace";
 import { commitEdit } from "./commit";
+import { batchMemberFor, executeBatchMember, noteBatchFailure } from "./batch";
 import { readNormFile, type NormFile } from "./file-reader";
-import { MAX_HASH_LINES, parseHashRef, resolveAnchorLine, type Anchor } from "./hashline";
+import { MAX_HASH_LINES, parseHashRef, resEdit, resolveAnchorLine, type Anchor, type HEdit } from "./hashline";
 import { stripAnchorRow } from "./hashline/resolve";
 import { loadP, loadGuide } from "./prompts";
-import { normReq } from "./payload-contract";
-import { decodeStringArray, isRec, rejectUnknownFields, splitLines } from "./utils";
+import { assertInsertReq, normReq, type InsertReq } from "./payload-contract";
+import { decodeStringArray, isRec, splitLines } from "./utils";
 import { clearBoundaryBypass } from "./boundary-bypass";
 import { queuedEdit, editToolBase, editRenderCallWrapper, editRenderResultWrapper, resolveEditTargetWithRequirement, throwIfStrictInput, withInsertPrompts, DEFAULT_EDIT_FLAGS, type EditToolFlags } from "./edit-common";
 import type { RPreview, RRState } from "./replace-render";
-
-const INSERT_KS = new Set(["path", "anchor", "direction", "lines"]);
-
-export interface InsertReq {
-  path?: string;
-  anchor: string;
-  direction: "before" | "after";
-  lines: string[];
-}
-
-export function assertInsertReq(request: unknown): asserts request is InsertReq {
-  if (!isRec(request)) {
-    throw new Error("[E_BAD_SHAPE] Insert request must be an object.");
-  }
-  rejectUnknownFields(request, INSERT_KS, "Insert request");
-  if (request.path !== undefined && typeof request.path !== "string") {
-    throw new Error('[E_BAD_SHAPE] Insert request field "path" must be a string when provided.');
-  }
-  if (typeof request.anchor !== "string" || request.anchor.length === 0) {
-    throw new Error('[E_BAD_SHAPE] Insert request requires an "anchor" string (4-char anchor from read output).');
-  }
-  if (request.direction !== "before" && request.direction !== "after") {
-    throw new Error('[E_BAD_SHAPE] Insert request "direction" must be "before" or "after".');
-  }
-  if (!Array.isArray(request.lines) || request.lines.some((line) => typeof line !== "string")) {
-    throw new Error('[E_BAD_SHAPE] Insert request requires "lines" as an array of strings, one element per line.');
-  }
-}
+export { assertInsertReq, type InsertReq };
 
 const insertAnchorSchema = Type.String({
   description:
@@ -71,7 +45,7 @@ const insertToolSchema = Type.Object(
     direction: insertDirectionSchema,
     lines: insertLinesSchema,
   },
-  { additionalProperties: false },
+  { additionalProperties: true },
 );
 
 export function buildInsertToolSchema(requirePath: boolean): typeof insertToolSchema {
@@ -83,18 +57,18 @@ export function buildInsertToolSchema(requirePath: boolean): typeof insertToolSc
       direction: insertDirectionSchema,
       lines: insertLinesSchema,
     },
-    { additionalProperties: false },
+    { additionalProperties: true },
   ) as typeof insertToolSchema;
 }
 
-function parseInsertAnchor(raw: string): { ref: Anchor; warnings: string[] } {
+export function parseInsertAnchor(raw: string): { ref: Anchor; warnings: string[] } {
   const trimmedAnchor = raw.trim();
   const warnings: string[] = [];
   const anchorText = stripAnchorRow(trimmedAnchor, "anchor entry", warnings);
   return { ref: parseHashRef(anchorText), warnings };
 }
 
-function buildInsertEdit(
+export function buildInsertEdit(
   req: InsertReq,
   preload: NormFile,
   ref: Anchor,
@@ -216,32 +190,68 @@ export function buildInsertToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): I
         anchor: req.anchor,
         providedPath: req.path,
         cwd: ctx.cwd,
+      }).catch((error: unknown) => {
+        const member = batchMemberFor(_toolCallId);
+        if (member) noteBatchFailure(member, error);
+        throw error;
       });
-      const { ref, warnings: anchorWarnings } = parseInsertAnchor(req.anchor);
-      await throwIfStrictInput([...anchorWarnings, ...insertWarnings]);
+      let ref: Anchor;
+      let anchorWarnings: string[];
+      try {
+        ({ ref, warnings: anchorWarnings } = parseInsertAnchor(req.anchor));
+        await throwIfStrictInput([...anchorWarnings, ...insertWarnings]);
+      } catch (error) {
+        const member = batchMemberFor(_toolCallId);
+        if (member) noteBatchFailure(member, error);
+        throw error;
+      }
       return queuedEdit(targetPath, ctx.cwd, signal, async (absolutePath, mutationTargetPath) => {
+        const member = batchMemberFor(_toolCallId);
         const preload = await readNormFile(targetPath, ctx.cwd, {
           signal,
           accessMode: constants.R_OK | constants.W_OK,
           maxLines: MAX_HASH_LINES,
         });
         const { editParams, anchorLine } = buildInsertEdit(req, preload, ref, targetPath);
-        const pipe = await execPipeline(targetPath, editParams, ctx.cwd, {
-          accessMode: constants.R_OK | constants.W_OK,
-          signal,
-          preloadedNorm: preload,
-          skipBoundaryDedup: true,
-        });
-        return commitEdit(pipe, {
-          path: pipe.path,
-          absolutePath,
+        if (!member) {
+          const pipe = await execPipeline(targetPath, editParams, ctx.cwd, {
+            accessMode: constants.R_OK | constants.W_OK,
+            signal,
+            preloadedNorm: preload,
+            skipBoundaryDedup: true,
+          });
+          return commitEdit(pipe, {
+            path: pipe.path,
+            absolutePath,
+            mutationTargetPath,
+            signal,
+            verb: "inserted",
+            noopNoun: "Insertion",
+            foldedAnchorLines: anchorLine === undefined ? 0 : 1,
+            prefixWarnings: [...anchorWarnings, ...insertWarnings],
+            onApplied: () => clearBoundaryBypass(mutationTargetPath),
+          });
+        }
+        let hedit: HEdit;
+        const resWarnings: string[] = [];
+        try {
+          hedit = resEdit(editParams, resWarnings);
+        } catch (error) {
+          noteBatchFailure(member, error);
+          throw error;
+        }
+        return executeBatchMember({
+          kind: "insert",
+          member,
+          targetPath,
           mutationTargetPath,
+          cwd: ctx.cwd,
           signal,
-          verb: "inserted",
-          noopNoun: "Insertion",
-          foldedAnchorLines: anchorLine === undefined ? 0 : 1,
-          prefixWarnings: [...anchorWarnings, ...insertWarnings],
-          onApplied: () => clearBoundaryBypass(mutationTargetPath),
+          hedit,
+          extraWarnings: [...anchorWarnings, ...insertWarnings, ...resWarnings],
+          skipBoundaryDedup: true,
+          strictBoundaryDedup: false,
+          foldedLines: anchorLine === undefined ? 0 : 1,
         });
       });
     },

package/src/payload-contract.ts

@@ -32,7 +32,7 @@ export const editToolSchema = Type.Object(
     remove_to: removeToSchema,
     replacement_lines: replacementLinesSchema,
   },
-  { additionalProperties: false },
+  { additionalProperties: true },
 );
 
 export function buildEditToolSchema(requirePath: boolean): typeof editToolSchema {
@@ -44,7 +44,7 @@ export function buildEditToolSchema(requirePath: boolean): typeof editToolSchema
       remove_to: removeToSchema,
       replacement_lines: replacementLinesSchema,
     },
-    { additionalProperties: false },
+    { additionalProperties: true },
   ) as typeof editToolSchema;
 }
 
@@ -109,3 +109,31 @@ export function getPreviewInput(args: unknown): { path?: string; remove_from: st
     replacement_lines: normalized.replacement_lines as string[],
   };
 }
+
+const INSERT_KS = new Set(["path", "anchor", "direction", "lines"]);
+
+export interface InsertReq {
+  path?: string;
+  anchor: string;
+  direction: "before" | "after";
+  lines: string[];
+}
+
+export function assertInsertReq(request: unknown): asserts request is InsertReq {
+  if (!isRec(request)) {
+    throw new Error("[E_BAD_SHAPE] Insert request must be an object.");
+  }
+  rejectUnknownFields(request, INSERT_KS, "Insert request");
+  if (request.path !== undefined && typeof request.path !== "string") {
+    throw new Error('[E_BAD_SHAPE] Insert request field "path" must be a string when provided.');
+  }
+  if (typeof request.anchor !== "string" || request.anchor.length === 0) {
+    throw new Error('[E_BAD_SHAPE] Insert request requires an "anchor" string (4-char anchor from read output).');
+  }
+  if (request.direction !== "before" && request.direction !== "after") {
+    throw new Error('[E_BAD_SHAPE] Insert request "direction" must be "before" or "after".');
+  }
+  if (!Array.isArray(request.lines) || request.lines.some((line) => typeof line !== "string")) {
+    throw new Error('[E_BAD_SHAPE] Insert request requires "lines" as an array of strings, one element per line.');
+  }
+}

package/src/replace-response.ts

@@ -170,10 +170,10 @@ export function withDedupRows(diff: string, lineNumbers: (number | undefined)[],
   return { diff: out.join("\n"), lineNumbers: nums };
 }
 
-export function buildChanged(input: SuccessInput, verb = "replaced"): TResult {
+export function buildChanged(input: SuccessInput, verb = "replaced", diffContextLines = 1): TResult {
   const { path, result, warnings, snapshotId, originalNormalized, originalHashes, editMeta, resultHashes, boundaryDedupAbove, boundaryDedupBelow } = input;
   const resultLines = visLines(result);
-  const baseDiff = genDiff(originalNormalized, result, 1, resultHashes, originalHashes);
+  const baseDiff = genDiff(originalNormalized, result, diffContextLines, resultHashes, originalHashes);
   const diffResult = withDedupRows(baseDiff.diff, baseDiff.lineNumbers, boundaryDedupAbove, boundaryDedupBelow);
   const addedLines = editMeta.addedLines;
   const removedLines = editMeta.removedLines;

package/src/replace-undo.ts

@@ -11,6 +11,7 @@ import { markServed as markServedScoped, freeAnchors, adoptAnchors } from "./anc
 import { resolveInCwd, writeAtomic, type FileIdentity } from "./fs-write";
 import { toLF, stripBOM, restoreEndings, type LineEnding } from "./normalize";
 import { genDiff, genPatch } from "./replace-diff";
+import { getDiffContextLines } from "./config";
 import { cntDiff, errCode, makePrepareArguments, splitLines } from "./utils";
 import { loadP, loadGuide } from "./prompts";
 import { buildMetrics } from "./replace-response";
@@ -178,13 +179,13 @@ export function regUndo(pi: ExtensionAPI): void {
         const linesAddedByReplace = cntDiff(diffResult.diff, "+");
         const linesRemovedByReplace = cntDiff(diffResult.diff, "-");
         const restoredRange = changedRange(currentNormalized, undo.content);
-        const undoDiffResult = genDiff(currentNormalized, undo.content, 1, undo.hashes, currentHashes);
+        const undoDiffResult = genDiff(currentNormalized, undo.content, await getDiffContextLines(), undo.hashes, currentHashes);
         const undoDiff = undoDiffResult.diff;
 
         try {
           const store = await loadHashStore();
           const undoLines = splitLines(undo.content);
-          persistSnapshot(store, mutationTargetPath, undo.content, undo.hashes);
+          persistSnapshot(store, mutationTargetPath, undo.content, undo.hashes, undoLines.map((line) => contentChecksum(hashSource(line))));
           freeAnchors(mutationTargetPath);
           adoptAnchors(
             mutationTargetPath,

package/src/replace.ts

@@ -22,7 +22,6 @@ import { applyEdit,
   type HEdit,
   type NEdit,
 } from "./hashline";
-import { commitEdit } from "./commit";
 import { withDedupRows, type RMetrics } from "./replace-response";
 import {
   type RPreview,
@@ -33,7 +32,9 @@ 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, resolveEditTargetWithRequirement, throwIfStrictInput, isBoundaryDedupEnabled, withReplacePrompts, DEFAULT_EDIT_FLAGS, type EditToolFlags } from "./edit-common";
+import { queuedEdit, editToolBase, editRenderCallWrapper, editRenderResultWrapper, resolveEditTargetWithRequirement, throwIfStrictInput, getBoundaryDedupMode, withReplacePrompts, DEFAULT_EDIT_FLAGS, type EditToolFlags } from "./edit-common";
+import { commitEdit } from "./commit";
+import { batchMemberFor, executeBatchMember, noteBatchFailure } from "./batch";
 
 export { editToolSchema, type ReqParams, assertReq };
 
@@ -47,6 +48,7 @@ export type ReplaceDetails = {
   metrics?: RMetrics;
   diffLineNumbers?: (number|undefined)[];
   warnings?: string[];
+  batch?: { id: number; size: number; last: boolean; total: number };
 };
 
 export interface PipelineResult {
@@ -112,13 +114,7 @@ function countLineChanges(
   };
 }
 
-export async function execPipeline(
-  targetPath: string,
-  params: ReqParams,
-  cwd: string,
-  options?: ExecPipelineOptions,
-): Promise<PipelineResult> {
-
+export function buildReplaceHEdit(params: ReqParams): { edit: HEdit; warnings: string[] } {
   const editWarnings: string[] = [];
   let replacementLines = params.replacement_lines;
   const expandedReplacement = decodeStringArray(replacementLines);
@@ -134,7 +130,17 @@ export async function execPipeline(
     },
     editWarnings,
   );
+  return { edit, warnings: editWarnings };
+}
 
+export async function execPipeline(
+  targetPath: string,
+  params: ReqParams,
+  cwd: string,
+  options?: ExecPipelineOptions,
+): Promise<PipelineResult> {
+
+  const { edit, warnings: editWarnings } = buildReplaceHEdit(params);
   const hashStore = options?.store ?? await loadHashStore();
   const preResolvedPath = await resolveTarget(toCwd(targetPath, cwd));
   const served = servedForPath(preResolvedPath);
@@ -143,8 +149,9 @@ export async function execPipeline(
   );
   const displayPath = relative(cwd, absolutePath).replace(/\\/g, "/") || targetPath;
 
-  const dedupEnabled = await isBoundaryDedupEnabled();
-  const effectiveSkipBoundaryDedup = options?.skipBoundaryDedup === true || !dedupEnabled;
+  const dedupMode = await getBoundaryDedupMode();
+  const effectiveSkipBoundaryDedup = options?.skipBoundaryDedup === true || dedupMode === "off";
+  const strictBoundaryDedup = options?.skipBoundaryDedup !== true && dedupMode === "strict";
   let anchorResult: ReturnType<typeof applyEdit>;
   try {
     anchorResult = applyEdit(
@@ -155,6 +162,7 @@ export async function execPipeline(
       displayPath,
       served,
       effectiveSkipBoundaryDedup,
+      strictBoundaryDedup,
     );
   } catch (error) {
     await noteAnchorError(absolutePath, error, originalHashes, options?.noPersist);
@@ -275,29 +283,61 @@ export function buildToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): ToolDef
         removeTo: normalizedParams.remove_to,
         providedPath: normalizedParams.path,
         cwd: ctx.cwd,
+      }).catch((error: unknown) => {
+        const member = batchMemberFor(_toolCallId);
+        if (member) noteBatchFailure(member, error);
+        throw error;
       });
       return queuedEdit(targetPath, ctx.cwd, signal, async (absolutePath, mutationTargetPath) => {
-        const dedupOn = await isBoundaryDedupEnabled();
+        const dedupMode = await getBoundaryDedupMode();
+        const dedupOn = dedupMode !== "off";
         const noopPayload = noopPayloadKey(mutationTargetPath, normalizedParams.remove_from, normalizedParams.remove_to, normalizedParams.replacement_lines);
         const boundaryBypass = dedupOn ? consumeBoundaryBypass(mutationTargetPath, noopPayload) : false;
-        const pipe = await execPipeline(
-          targetPath,
-          normalizedParams,
-          ctx.cwd,
-          { accessMode: constants.R_OK | constants.W_OK, signal, skipBoundaryDedup: boundaryBypass },
-        );
+        const strictBoundaryDedup = dedupMode === "strict" && !boundaryBypass;
+        const member = batchMemberFor(_toolCallId);
+        if (!member) {
+          const pipe = await execPipeline(
+            targetPath,
+            normalizedParams,
+            ctx.cwd,
+            { accessMode: constants.R_OK | constants.W_OK, signal, skipBoundaryDedup: boundaryBypass },
+          );
+          const appliedWarnings = boundaryBypass
+            ? ["[W_BOUNDARY_BYPASS] Boundary dedup was off for this call and is back on."]
+            : [];
+          return commitEdit(pipe, {
+            path: pipe.path,
+            absolutePath,
+            mutationTargetPath,
+            editAnchors: [normalizedParams.remove_from, normalizedParams.remove_to],
+            signal,
+            appliedWarnings,
+            onApplied: () => { if (dedupOn) clearBoundaryBypass(mutationTargetPath); },
+            onNoopDedup: dedupOn ? () => markBoundaryNoop(mutationTargetPath, noopPayload) : undefined,
+          });
+        }
+        let built: { edit: HEdit; warnings: string[] };
+        try {
+          built = buildReplaceHEdit(normalizedParams);
+        } catch (error) {
+          noteBatchFailure(member, error);
+          throw error;
+        }
         const appliedWarnings = boundaryBypass
           ? ["[W_BOUNDARY_BYPASS] Boundary dedup was off for this call and is back on."]
           : [];
-        return commitEdit(pipe, {
-          path: pipe.path,
-          absolutePath,
+        return executeBatchMember({
+          kind: "replace",
+          member,
+          targetPath,
           mutationTargetPath,
-          editAnchors: [normalizedParams.remove_from, normalizedParams.remove_to],
+          cwd: ctx.cwd,
           signal,
-          appliedWarnings,
-          onApplied: () => { if (dedupOn) clearBoundaryBypass(mutationTargetPath); },
-          onNoopDedup: dedupOn ? () => markBoundaryNoop(mutationTargetPath, noopPayload) : undefined,
+          hedit: built.edit,
+          extraWarnings: [...built.warnings, ...appliedWarnings],
+          skipBoundaryDedup: boundaryBypass,
+          strictBoundaryDedup,
+          noopPayload,
         });
       });
     },

package/src/write-hook.ts

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