pi-hashline-edit-pro 4.2.11 → 4.3.1

package/src/replace-diff.ts

@@ -201,6 +201,74 @@ function trimPlacedSpans(
   return out;
 }
 
+function createRowEmitter(
+  output: string[],
+  lineNumbers: (number | undefined)[],
+  maxLineBytes: number,
+  maxBytes: number,
+): {
+  readonly stopped: boolean;
+  readonly truncated: boolean;
+  emitPlain(line: string, num?: number): void;
+  emitRow(prefix: " " | "+" | "-", line: string, hash: string | undefined, num?: number): void;
+  emitDedup(line: string): boolean;
+} {
+  let outBytes = 0;
+  let stopped = false;
+  let truncated = false;
+  const emitPlain = (line: string, num?: number): void => {
+    if (stopped) return;
+    const lineBytes = Buffer.byteLength(line, "utf-8") + 1;
+    if (outBytes + lineBytes > maxBytes) {
+      stopped = true;
+      truncated = true;
+      return;
+    }
+    outBytes += lineBytes;
+    output.push(line);
+    lineNumbers.push(num);
+  };
+  const emitRow = (prefix: " " | "+" | "-", line: string, hash: string | undefined, num?: number): void => {
+    if (stopped) return;
+    const full = fmtDiffLine(prefix, line, hash);
+    const rowBytes = Buffer.byteLength(full, "utf-8");
+    if (rowBytes > maxLineBytes) {
+      const marker = `[Row is ${formatSize(rowBytes)}, exceeds ${formatSize(maxLineBytes)}; content not shown. Use read to see the full line.]`;
+      emitPlain(fmtDiffLine(prefix, marker, hash), num);
+      return;
+    }
+    if (outBytes + rowBytes + 1 > maxBytes) {
+      stopped = true;
+      truncated = true;
+      return;
+    }
+    outBytes += rowBytes + 1;
+    output.push(full);
+    lineNumbers.push(num);
+  };
+  const emitDedup = (line: string): boolean => {
+    if (stopped) return false;
+    const row = fmtDedupRow(line);
+    const rowBytes = Buffer.byteLength(row, "utf-8") + 1;
+    if (outBytes + rowBytes > maxBytes) {
+      stopped = true;
+      truncated = true;
+      return false;
+    }
+    outBytes += rowBytes;
+    output.push(row);
+    lineNumbers.push(undefined);
+    return true;
+  };
+  return {
+    get stopped() { return stopped; },
+    get truncated() { return truncated; },
+    emitPlain,
+    emitRow,
+    emitDedup,
+  };
+}
+
 function genSpanDiff(
   oldContent: string,
   newContent: string,
@@ -235,50 +303,18 @@ function genSpanDiff(
   let dedupEmitted = false;
   const lineNumbers: (number | undefined)[] = [];
   let firstChangedLine: number | undefined;
-  let outBytes = 0;
-  let stopped = false;
-  let diffTruncated = false;
-  const emitPlain = (line: string, num?: number): void => {
-    if (stopped) return;
-    const lineBytes = Buffer.byteLength(line, "utf-8") + 1;
-    if (outBytes + lineBytes > maxBytes) {
-      stopped = true;
-      diffTruncated = true;
-      return;
-    }
-    outBytes += lineBytes;
-    output.push(line);
-    lineNumbers.push(num);
-  };
-  const emitRow = (prefix: " " | "+" | "-", line: string, hash: string | undefined, num?: number): void => {
-    if (stopped) return;
-    const full = fmtDiffLine(prefix, line, hash);
-    const rowBytes = Buffer.byteLength(full, "utf-8");
-    if (rowBytes > maxLineBytes) {
-      const marker = `[Row is ${formatSize(rowBytes)}, exceeds ${formatSize(maxLineBytes)}; content not shown. Use read to see the full line.]`;
-      emitPlain(fmtDiffLine(prefix, marker, hash), num);
-      return;
-    }
-    if (outBytes + rowBytes + 1 > maxBytes) {
-      stopped = true;
-      diffTruncated = true;
-      return;
-    }
-    outBytes += rowBytes + 1;
-    output.push(full);
-    lineNumbers.push(num);
-  };
+  const em = createRowEmitter(output, lineNumbers, maxLineBytes, maxBytes);
   const emitGap = (gapStartNew: number, gapLen: number, position: "leading" | "middle" | "trailing"): void => {
-    if (stopped || gapLen <= 0) return;
+    if (em.stopped || gapLen <= 0) return;
     if (position === "leading") {
       let count = contextLines;
       if (contextLines > 0 && gapLen > count && isBlankLine(newLines[gapStartNew + gapLen - 1]!)) count += 1;
       count = Math.min(count, gapLen);
       const skipStart = gapLen - count;
-      if (skipStart > 0) emitPlain(" ...", undefined);
-      for (let k = gapLen - count; k < gapLen && !stopped; k++) {
+      if (skipStart > 0) em.emitPlain(" ...", undefined);
+      for (let k = gapLen - count; k < gapLen && !em.stopped; k++) {
         const newIdx = gapStartNew + k;
-        emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
+        em.emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
       }
       return;
     }
@@ -286,11 +322,11 @@ function genSpanDiff(
       let count = contextLines;
       if (contextLines > 0 && gapLen > count && isBlankLine(newLines[gapStartNew]!)) count += 1;
       count = Math.min(count, gapLen);
-      for (let k = 0; k < count && !stopped; k++) {
+      for (let k = 0; k < count && !em.stopped; k++) {
         const newIdx = gapStartNew + k;
-        emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
+        em.emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
       }
-      if (gapLen > count) emitPlain(" ...", undefined);
+      if (gapLen > count) em.emitPlain(" ...", undefined);
       return;
     }
     let headCount = contextLines;
@@ -299,56 +335,52 @@ function genSpanDiff(
     if (contextLines > 0 && gapLen - tailCount > headCount && isBlankLine(newLines[gapStartNew + gapLen - tailCount]!)) tailCount += 1;
     const middleLen = gapLen - headCount - tailCount;
     if (middleLen <= 0) {
-      for (let k = 0; k < gapLen && !stopped; k++) {
+      for (let k = 0; k < gapLen && !em.stopped; k++) {
         const newIdx = gapStartNew + k;
-        emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
+        em.emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
       }
       return;
     }
-    for (let k = 0; k < headCount && !stopped; k++) {
+    for (let k = 0; k < headCount && !em.stopped; k++) {
       const newIdx = gapStartNew + k;
-      emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
+      em.emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
     }
-    if (!stopped) emitPlain(" ...", undefined);
-    for (let k = gapLen - tailCount; k < gapLen && !stopped; k++) {
+    if (!em.stopped) em.emitPlain(" ...", undefined);
+    for (let k = gapLen - tailCount; k < gapLen && !em.stopped; k++) {
       const newIdx = gapStartNew + k;
-      emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
+      em.emitRow(" ", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
     }
   };
   oldPos = 0;
   newPos = 0;
-  for (let spanIdx = 0; spanIdx < ordered.length && !stopped; spanIdx++) {
+  for (let spanIdx = 0; spanIdx < ordered.length && !em.stopped; spanIdx++) {
     const span = ordered[spanIdx]!;
     const gapLen = span.oldStart - oldPos;
     emitGap(newPos, gapLen, spanIdx === 0 ? "leading" : "middle");
-    if (stopped) break;
+    if (em.stopped) break;
     if (firstChangedLine === undefined) firstChangedLine = span.newStart + 1;
     for (const dedup of span.dedupAbove ?? []) {
-      if (stopped) break;
-      dedupEmitted = true;
-      output.push(fmtDedupRow(dedup));
-      lineNumbers.push(undefined);
+      if (em.stopped) break;
+      if (em.emitDedup(dedup)) dedupEmitted = true;
     }
-    for (let oldIdx = span.oldStart; oldIdx <= span.oldEnd && !stopped; oldIdx++) {
-      emitRow("-", oldLines[oldIdx]!, oldHashes[oldIdx], oldIdx + 1);
+    for (let oldIdx = span.oldStart; oldIdx <= span.oldEnd && !em.stopped; oldIdx++) {
+      em.emitRow("-", oldLines[oldIdx]!, oldHashes[oldIdx], oldIdx + 1);
     }
-    for (let newIdx = span.newStart; newIdx <= span.newEnd && !stopped; newIdx++) {
-      emitRow("+", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
+    for (let newIdx = span.newStart; newIdx <= span.newEnd && !em.stopped; newIdx++) {
+      em.emitRow("+", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
     }
     for (const dedup of span.dedupBelow ?? []) {
-      if (stopped) break;
-      dedupEmitted = true;
-      output.push(fmtDedupRow(dedup));
-      lineNumbers.push(undefined);
+      if (em.stopped) break;
+      if (em.emitDedup(dedup)) dedupEmitted = true;
     }
     oldPos = span.oldEnd + 1;
     newPos = span.newEnd + 1;
   }
-  if (!stopped) {
+  if (!em.stopped) {
     const trailingLen = oldLines.length - oldPos;
     emitGap(newPos, trailingLen, "trailing");
   }
-  if (diffTruncated) {
+  if (em.truncated) {
     output.push(" ...");
     lineNumbers.push(undefined);
     output.push(`[diff truncated at ${formatSize(maxBytes)}; use read to see the rest.]`);
@@ -441,45 +473,12 @@ export function genDiff(
   let oldLineNum = 1;
   let lastWasChange = false;
   let firstChangedLine: number | undefined;
-  let outBytes = 0;
-  let stopped = false;
-  let diffTruncated = false;
   const lineNumbers: (number|undefined)[] = [];
 
-  const emitPlain = (line: string, num?: number): void => {
-    if (stopped) return;
-    const lineBytes = Buffer.byteLength(line, "utf-8") + 1;
-    if (outBytes + lineBytes > maxBytes) {
-      stopped = true;
-      diffTruncated = true;
-      return;
-    }
-    outBytes += lineBytes;
-    output.push(line);
-    lineNumbers.push(num);
-  };
-
-  const emitRow = (prefix: " " | "+" | "-", line: string, hash: string | undefined, num?: number): void => {
-    if (stopped) return;
-    const full = fmtDiffLine(prefix, line, hash);
-    const rowBytes = Buffer.byteLength(full, "utf-8");
-    if (rowBytes > maxLineBytes) {
-      const marker = `[Row is ${formatSize(rowBytes)}, exceeds ${formatSize(maxLineBytes)}; content not shown. Use read to see the full line.]`;
-      emitPlain(fmtDiffLine(prefix, marker, hash), num);
-      return;
-    }
-    if (outBytes + rowBytes + 1 > maxBytes) {
-      stopped = true;
-      diffTruncated = true;
-      return;
-    }
-    outBytes += rowBytes + 1;
-    output.push(full);
-    lineNumbers.push(num);
-  };
+  const em = createRowEmitter(output, lineNumbers, maxLineBytes, maxBytes);
 
   for (let i = 0; i < parts.length; i++) {
-    if (stopped) break;
+    if (em.stopped) break;
     const part = parts[i]!;
     const raw = part.value.split("\n");
     if (raw[raw.length - 1] === "") raw.pop();
@@ -488,18 +487,18 @@ export function genDiff(
     if (part.added || part.removed) {
       if (firstChangedLine === undefined) firstChangedLine = newLineNum;
       for (let k = 0; k < displayLines.length; k++) {
-        if (stopped) break;
+        if (em.stopped) break;
         if (part.added) {
           const hash = effectiveNewHashes[newLineNum - 1];
-          emitRow("+", displayLines[k]!, hash, newLineNum);
+          em.emitRow("+", displayLines[k]!, hash, newLineNum);
           newLineNum++;
         } else {
           const hash = oldContentHashes?.[oldLineNum - 1];
-          emitRow("-", displayLines[k]!, hash, oldLineNum);
+          em.emitRow("-", displayLines[k]!, hash, oldLineNum);
           oldLineNum++;
         }
       }
-      if (stopped) break;
+      if (em.stopped) break;
       lastWasChange = true;
       continue;
     }
@@ -562,25 +561,25 @@ export function genDiff(
       }
 
       if (skipStart > 0) {
-        emitPlain(" ...", undefined);
+        em.emitPlain(" ...", undefined);
         newLineNum += skipStart;
         oldLineNum += skipStart;
       }
       for (const line of linesToShow) {
-        if (stopped) break;
+        if (em.stopped) break;
         if (isEllipsisMarker(line)) {
-          emitPlain(" ...", undefined);
+          em.emitPlain(" ...", undefined);
           newLineNum += skipMiddle;
           oldLineNum += skipMiddle;
           continue;
         }
         const hash = effectiveNewHashes[newLineNum - 1];
-        emitRow(" ", line, hash, newLineNum);
+        em.emitRow(" ", line, hash, newLineNum);
         newLineNum++;
         oldLineNum++;
       }
       if (skipTail > 0) {
-        emitPlain(" ...", undefined);
+        em.emitPlain(" ...", undefined);
       }
     } else {
       newLineNum += displayLines.length;
@@ -589,7 +588,7 @@ export function genDiff(
     lastWasChange = false;
   }
 
-  if (diffTruncated) {
+  if (em.truncated) {
     output.push(" ...");
     lineNumbers.push(undefined);
     output.push(`[diff truncated at ${formatSize(maxBytes)}; use read to see the rest.]`);

package/src/replace-response.ts

@@ -1,3 +1,4 @@
+import { formatSize, DEFAULT_MAX_BYTES } from "@earendil-works/pi-coding-agent";
 import type { NEdit } from "./hashline";
 import { HASH_SEP } from "./hashline";
 import type { ReplaceDetails } from "./replace";
@@ -140,9 +141,42 @@ export function isChangeRow(line: string): boolean {
   return line.startsWith("+") || line.startsWith("-");
 }
 
-export function withDedupRows(diff: string, lineNumbers: (number | undefined)[], above: string[] | undefined, below: string[] | undefined): { diff: string; lineNumbers: (number | undefined)[] } {
-  const top = (above ?? []).map(fmtDedupRow);
-  const bottom = (below ?? []).map(fmtDedupRow);
+function capDedupRows(rows: string[], budget: number): { rows: string[]; bytes: number; omitted: number } {
+  const kept: string[] = [];
+  let bytes = 0;
+  for (const row of rows) {
+    const rowBytes = Buffer.byteLength(row, "utf-8") + 1;
+    if (bytes + rowBytes > budget) break;
+    kept.push(row);
+    bytes += rowBytes;
+  }
+  return { rows: kept, bytes, omitted: rows.length - kept.length };
+}
+
+function dedupOmissionNote(omitted: number, maxBytes: number): string {
+  return fmtDedupRow(`[${omitted} line(s) not shown again; output capped at ${formatSize(maxBytes)}.]`);
+}
+
+export function withDedupRows(diff: string, lineNumbers: (number | undefined)[], above: string[] | undefined, below: string[] | undefined, maxBytes = DEFAULT_MAX_BYTES): { diff: string; lineNumbers: (number | undefined)[] } {
+  const topAll = (above ?? []).map(fmtDedupRow);
+  const bottomAll = (below ?? []).map(fmtDedupRow);
+  if (topAll.length === 0 && bottomAll.length === 0) return { diff, lineNumbers };
+  const usedBytes = Buffer.byteLength(diff, "utf-8");
+  const fullBudget = Math.max(0, maxBytes - usedBytes);
+  const initialTop = capDedupRows(topAll, fullBudget);
+  const initialBottom = capDedupRows(bottomAll, Math.max(0, fullBudget - initialTop.bytes));
+  const anyOmitted = initialTop.omitted + initialBottom.omitted > 0;
+  const reserved = anyOmitted ? Buffer.byteLength(dedupOmissionNote(topAll.length + bottomAll.length, maxBytes), "utf-8") + 1 : 0;
+  const budget = Math.max(0, fullBudget - reserved);
+  const topCapped = anyOmitted ? capDedupRows(topAll, budget) : initialTop;
+  const bottomCapped = anyOmitted ? capDedupRows(bottomAll, Math.max(0, budget - topCapped.bytes)) : initialBottom;
+  const top = topCapped.rows;
+  const bottom = [...bottomCapped.rows];
+  const omitted = topCapped.omitted + bottomCapped.omitted;
+  if (omitted > 0) {
+    const note = dedupOmissionNote(omitted, maxBytes);
+    if (usedBytes + topCapped.bytes + bottomCapped.bytes + Buffer.byteLength(note, "utf-8") + 1 <= maxBytes) bottom.push(note);
+  }
   if (top.length === 0 && bottom.length === 0) return { diff, lineNumbers };
   if (diff.length === 0) return { diff: [...top, ...bottom].join("\n"), lineNumbers: [...lineNumbers, ...[...top, ...bottom].map(() => undefined)] };
   const lines = diff.split("\n");

package/src/replace-undo.ts

@@ -4,10 +4,9 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { loadHashStore, persistSnapshot, upsertUndo, getUndoEntry, deleteUndo, type UndoRecord } from "./hash-store";
-import { servedHashesFromDiff, buildServedMap } from "./served";
-import { contentChecksum } from "./hashline/hasher";
-import { hashSource } from "./hashline";
-import { markServed as markServedScoped, freeAnchors, adoptAnchors, withAnchorSession } from "./anchor-registry";
+import { servedHashesFromDiff, serveRows } from "./served";
+import { lineChecksum } from "./hashline";
+import { freeAnchors, adoptAnchors, withAnchorSession } from "./anchor-registry";
 import { resolveInCwd, writeAtomic, type FileIdentity } from "./fs-write";
 import { toLF, stripBOM, restoreEndings, type LineEnding } from "./normalize";
 import { genDiff, genPatch, spansFromHashes } from "./replace-diff";
@@ -200,16 +199,17 @@ export function regUndo(pi: ExtensionAPI): void {
           try {
             const store = await loadHashStore();
             const undoLines = splitLines(undo.content);
-            persistSnapshot(store, mutationTargetPath, undo.content, undo.hashes, undoLines.map((line) => contentChecksum(hashSource(line))));
+            persistSnapshot(store, mutationTargetPath, undo.content, undo.hashes, undoLines.map(lineChecksum));
             freeAnchors(mutationTargetPath);
             adoptAnchors(
               mutationTargetPath,
-              new Map(undoLines.map((line, i) => [undo.hashes[i]!, contentChecksum(hashSource(line))])),
+              new Map(undoLines.map((line, i) => [undo.hashes[i]!, lineChecksum(line)])),
             );
-            markServedScoped(
+            serveRows(
               mutationTargetPath,
-              buildServedMap(undo.hashes, undoLines, servedHashesFromDiff(undoDiff)),
-              new Set(undo.hashes),
+              undo.hashes,
+              undoLines,
+              servedHashesFromDiff(undoDiff),
             );
           } catch (error) {
             console.error("Failed to restore hash store snapshot after undo:", error);

package/src/replace.ts

@@ -90,7 +90,14 @@ export function hashSpan(hashes: string[], from: string, to: string): [number, n
   if (a < 0 || b < 0) return undefined;
   return [Math.min(a, b), Math.max(a, b)];
 }
-async function noteAnchorError(absolutePath: string, error: unknown, scopeHashes: string[], noPersist?: boolean): Promise<void> {
+
+export function spanForEdit(originalHashes: string[], from: string, to: string, resultContent: string): DiffSpan | undefined {
+  const span = hashSpan(originalHashes, from, to);
+  if (!span) return undefined;
+  const replacementCount = splitLines(resultContent).length - (originalHashes.length - (span[1] - span[0] + 1));
+  return { start: span[0], end: span[1], replacementCount };
+}
+async function noteAnchorError(absolutePath: string, error: unknown, noPersist?: boolean): Promise<void> {
   if (noPersist === true) return;
   if (error instanceof RangeStaleError) {
     adoptAnchors(absolutePath, error.rangeServedMap);
@@ -159,7 +166,7 @@ export async function execPipeline(
       strictBoundaryDedup,
     );
   } catch (error) {
-    await noteAnchorError(absolutePath, error, originalHashes, options?.noPersist);
+    await noteAnchorError(absolutePath, error, options?.noPersist);
     throw error;
   }
 
@@ -179,9 +186,8 @@ export async function execPipeline(
   );
 
   const sortedFixes = dedupRowsFromFixes(anchorResult.autoFixes ?? []);
-  const pipeSpan = isNoop ? undefined : hashSpan(originalHashes, edit.hash_bounds[0].hash, edit.hash_bounds[1].hash);
-  const pipeResultCount = splitLines(result).length;
-  const pipeSpans = pipeSpan ? [{ start: pipeSpan[0], end: pipeSpan[1], replacementCount: pipeResultCount - (originalHashes.length - (pipeSpan[1] - pipeSpan[0] + 1)) }] : undefined;
+  const pipeSpan = isNoop ? undefined : spanForEdit(originalHashes, edit.hash_bounds[0].hash, edit.hash_bounds[1].hash, result);
+  const pipeSpans = pipeSpan ? [pipeSpan] : undefined;
   return {
     path: displayPath,
     originalNormalized,

package/src/served.ts

@@ -1,6 +1,6 @@
 import { HASH_CLASS } from "./hashline/alphabet";
-import { hashSource } from "./hashline";
-import { contentChecksum } from "./hashline/hasher";
+import { lineChecksum } from "./hashline/hash";
+import { markServed } from "./anchor-registry";
 
 const SERVED_DIFF_ROW_RE = new RegExp(`^[+ ](${HASH_CLASS})│`);
 
@@ -26,7 +26,11 @@ export function buildServedMap(
   const entries: Array<[string, string]> = [];
   for (const hash of wantedHashes) {
     const idx = index.get(hash);
-    if (idx !== undefined) entries.push([hash, contentChecksum(hashSource(fileLines[idx]!))]);
+    if (idx !== undefined) entries.push([hash, lineChecksum(fileLines[idx]!)]);
   }
   return entries;
 }
+
+export function serveRows(path: string, fileHashes: string[], fileLines: string[], wantedHashes: string[]): void {
+  markServed(path, buildServedMap(fileHashes, fileLines, wantedHashes), new Set(fileHashes));
+}

package/src/utils.ts

@@ -22,14 +22,16 @@ export function normalizeAnchors(record: Record<string, unknown>): void {
   }
 }
 
+export function normalizeRequest(input: unknown): unknown {
+  if (!isRec(input)) return input;
+  const record: Record<string, unknown> = { ...input };
+  normalizeFilePath(record);
+  normalizeAnchors(record);
+  return record;
+}
+
 export function makePrepareArguments(): (args: unknown) => any {
-  return (args) => {
-    if (!isRec(args)) return args;
-    const record = { ...args };
-    normalizeFilePath(record);
-    normalizeAnchors(record);
-    return record;
-  };
+  return normalizeRequest;
 }
 
 export function splitLines(text: string): string[] {
@@ -293,7 +295,6 @@ export function decodeStringArray(value: unknown, warnings?: string[], label = "
 	if (candidate === undefined) return undefined;
 	const decoded = decodeArrayText(candidate);
 	if (decoded !== undefined) {
-		warnings?.push(`[W_BAD_SHAPE] Unwrapped JSON array syntax from a ${label} element.`);
 		return decoded;
 	}
 	if (looksLikeStringArray(candidate)) {

package/src/write-hook.ts

@@ -19,10 +19,6 @@ export function findServedHashEcho(content: string, served: ReadonlyMap<string,
   return searchEcho(splitLines(content), served);
 }
 
-export function findEditHashEcho(lines: string[], served: ReadonlyMap<string, string> | ReadonlySet<string>): { line: number; hash: string } | undefined {
-  return searchEcho(lines, served);
-}
-
 export async function servedHashEchoDenial(rawPath: string, content: string, cwd: string, signal?: AbortSignal): Promise<string | undefined> {
   abortIf(signal);
   const { resolved } = await resolveInCwd(rawPath, cwd);