pi-hashline-edit-pro 4.0.1 → 4.2.0

package/src/read.ts

@@ -15,18 +15,16 @@ import { lineHashes, fmtRegion, fmtRow, HASH_SEP, MAX_HASH_LINES } from "./hashl
 import { toCwd } from "./paths";
 import { abortIf, makePrepareArguments, numberedRead, visLines, splitLines } from "./utils";
 import { loadP, loadGuide } from "./prompts";
+import { withReadPrompts, DEFAULT_EDIT_FLAGS, type EditToolFlags } from "./edit-common";
 import { valAccess } from "./validation";
 import { markServed as markServedScoped } from "./anchor-registry";
 import { buildServedMap } from "./served";
 import { Text } from "@earendil-works/pi-tui";
 const R_DESC = loadP("../prompts/read.md");
-
 const R_SNIPPET = loadP("../prompts/read-snippet.md");
-
 function readGuide(): string[] {
-	return loadGuide("../prompts/read-guidelines.md");
+  return loadGuide("../prompts/read-guidelines.md");
 }
-
 function normPosInt(
 	value: number | undefined,
 	name: "offset" | "limit",
@@ -166,13 +164,14 @@ export async function fmtReadPreview(
 	};
 }
 
-export function regRead(pi: ExtensionAPI): void {
-	pi.registerTool({
-		name: "read",
-		label: "Read",
-		description: R_DESC,
-		promptSnippet: R_SNIPPET,
-		promptGuidelines: readGuide(),
+export function regRead(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FLAGS): void {
+  const prompted = withReadPrompts({ description: R_DESC, snippet: R_SNIPPET, guidelines: readGuide() }, flags);
+  pi.registerTool({
+    name: "read",
+    label: "Read",
+    description: prompted.description,
+    promptSnippet: prompted.snippet,
+    promptGuidelines: prompted.guidelines,
 		prepareArguments: makePrepareArguments(),
 		parameters: Type.Object({
 			path: Type.String({

package/src/replace-render.ts

@@ -128,7 +128,7 @@ export function isApplied(
 
 const RESULT_PREVIEW_LINES = 16;
 
-function expandHint(): string {
+export function expandHint(): string {
 	try {
 		return keyHint("app.tools.expand", "to expand");
 	} catch {
@@ -165,7 +165,7 @@ export function buildAppliedText(
 				: "";
 		sections.push(`${diffSection}${hint}`);
 	}
-	const warnings = extractWarnings(text);
+	const warnings = details?.warnings?.length ? `Warnings:\n${details.warnings.join("\n")}` : extractWarnings(text);
 	if (warnings) sections.push(warnings);
 	return sections.length > 0 ? sections.join("\n\n") : undefined;
 }

package/src/replace-response.ts

@@ -125,7 +125,8 @@ export function buildNoop(input: NoopInput, noopNoun = "Replacement"): TResult {
 			firstChangedLine: undefined,
 			snapshotId,
 			classification: "noop" as const,
-			metrics,
+      metrics,
+      ...(warnings?.length ? { warnings: [...warnings] } : {}),
 		},
 	};
 }
@@ -210,6 +211,7 @@ export function buildChanged(input: SuccessInput, verb = "replaced"): TResult {
       snapshotId,
       metrics,
       diffLineNumbers: diffResult.lineNumbers,
+      ...(warnings?.length ? { warnings: [...warnings] } : {}),
     },
   };
 }

package/src/replace.ts

@@ -9,7 +9,7 @@ import {
   type LineEnding,
 } from "./replace-diff";
 import { readNormFile, type NormFile } from "./file-reader";
-import { editToolSchema, type ReqParams, assertReq, normReq } from "./payload-contract";
+import { editToolSchema, buildEditToolSchema, type ReqParams, assertReq, normReq } from "./payload-contract";
 import { decodeStringArray } from "./utils";
 import { loadP, loadGuide } from "./prompts";
 import { type FileIdentity } from "./fs-write";
@@ -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, resolveEditTarget } 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 };
 
@@ -46,6 +47,8 @@ export type ReplaceDetails = {
   classification?: "noop";
   metrics?: RMetrics;
   diffLineNumbers?: (number|undefined)[];
+  warnings?: string[];
+  batch?: { id: number; size: number; last: boolean; total: number };
 };
 
 export interface PipelineResult {
@@ -111,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);
@@ -133,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);
@@ -142,6 +149,9 @@ export async function execPipeline(
   );
   const displayPath = relative(cwd, absolutePath).replace(/\\/g, "/") || targetPath;
 
+  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(
@@ -151,7 +161,8 @@ export async function execPipeline(
       originalHashes,
       displayPath,
       served,
-      options?.skipBoundaryDedup,
+      effectiveSkipBoundaryDedup,
+      strictBoundaryDedup,
     );
   } catch (error) {
     await noteAnchorError(absolutePath, error, originalHashes, options?.noPersist);
@@ -168,6 +179,7 @@ export async function execPipeline(
         hashes: originalHashes,
       }, hashStore, false, true);
   const warnings = [...editWarnings, ...(anchorResult.warnings ?? [])];
+  await throwIfStrictInput(warnings);
   const { totalAddedLines, totalRemovedLines } = countLineChanges(
     edit, originalHashes, isNoop, anchorResult.autoFixes?.length ?? 0,
   );
@@ -220,7 +232,12 @@ export async function compPreview(
   try {
     const normalized = normReq(request);
     assertReq(normalized);
-    const targetPath = resolveEditTarget(normalized.remove_from, normalized.remove_to);
+    const targetPath = await resolveEditTargetWithRequirement({
+      removeFrom: (normalized as ReqParams).remove_from,
+      removeTo: (normalized as ReqParams).remove_to,
+      providedPath: (normalized as ReqParams).path,
+      cwd,
+    });
     const pipe = await execPipeline(
       targetPath,
       normalized,
@@ -240,18 +257,20 @@ type ToolDef = ToolDefinition<
   RRState
 > & { renderShell?: "default" | "self" };
 
-export function buildToolDef(): ToolDef {
-  const E_DESC = loadP("../prompts/replace.md");
-  const E_SNIPPET = loadP("../prompts/replace-snippet.md");
-  const E_GUIDE = loadGuide("../prompts/replace-guidelines.md");
-  const parameters = editToolSchema;
+export function buildToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): ToolDef {
+  const prompted = withReplacePrompts({
+    description: loadP("../prompts/replace.md"),
+    snippet: loadP("../prompts/replace-snippet.md"),
+    guidelines: loadGuide("../prompts/replace-guidelines.md"),
+  }, flags);
+  const parameters = buildEditToolSchema(flags.requirePath);
   return {
     name: "replace",
     label: "Replace",
-    description: E_DESC,
+    description: prompted.description,
     parameters,
-    promptSnippet: E_SNIPPET,
-    promptGuidelines: E_GUIDE,
+    promptSnippet: prompted.snippet,
+    promptGuidelines: prompted.guidelines,
     ...editToolBase,
     renderCall: editRenderCallWrapper(compPreview),
     renderResult: editRenderResultWrapper,
@@ -259,34 +278,72 @@ export function buildToolDef(): ToolDef {
       const canonical = normReq(params);
       assertReq(canonical);
       const normalizedParams = canonical;
-      const targetPath = resolveEditTarget(normalizedParams.remove_from, normalizedParams.remove_to);
+      const targetPath = await resolveEditTargetWithRequirement({
+        removeFrom: normalizedParams.remove_from,
+        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 dedupMode = await getBoundaryDedupMode();
+        const dedupOn = dedupMode !== "off";
         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 boundaryBypass = dedupOn ? consumeBoundaryBypass(mutationTargetPath, noopPayload) : false;
+        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: () => clearBoundaryBypass(mutationTargetPath),
-          onNoopDedup: () => markBoundaryNoop(mutationTargetPath, noopPayload),
+          hedit: built.edit,
+          extraWarnings: [...built.warnings, ...appliedWarnings],
+          skipBoundaryDedup: boundaryBypass,
+          strictBoundaryDedup,
+          noopPayload,
         });
       });
     },
   };
 }
 
-export function regReplace(pi: ExtensionAPI): void {
-  pi.registerTool(buildToolDef());
+export function regReplace(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FLAGS): void {
+  pi.registerTool(buildToolDef(flags));
 }