pi-hashline-edit-pro 6.4.0 → 6.4.1

package/README.md

@@ -315,7 +315,7 @@ Multiple `replace`, `replace_match`, `insert`, `copy`, and `move` calls on the s
 - A call outside a batch commits before its result returns.
 - A cross-file `move` whose source file also has batched edits in the same message is not grouped: it commits on its own, and a pending same-file batch aborts safely with `[E_OP_ABORTED]` if the file changed under it.
 - A batched cross-file `move` displays only the destination diff: the arrival is covered by the batch's undo, and the source removal is committed with the same batch but is not shown. Read the source file for fresh anchors; it keeps its own undo entry, and `details.patch` still contains the source patch.
-- A batch validates every call against the pre-batch state and commits once, during the batch's last applied call: earlier applied calls reply `In batch N (queued)`, and the batch's last applied call shows the combined diff, with one undo reverting the whole batch. A `copy` always duplicates the content its source anchors were served from: when the source file is also edited in the message, the copy reads that file's pre-batch state, even if the source batch commits before the copy runs. A batched cross-file `move` defers the source-file removal to the batch commit, so if the batch aborts, the source file is untouched.
+- A batch validates every call against the pre-batch state and commits once, during the batch's last applied call: earlier applied calls reply `In batch N (queued)`, and the batch's last applied call shows the combined diff, with one undo reverting the whole batch. A `copy` always duplicates the content its source anchors were served from: when the source file is also edited in the message, the copy reads that file's pre-edit state, even if the source batch commits before the copy runs. A batched cross-file `move` defers the source-file removal to the batch commit, so if the batch aborts, the source file is untouched.
 - Before committing, the batch validates every call against the pre-batch state. A call whose own request is invalid (`[E_BAD_SHAPE]`, `[E_BAD_REF]`, `[E_STALE_ANCHOR]`, `[E_RANGE_STALE]`, `[E_SUBSTRING_NOT_FOUND]`, or a strict-input rejection) is left out: it fails on its own call without an `Aborts batch N.` suffix, and the remaining calls still commit as one batch with one undo. A failure of the file, the commit, or a cross-file member aborts the whole batch instead: nothing is written, the failing call's error ends with `Aborts batch N.`, and an earlier member's row renders the abort message instead of the queued placeholder.
 - A batch member accepts the same request shapes and auto-fixes as a standalone call.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "6.4.0",
+  "version": "6.4.1",
   "type": "module",
   "description": "Hash-anchored read/replace/insert/grep tools for pi-coding-agent. Every line gets a unique 4-char tokenizer-friendly anchor that stays stable across edits; stale or ambiguous anchors are rejected, never fuzzy-matched. Undo persists across restarts.",
   "main": "index.ts",

package/src/batch.ts

@@ -4,6 +4,7 @@ import { toDisplayPath } from "./paths";
 import { readConfig, getDiffContextLines } from "./config";
 import { throwIfStrictInput, tryResolveEditTarget } from "./edit-common";
 import { readNormFile, safeSnapId } from "./file-reader";
+import { clearPreEditSnapshots, recordPreEditSnapshot } from "./pre-edit-snapshot";
 import { resolveInCwd, writeAtomic, type FileIdentity } from "./fs-write";
 import {
   AnchorMismatchError,
@@ -27,7 +28,7 @@ import { saveUndo } from "./replace-undo";
 import { buildChanged, buildNoop, type RMetrics, type TResult } from "./replace-response";
 import { toEditVerb, withStructuredText, type EditStructured } from "./structured";
 import { serveRows, servedHashesFromDiff } from "./served";
-import { abortIf, assertByteLimit, assertLineLimit, errCode, isRec, splitLines } from "./utils";
+import { abortIf, assertByteLimit, assertLineLimit, errCode, isRec, mapIoError, splitLines } from "./utils";
 
 export interface PlannedMember {
   batchKey: number;
@@ -231,7 +232,9 @@ export function abortedBatchMessageFor(toolCallId: string): string | undefined {
 }
 
 export function batchMemberFor(toolCallId: string): PlannedMember | undefined {
-  return plan.get(toolCallId);
+  const member = plan.get(toolCallId);
+  if (!member || !batches.has(member.batchKey)) return undefined;
+  return member;
 }
 
 export function pendingBatchMemberFor(path: string): PlannedMember | undefined {
@@ -255,6 +258,7 @@ export function resetBatchStateForTests(): void {
   abortedMembers.clear();
   placeholderResults.clear();
   nextBatchKey = 1;
+  clearPreEditSnapshots();
 }
 
 function normalizeEditArgs(name: string, args: unknown): NormalizedEditArgs | undefined {
@@ -371,7 +375,9 @@ function enforceCap(): void {
 }
 
 export async function planAssistantMessage(message: unknown, cwd: string): Promise<void> {
-  if (!isRec(message) || message.role !== "assistant" || !Array.isArray(message.content)) return;
+  if (!isRec(message) || message.role !== "assistant") return;
+  clearPreEditSnapshots();
+  if (!Array.isArray(message.content)) return;
   const calls: EditCall[] = [];
   for (const block of message.content) {
     if (!isRec(block) || block.type !== "toolCall") continue;
@@ -931,12 +937,24 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
     const snapshotId = await safeSnapId(paths.absolutePath, "noop edit");
     return combinedNoop(paths.displayPath, member, runtime, snapshotId);
   }
+
+  recordPreEditSnapshot({
+    absolutePath: runtime.target,
+    normalized: base.content,
+    bom: base.bom,
+    originalEnding: base.ending,
+    endingSeparators: base.separators,
+    fileHashes: base.hashes,
+    hadUtf8DecodeErrors: base.hadUtf8DecodeErrors,
+    identity: base.identity,
+    served: runtime.served ? new Map(runtime.served) : undefined,
+  });
   abortIf(signal);
   let currentRaw: string;
   try {
     currentRaw = await readFile(runtime.target, "utf-8");
   } catch (error) {
-    if (errCode(error) !== "ENOENT") throw error;
+    if (errCode(error) !== "ENOENT") throw mapIoError(error, "read", runtime.target);
     discardBatchState(runtime);
     throw new Error(`[E_OP_ABORTED] Batch ${runtime.display} aborted: the file was deleted after the batch started.`);
   }
@@ -962,7 +980,7 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
     try {
       sourceRaw = await readFile(source.mutationTargetPath, "utf-8");
     } catch (error) {
-      if (errCode(error) !== "ENOENT") throw error;
+      if (errCode(error) !== "ENOENT") throw mapIoError(error, "read", source.displayPath);
       sourceRaw = undefined;
     }
     if (sourceRaw === undefined || toLF(stripBOM(sourceRaw).text) !== source.pipe.originalNormalized) {
@@ -1196,4 +1214,5 @@ export async function finalizeTurn(toolCallIds: string[]): Promise<void> {
     }
     batches.delete(key);
   }
+  clearPreEditSnapshots();
 }

package/src/commit.ts

@@ -1,13 +1,14 @@
 import { readFile } from "node:fs/promises";
 import type { PipelineResult } from "./replace";
-import { abortIf, assertByteLimit, errCode, splitLines } from "./utils";
+import { abortIf, assertByteLimit, errCode, mapIoError, splitLines } from "./utils";
 import { buildChanged, buildNoop, type RMeta, type TResult } from "./replace-response";
 import { saveUndo } from "./replace-undo";
 import { getDiffContextLines } from "./config";
 import { safeSnapId } from "./file-reader";
 import { writeAtomic } from "./fs-write";
-import { formatAnchorReclaimNotice, takeReclaimedPaths } from "./anchor-registry";
+import { formatAnchorReclaimNotice, servedForPath, takeReclaimedPaths } from "./anchor-registry";
 import { servedHashesFromDiff, serveRows } from "./served";
+import { recordPreEditSnapshot } from "./pre-edit-snapshot";
 import { lineHashes } from "./hashline";
 import { spanForEdit } from "./replace";
 import { restoreEndings, stripBOM, toLF, type LineEnding } from "./normalize";
@@ -69,6 +70,19 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
     );
   }
 
+  const served = servedForPath(mutationTargetPath);
+  recordPreEditSnapshot({
+    absolutePath: mutationTargetPath,
+    normalized: pipe.originalNormalized,
+    bom: pipe.bom,
+    originalEnding: pipe.originalEnding,
+    endingSeparators: pipe.originalSeparators,
+    fileHashes: pipe.originalHashes,
+    hadUtf8DecodeErrors: pipe.hadUtf8DecodeErrors,
+    identity: pipe.identity,
+    served: served ? new Map(served) : undefined,
+  });
+
   assertByteLimit(finalFileBytes, path);
 
   if (pipe.hadUtf8DecodeErrors) {
@@ -86,7 +100,7 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
     if (code === "ENOENT") currentRaw = undefined;
     else if (code === "EACCES" || code === "EPERM") throw new Error(`[E_ACCESS] File is not readable: ${path}`);
     else if (code === "ELOOP") throw new Error(`[E_ACCESS] Too many symbolic links while resolving: ${path}`);
-    else throw error;
+    else throw mapIoError(error, "read", path);
   }
   if (currentRaw === undefined) {
     throw new Error(`[E_OP_ABORTED] Edit aborted: the file was deleted after the edit started.`);

package/src/copy-move.ts

@@ -5,6 +5,7 @@ import { constants } from "node:fs";
 import { execPipeline, noteAnchorError, previewFromPipe, previewError, type PipelineResult, type ReplaceDetails } from "./replace";
 import { commitEdit } from "./commit";
 import { readNormFile, safeSnapId, type NormFile } from "./file-reader";
+import { preEditSnapshotFor } from "./pre-edit-snapshot";
 import {
   lineHashes,
   MAX_HASH_LINES,
@@ -236,11 +237,17 @@ async function prepareCrossTransfer(input: {
   const { kind, refs, sourcePath, destinationPath, cwd, signal, noPersist } = input;
   const common = { signal, maxLines: MAX_HASH_LINES };
   const sourceAccessMode = kind === "move" ? constants.R_OK | constants.W_OK : constants.R_OK;
-  const sourcePreload = input.sourcePreload ?? (await readNormFile(sourcePath, cwd, noPersist ? { ...common, accessMode: constants.R_OK, noPersist: true, allocation: "shadow" } : { ...common, accessMode: sourceAccessMode }));
+  const candidate = kind === "copy" && input.sourcePreload === undefined ? preEditSnapshotFor(sourcePath) : undefined;
+  const snapshotPreload = candidate !== undefined
+    && candidate.fileHashes.includes(refs.sourceFrom.hash)
+    && candidate.fileHashes.includes(refs.sourceTo.hash)
+    ? candidate
+    : undefined;
+  const sourcePreload = input.sourcePreload ?? snapshotPreload ?? (await readNormFile(sourcePath, cwd, noPersist ? { ...common, accessMode: constants.R_OK, noPersist: true, allocation: "shadow" } : { ...common, accessMode: sourceAccessMode }));
   const destinationPreload = input.destinationPreload ?? (await readNormFile(destinationPath, cwd, noPersist ? { ...common, accessMode: constants.R_OK, noPersist: true, allocation: "shadow" } : { ...common, accessMode: constants.R_OK | constants.W_OK }));
   const sourceDisplay = toDisplayPath(cwd, sourcePreload.absolutePath, sourcePath);
   const destinationDisplay = toDisplayPath(cwd, destinationPreload.absolutePath, destinationPath);
-  const sourceServed = input.sourceServed ?? servedForPath(sourcePreload.absolutePath);
+  const sourceServed = input.sourceServed ?? (snapshotPreload !== undefined ? snapshotPreload.served : servedForPath(sourcePreload.absolutePath));
   const destinationServed = input.destinationServed ?? servedForPath(destinationPreload.absolutePath);
   const sourceLines = splitLines(sourcePreload.normalized);
   const destinationLines = splitLines(destinationPreload.normalized);
@@ -667,7 +674,7 @@ async function executeBatchCrossCopy(
     const sourceMember = pendingBatchMemberFor(sourcePath);
     const sourcePreload = sourceMember
       ? preloadFromBase(await ensureBatchBase({ member: sourceMember, targetPath: sourcePath, mutationTargetPath: sourceMember.target, cwd, signal }))
-      : await readNormFile(sourcePath, cwd, { signal, accessMode: constants.R_OK, maxLines: MAX_HASH_LINES });
+      : undefined;
     prepared = await prepareCrossTransfer({
       kind: "copy",
       refs,

package/src/fs-write.ts

@@ -13,7 +13,7 @@ import {
 } from "node:fs/promises";
 import { dirname, join, parse, resolve, sep } from "node:path";
 import { toCwd } from "./paths";
-import { errCode, isModeUnsupported } from "./utils";
+import { errCode, isModeUnsupported, mapIoError } from "./utils";
 
 export interface FileIdentity {
   dev: number;
@@ -138,7 +138,7 @@ export async function resolveInCwd(path: string, cwd: string): Promise<{ absolut
   const resolved = await resolveTarget(absolute);
   return { absolute, resolved };
 }
-export async function writeAtomic(
+async function writeAtomicRaw(
   path: string,
   content: string,
   expectedIdentity?: FileIdentity,
@@ -223,3 +223,15 @@ export async function writeAtomic(
     throw error;
   }
 }
+export async function writeAtomic(
+  path: string,
+  content: string,
+  expectedIdentity?: FileIdentity,
+  restoreMode?: number,
+): Promise<void> {
+  try {
+    await writeAtomicRaw(path, content, expectedIdentity, restoreMode);
+  } catch (error) {
+    throw mapIoError(error, "write", path);
+  }
+}

package/src/line-endings.ts

@@ -35,9 +35,13 @@ export function splitSeparators(raw: string): LineEnding[] {
 export function joinSeparators(content: string, separators: readonly LineEnding[]): string {
 	let out = "";
 	let separatorIndex = 0;
-	for (const char of content) {
+	for (let index = 0; index < content.length; index += 1) {
+		const char = content[index]!;
 		if (char === "\n") {
-			out += separators[separatorIndex] ?? "\n";
+			const separator = separators[separatorIndex] ?? "\n";
+			const emptyLineBefore = content[index - 1] === "\n";
+			const followsLoneCr = separator === "\n" && separators[separatorIndex - 1] === "\r" && emptyLineBefore;
+			out += followsLoneCr ? "\r\n" : separator;
 			separatorIndex += 1;
 		} else {
 			out += char;

package/src/pre-edit-snapshot.ts

@@ -0,0 +1,19 @@
+import type { NormFile } from "./file-reader";
+
+export interface PreEditSnapshot extends NormFile {
+  served?: ReadonlyMap<string, string>;
+}
+
+const snapshots = new Map<string, PreEditSnapshot>();
+
+export function recordPreEditSnapshot(snapshot: PreEditSnapshot): void {
+  snapshots.set(snapshot.absolutePath, snapshot);
+}
+
+export function preEditSnapshotFor(path: string): PreEditSnapshot | undefined {
+  return snapshots.get(path);
+}
+
+export function clearPreEditSnapshots(): void {
+  snapshots.clear();
+}

package/src/replace-diff.ts

@@ -163,6 +163,8 @@ function trimPlacedSpans(
   placed: PlacedSpan[],
   oldLines: string[],
   newLines: string[],
+  oldHashes: string[],
+  newHashes: string[],
 ): PlacedSpan[] {
   const out: PlacedSpan[] = [];
   for (const span of placed) {
@@ -170,11 +172,11 @@ function trimPlacedSpans(
     let oldEnd = span.oldEnd;
     let newStart = span.newStart;
     let newEnd = span.newEnd;
-    while (oldStart <= oldEnd && newStart <= newEnd && oldLines[oldStart] === newLines[newStart]) {
+    while (oldStart <= oldEnd && newStart <= newEnd && oldLines[oldStart] === newLines[newStart] && oldHashes[oldStart] === newHashes[newStart]) {
       oldStart += 1;
       newStart += 1;
     }
-    while (oldStart <= oldEnd && newStart <= newEnd && oldLines[oldEnd] === newLines[newEnd]) {
+    while (oldStart <= oldEnd && newStart <= newEnd && oldLines[oldEnd] === newLines[newEnd] && oldHashes[oldEnd] === newHashes[newEnd]) {
       oldEnd -= 1;
       newEnd -= 1;
     }
@@ -251,7 +253,7 @@ function genSpanDiff(
   if (oldHashes.length !== oldLines.length || newHashes.length !== newLines.length) return undefined;
   const placed = placeSpans(oldLines.length, newLines.length, spans);
   if (!placed) return undefined;
-  const trimmed = trimPlacedSpans(placed, oldLines, newLines);
+  const trimmed = trimPlacedSpans(placed, oldLines, newLines, oldHashes, newHashes);
   const ordered = [...trimmed].sort((a, b) => a.oldStart - b.oldStart || a.newStart - b.newStart);
   let oldPos = 0;
   let newPos = 0;

package/src/replace-undo.ts

@@ -12,7 +12,7 @@ import { toLF, stripBOM, restoreEndings, type LineEnding } from "./normalize";
 import { joinSeparators } from "./line-endings";
 import { genDiff, genPatch, spansFromHashes } from "./replace-diff";
 import { getDiffContextLines } from "./config";
-import { cntDiff, errCode, makePrepareArguments, splitLines } from "./utils";
+import { cntDiff, errCode, makePrepareArguments, mapIoError, splitLines } from "./utils";
 import { loadP, loadGuidelines } from "./prompts";
 import { withUndoPrompts, DEFAULT_EDIT_FLAGS, type EditToolFlags } from "./edit-common";
 import { buildMetrics } from "./replace-response";
@@ -166,7 +166,7 @@ export function regUndo(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
               await handle.close();
             }
           } catch (error) {
-            if (errCode(error) !== "ENOENT") throw error;
+            if (errCode(error) !== "ENOENT") throw mapIoError(error, "read", path);
           }
 
           if (

package/src/structured.ts

@@ -1,5 +1,6 @@
 import { Type } from "typebox";
 import { HASH_CLASS, HASH_SEP } from "./hashline/hash";
+import { ioErrorCode } from "./utils";
 
 export type Json = null | boolean | number | string | Json[] | { [key: string]: Json };
 
@@ -200,7 +201,7 @@ export function messageOf(error: unknown): string {
 
 export function structuredError(error: unknown): StructuredError {
 	const message = messageOf(error);
-	return { ok: false, kind: "error", error: { code: ERROR_CODE_RE.exec(message)?.[1] ?? "E_TOOL", message } };
+	return { ok: false, kind: "error", error: { code: ERROR_CODE_RE.exec(message)?.[1] ?? ioErrorCode(error) ?? "E_TOOL", message } };
 }
 
 export type StructuredFailureResult<TDetails> = {

package/src/utils.ts

@@ -94,6 +94,35 @@ export function errCode(error: unknown): string | undefined {
 	return undefined;
 }
 
+const IO_ERROR_CODES: Record<string, string> = {
+  ENOENT: "E_NOT_FOUND",
+  EACCES: "E_ACCESS",
+  EPERM: "E_ACCESS",
+  EROFS: "E_ACCESS",
+  EISDIR: "E_ACCESS",
+  ENOTDIR: "E_ACCESS",
+  EEXIST: "E_ACCESS",
+  ELOOP: "E_ACCESS",
+  ENOSPC: "E_ACCESS",
+  EDQUOT: "E_ACCESS",
+  EMFILE: "E_ACCESS",
+  ENFILE: "E_ACCESS",
+  ENAMETOOLONG: "E_ACCESS",
+};
+
+export function ioErrorCode(error: unknown): string | undefined {
+  const code = errCode(error);
+  return code !== undefined ? IO_ERROR_CODES[code] : undefined;
+}
+
+export function mapIoError(error: unknown, action: string, path: string): Error {
+  if (error instanceof Error && /\[[EWH]_[A-Z0-9_]+\]/.test(error.message)) return error;
+  const mapped = ioErrorCode(error);
+  if (mapped === undefined) return error instanceof Error ? error : new Error(String(error));
+  const detail = error instanceof Error ? error.message : String(error);
+  return new Error(`[${mapped}] Cannot ${action} ${path}: ${detail}`);
+}
+
 export function isModeUnsupported(error: unknown): boolean {
 	const code = errCode(error);
 	return code === "EPERM" || code === "ENOTSUP" || code === "EOPNOTSUPP" || code === "EINVAL" || code === "ENOSYS";