pi-hashline-edit-pro 4.1.0 → 4.2.0

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