pi-hashline-edit-pro 4.2.1 → 4.2.2

package/src/hashline/apply.ts

@@ -174,11 +174,13 @@ export function planEdit(
     skipBoundaryDedup?: boolean;
     strictBoundaryDedup?: boolean;
     signal?: AbortSignal;
+    baseFileLines?: string[];
   },
 ): PlannedEdit {
   const signal = options?.signal;
   abortIf(signal);
-  const lineIndex = buildIdx(content);
+  const fileLines = options?.baseFileLines ?? buildIdx(content).fileLines;
+  const lineIndex = { fileLines };
   const fileHashes = precomputedHashes;
   const warnings: string[] = [];
 

package/src/hashline/resolve.ts

@@ -540,7 +540,7 @@ export function assertRangeServed(
       ? `\n\n[The range has ${rangeLength} lines; showing the first ${shownLength}. Call read()${filePath ? ` on ${filePath}` : ""} with offset=${startLine + shownLength} to see the rest.]`
       : "\n\nRetry with the fresh anchors above without a read.";
   const message =
-    `[E_RANGE_STALE] ${mismatchText} what was shown. Nothing was modified. Current range with fresh anchors:\n\n${rows.join("\n")}${capHint}`;
+    `[E_RANGE_STALE] ${mismatchText} what was shown. Current range with fresh anchors:\n\n${rows.join("\n")}${capHint}`;
   throw new RangeStaleError(message, shownHashes, shownMap);
 }
 

package/src/insert.ts

@@ -3,7 +3,7 @@ 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 { batchMemberFor, ensureBatchBase, executeBatchMember, noteBatchFailure, suffixPoisonCause } from "./batch";
 import { readNormFile, type NormFile } from "./file-reader";
 import { MAX_HASH_LINES, parseHashRef, resEdit, resolveAnchorLine, type Anchor, type HEdit } from "./hashline";
 import { stripAnchorRow } from "./hashline/resolve";
@@ -193,6 +193,7 @@ export function buildInsertToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): I
       }).catch((error: unknown) => {
         const member = batchMemberFor(_toolCallId);
         if (member) noteBatchFailure(member, error);
+        else suffixPoisonCause(_toolCallId, error);
         throw error;
       });
       let ref: Anchor;
@@ -207,51 +208,54 @@ export function buildInsertToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): I
       }
       return queuedEdit(targetPath, ctx.cwd, signal, async (absolutePath, mutationTargetPath) => {
         const member = batchMemberFor(_toolCallId);
+        if (member) {
+          const base = await ensureBatchBase({ member, targetPath, mutationTargetPath, cwd: ctx.cwd, signal });
+          const basePreload = { normalized: base.content, fileHashes: base.hashes } as NormFile;
+          const built = buildInsertEdit(req, basePreload, ref, targetPath);
+          let hedit: HEdit;
+          const resWarnings: string[] = [];
+          try {
+            hedit = resEdit(built.editParams, resWarnings);
+          } catch (error) {
+            noteBatchFailure(member, error);
+            throw error;
+          }
+          return executeBatchMember({
+            kind: "insert",
+            member,
+            targetPath,
+            mutationTargetPath,
+            cwd: ctx.cwd,
+            signal,
+            hedit,
+            extraWarnings: [...anchorWarnings, ...insertWarnings, ...resWarnings],
+            skipBoundaryDedup: true,
+            strictBoundaryDedup: false,
+            foldedLines: built.anchorLine === undefined ? 0 : 1,
+          });
+        }
         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);
-        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,
+        const pipe = await execPipeline(targetPath, editParams, ctx.cwd, {
+          accessMode: constants.R_OK | constants.W_OK,
           signal,
-          hedit,
-          extraWarnings: [...anchorWarnings, ...insertWarnings, ...resWarnings],
+          preloadedNorm: preload,
           skipBoundaryDedup: true,
-          strictBoundaryDedup: false,
-          foldedLines: anchorLine === undefined ? 0 : 1,
+        });
+        return commitEdit(pipe, {
+          path: pipe.path,
+          absolutePath,
+          mutationTargetPath,
+          signal,
+          verb: "inserted",
+          noopNoun: "Insertion",
+          foldedAnchorLines: anchorLine === undefined ? 0 : 1,
+          prefixWarnings: [...anchorWarnings, ...insertWarnings],
+          onApplied: () => clearBoundaryBypass(mutationTargetPath),
         });
       });
     },

package/src/replace.ts

@@ -34,7 +34,7 @@ import { toCwd } from "./paths";
 import { noopPayloadKey, markBoundaryNoop, consumeBoundaryBypass, clearBoundaryBypass } from "./boundary-bypass";
 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";
+import { batchMemberFor, executeBatchMember, noteBatchFailure, suffixPoisonCause } from "./batch";
 
 export { editToolSchema, type ReqParams, assertReq };
 
@@ -286,6 +286,7 @@ export function buildToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): ToolDef
       }).catch((error: unknown) => {
         const member = batchMemberFor(_toolCallId);
         if (member) noteBatchFailure(member, error);
+        else suffixPoisonCause(_toolCallId, error);
         throw error;
       });
       return queuedEdit(targetPath, ctx.cwd, signal, async (absolutePath, mutationTargetPath) => {
@@ -296,31 +297,38 @@ export function buildToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): ToolDef
         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,
-          });
+          try {
+            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 await 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,
+            });
+          } catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            if (boundaryBypass && !detail.includes("File was written;")) markBoundaryNoop(mutationTargetPath, noopPayload);
+            throw error;
+          }
         }
         let built: { edit: HEdit; warnings: string[] };
         try {
           built = buildReplaceHEdit(normalizedParams);
         } catch (error) {
           noteBatchFailure(member, error);
+          if (boundaryBypass) markBoundaryNoop(mutationTargetPath, noopPayload);
           throw error;
         }
         const appliedWarnings = boundaryBypass
@@ -338,6 +346,7 @@ export function buildToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): ToolDef
           skipBoundaryDedup: boundaryBypass,
           strictBoundaryDedup,
           noopPayload,
+          bypassConsumed: boundaryBypass,
         });
       });
     },

package/src/validation.ts

@@ -32,10 +32,10 @@ export function valKind(file: LFile, path: string): asserts file is { kind: "tex
 		throw new Error(`[E_NOT_TEXT] Path is a directory: ${path}. Use ls to inspect directories.`);
 	}
 	if (file.kind === "binary") {
-		throw new Error(`[E_NOT_TEXT] Path is a binary file: ${path} (${file.description}). Hashline edit only supports text files.`);
+		throw new Error(`[E_NOT_TEXT] Path is a binary file: ${path} (${file.description}).`);
 	}
 	if (file.kind === "image") {
-		throw new Error(`[E_NOT_TEXT] Path is an image file: ${path}. Hashline edit only supports text files.`);
+		throw new Error(`[E_NOT_TEXT] Path is an image file: ${path}.`);
 	}
 	if (file.kind === "too_large") {
 		throw new Error(

package/src/write-hook.ts

@@ -31,7 +31,7 @@ export async function servedHashEchoDenial(rawPath: string, content: string, cwd
   if (!served || served.size === 0) return undefined;
   const echo = findServedHashEcho(content, served);
   if (!echo) return undefined;
-  return `[E_WRITE_HASH_ECHO] Refused write to ${rawPath}: line ${echo.line} begins with the exact ${echo.hash}${HASH_SEP} anchor served for this file. Remove the copied anchors and retry. Nothing was written.`;
+  return `[E_WRITE_HASH_ECHO] Refused write to ${rawPath}: line ${echo.line} begins with the exact ${echo.hash}${HASH_SEP} anchor served for this file. Remove the copied anchors and retry.`;
 }
 
 export function registerWriteHook(pi: ExtensionAPI): void {