pi-hashline-edit-pro 4.3.9 → 4.4.1

package/src/hashline/apply.ts

@@ -1,4 +1,4 @@
-import { abortIf, clipLine, splitLines } from "../utils";
+import { abortIf, splitLines } from "../utils";
 import {
 	valEdit,
 	stripBarePrefixes,
@@ -11,8 +11,6 @@ import {
 	type RHEdit,
 	type NEdit,
 	type HEdit,
-	type AutoFix,
-	type BDup,
 } from "./resolve";
 
 type LIdx = {
@@ -150,19 +148,9 @@ function assemble(
 export interface PlannedEdit {
   resolved: RHEdit;
   warnings: string[];
-  autoFixes?: AutoFix[];
 }
 
 
-function throwStrictBoundaryDedup(edit: HEdit, boundaryDups: BDup[], resolved: RHEdit): never {
-  const startLine = resolved.hash_bounds[0].line;
-  const endLine = resolved.hash_bounds[1].line;
-  const range = startLine === endLine ? `line ${startLine}` : `lines ${startLine}-${endLine}`;
-  const seen = new Set<number>();
-  for (const dup of boundaryDups) seen.add(dup.replacementLineIndex);
-  const removed = [...seen].sort((a, b) => a - b).map((index) => `replacement_lines line ${index + 1}: ${clipLine(edit.content_lines[index] ?? "")}`);
-  throw new Error(`[E_BOUNDARY_STRICT] Strict boundary dedup rejects this edit: ${seen.size} replacement line(s) re-include edge lines (${range}). ${removed.join("; ")}. Resend without those lines.`);
-}
 export function planEdit(
   content: string,
   edit: HEdit,
@@ -170,8 +158,6 @@ export function planEdit(
   options?: {
     filePath?: string;
     servedHashes?: ReadonlyMap<string, string>;
-    skipBoundaryDedup?: boolean;
-    strictBoundaryDedup?: boolean;
     signal?: AbortSignal;
     baseFileLines?: string[];
   },
@@ -189,7 +175,7 @@ export function planEdit(
     warnings,
   );
 
-  const { resolved: initialResolved, mismatches, boundaryDups } = valEdit(
+  const { resolved: initialResolved, mismatches } = valEdit(
     prefixFixed,
     lineIndex.fileLines,
     fileHashes,
@@ -208,51 +194,7 @@ export function planEdit(
 
   warnUnicodeEsc(prefixFixed, warnings);
 
-  if (options?.strictBoundaryDedup === true && boundaryDups.length > 0) {
-    throwStrictBoundaryDedup(prefixFixed, boundaryDups, initialResolved);
-  }
-  let resolved = initialResolved;
-  let autoFixes: AutoFix[] | undefined;
-  if (boundaryDups.length > 0 && !(options?.skipBoundaryDedup === true)) {
-    autoFixes = [];
-    const correctedEdit: HEdit = {
-      ...prefixFixed,
-      content_lines: [...prefixFixed.content_lines],
-    };
-    const seen = new Set<number>();
-    const uniqueDups: BDup[] = [];
-    for (const dup of boundaryDups) {
-      if (seen.has(dup.replacementLineIndex)) continue;
-      seen.add(dup.replacementLineIndex);
-      uniqueDups.push(dup);
-    }
-    const dupsByIndex = uniqueDups.sort(
-      (a, b) => b.replacementLineIndex - a.replacementLineIndex,
-    );
-    for (const dup of dupsByIndex) {
-      const idx = dup.replacementLineIndex;
-      if (idx < 0 || idx >= correctedEdit.content_lines.length) continue;
-      const removed = correctedEdit.content_lines.splice(idx, 1)[0];
-      autoFixes.push({ kind: dup.kind, removedLine: removed, removedLineIndex: idx });
-    }
-    const correctedResult = valEdit(
-      correctedEdit,
-      lineIndex.fileLines,
-      fileHashes,
-      warnings,
-      signal,
-    );
-    if (correctedResult.mismatches.length || !correctedResult.resolved) {
-      const feedback = fmtMismatchWithHashes(
-        correctedResult.mismatches,
-        lineIndex.fileLines,
-        fileHashes,
-        options?.filePath,
-      );
-      throw new AnchorMismatchError(feedback.text, feedback.hashes, feedback.servedMap);
-    }
-    resolved = correctedResult.resolved;
-  }
+  const resolved = initialResolved;
 
   if (options?.servedHashes) {
     abortIf(signal);
@@ -262,7 +204,6 @@ export function planEdit(
   return {
     resolved,
     warnings,
-    ...(autoFixes ? { autoFixes } : {}),
   };
 }
 export function applyEdit(
@@ -272,25 +213,21 @@ export function applyEdit(
 	precomputedHashes?: string[],
 	filePath?: string,
 	servedHashes?: ReadonlyMap<string, string>,
-	skipBoundaryDedup?: boolean,
-	strictBoundaryDedup?: boolean,
 	): {
 	content: string;
 	firstChangedLine: number | undefined;
 	lastChangedLine: number | undefined;
 	warnings?: string[];
 	noopEdit?: NEdit;
-	autoFixes?: AutoFix[];
 } {
   abortIf(signal);
   if (precomputedHashes === undefined) {
     throw new Error("[E_BAD_SHAPE] applyEdit requires the file's allocated anchors; derive them via lineHashes(content, path) first.");
   }
-  const planned = planEdit(content, edit, precomputedHashes, { filePath, servedHashes, skipBoundaryDedup, strictBoundaryDedup, signal });
+  const planned = planEdit(content, edit, precomputedHashes, { filePath, servedHashes, signal });
   const lineIndex = buildIdx(content);
   const warnings = planned.warnings;
   const resolved = planned.resolved;
-  const autoFixes = planned.autoFixes;
 	const spanResult = resToSpan(resolved, content, lineIndex);
 	if (spanResult.kind === "noop") {
 		return {
@@ -298,7 +235,6 @@ export function applyEdit(
 			firstChangedLine: undefined,
 			lastChangedLine: undefined,
 			...(warnings.length ? { warnings } : {}),
-			...(autoFixes ? { autoFixes } : {}),
 			noopEdit: { loc: spanResult.loc, currentContent: spanResult.currentContent },
 		};
 	}
@@ -312,7 +248,6 @@ export function applyEdit(
 		firstChangedLine: range?.firstChangedLine,
 		lastChangedLine: range?.lastChangedLine,
 		...(warnings.length ? { warnings } : {}),
-		...(autoFixes ? { autoFixes } : {}),
 	};
 }
 

package/src/hashline/index.ts

@@ -26,8 +26,6 @@ export {
 	type RHEdit,
 	type HTEdit,
 	type NEdit,
-	type BDup,
-	type AutoFix,
 	resEdit,
 	stripAnchorRow,
 	resolveAnchorLine,
@@ -35,7 +33,6 @@ export {
 	stripBarePrefixes,
 	stripDiffPrefixes,
 	swapReversedRanges,
-	findNewEdge,
 	assertRangeServed,
 	RangeStaleError,
 	AnchorMismatchError,

package/src/hashline/resolve.ts

@@ -1,6 +1,6 @@
-import { abortIf, rejectUnknownFields, firstNonEmptyIndex, lastNonEmptyIndex, clipLine, getCached, decodeStringArray, assertNoNul } from "../utils";
+import { abortIf, rejectUnknownFields, clipLine, decodeStringArray, assertNoNul } from "../utils";
 import { parseHashRef, parseText, type Anchor } from "./parse";
-import { HASH_SEP, stripRowPrefix, canon, lineChecksum, type RowPrefixKind } from "./hash";
+import { HASH_SEP, stripRowPrefix, lineChecksum, type RowPrefixKind } from "./hash";
 import { HASH_RUN } from "./alphabet";
 import { NEW_CONTENT_NOT_ARRAY_MSG, MAX_RANGE_STALE_LINES } from "../constants";
 
@@ -21,17 +21,6 @@ interface HMismatch {
 	context?: RAnchor;
 }
 
-export interface BDup {
-	kind: "trailing" | "leading" | "first-new-after" | "last-new-before";
-	replacementLineIndex: number;
-}
-
-export interface AutoFix {
-	kind: "trailing" | "leading" | "first-new-after" | "last-new-before";
-	removedLine: string;
-	removedLineIndex: number;
-}
-
 export interface NEdit {
 	loc: string;
 	currentContent: string;
@@ -240,147 +229,15 @@ export function swapReversedRanges(
 	return { ...edit, hash_bounds: [endRef, startRef] as [Anchor, Anchor] };
 }
 
-function trailingDups(
-	contentLines: string[],
-	fileLines: string[],
-	endLine: number,
-): BDup[] {
-	const start = lastNonEmptyIndex(contentLines);
-	if (start < 0) return [];
-	const dups: BDup[] = [];
-	const maxK = Math.min(start + 1, fileLines.length - endLine);
-	for (let k = 0; k < maxK; k++) {
-		if (contentLines[start - k] !== fileLines[endLine + k]) break;
-		dups.push({ kind: "trailing", replacementLineIndex: start - k });
-	}
-	return dups;
-}
-
-function leadingDups(
-	contentLines: string[],
-	fileLines: string[],
-	startLine: number,
-): BDup[] {
-	const start = firstNonEmptyIndex(contentLines);
-	if (start < 0) return [];
-	const dups: BDup[] = [];
-	const maxK = Math.min(contentLines.length - start, startLine - 1);
-	for (let k = 0; k < maxK; k++) {
-		if (contentLines[start + k] !== fileLines[startLine - 2 - k]) break;
-		dups.push({ kind: "leading", replacementLineIndex: start + k });
-	}
-	return dups;
-}
-
-function sectionIsUnique(
-	canonLines: string[],
-	start: number,
-	length: number,
-): boolean {
-	let count = 0;
-	for (let i = 0; i + length <= canonLines.length; i++) {
-		let k = 0;
-		while (k < length && canonLines[i + k] === canonLines[start + k]) k++;
-		if (k < length) continue;
-		count++;
-		if (count > 1) return false;
-	}
-	return true;
-}
-
-function firstNewAfterDups(
-	contentLines: string[],
-	rangeLines: string[],
-	canonLines: string[],
-	endLine: number,
-): BDup[] {
-	const firstNew = findNewEdge(contentLines, rangeLines, false);
-	if (!firstNew) return [];
-	const maxK = Math.min(contentLines.length - firstNew.index, canonLines.length - endLine);
-	let runLen = 0;
-	while (
-		runLen < maxK &&
-		canonLines[endLine + runLen]!.length > 0 &&
-		canon(contentLines[firstNew.index + runLen]!) === canonLines[endLine + runLen]!
-	) {
-		runLen++;
-	}
-	if (runLen === 0 || !sectionIsUnique(canonLines, endLine, runLen)) return [];
-	const dups: BDup[] = [];
-	for (let k = 0; k < runLen; k++) {
-		dups.push({ kind: "first-new-after", replacementLineIndex: firstNew.index + k });
-	}
-	return dups;
-}
-
-function lastNewBeforeDups(
-	contentLines: string[],
-	rangeLines: string[],
-	canonLines: string[],
-	startLine: number,
-): BDup[] {
-	const lastNew = findNewEdge(contentLines, rangeLines, true);
-	if (!lastNew) return [];
-	const maxK = Math.min(lastNew.index + 1, startLine - 1);
-	let runLen = 0;
-	while (
-		runLen < maxK &&
-		canonLines[startLine - 2 - runLen]!.length > 0 &&
-		canon(contentLines[lastNew.index - runLen]!) === canonLines[startLine - 2 - runLen]!
-	) {
-		runLen++;
-	}
-	if (runLen === 0) return [];
-	const sectionStart = startLine - 1 - runLen;
-	if (!sectionIsUnique(canonLines, sectionStart, runLen)) return [];
-	const dups: BDup[] = [];
-	for (let k = 0; k < runLen; k++) {
-		dups.push({ kind: "last-new-before", replacementLineIndex: lastNew.index - k });
-	}
-	return dups;
-}
-
-function canonCounts(lines: string[]): Map<string, number> {
-	const counts = new Map<string, number>();
-	for (const line of lines) {
-		const key = canon(line);
-		counts.set(key, (counts.get(key) ?? 0) + 1);
-	}
-	return counts;
-}
-
-export function findNewEdge(
-	contentLines: string[],
-	rangeLines: string[],
-	fromEnd: boolean,
-): { index: number; line: string } | undefined {
-	const multiset = canonCounts(rangeLines);
-	const step = fromEnd ? -1 : 1;
-	const start = fromEnd ? contentLines.length - 1 : 0;
-	for (let i = start; i >= 0 && i < contentLines.length; i += step) {
-		const line = contentLines[i]!;
-		const key = canon(line);
-		if (key.length === 0) continue;
-		const count = multiset.get(key) ?? 0;
-		if (count > 0) {
-			multiset.set(key, count - 1);
-		} else {
-			return { index: i, line };
-		}
-	}
-	return undefined;
-}
-
 export function valEdit(
 	edit: HEdit,
 	fileLines: string[],
 	fileHashes: string[],
 	warnings: string[],
 	signal: AbortSignal | undefined,
-): { resolved: RHEdit | undefined; mismatches: HMismatch[]; boundaryDups: BDup[] } {
+): { resolved: RHEdit | undefined; mismatches: HMismatch[] } {
 	assertAligned(fileLines, fileHashes, "valEdit");
 	const mismatches: HMismatch[] = [];
-	const boundaryDups: BDup[] = [];
 
 	const hashIndex = new Map<string, number[]>();
 	for (let i = 0; i < fileHashes.length; i++) {
@@ -410,26 +267,14 @@ export function valEdit(
 			const endMismatch = mismatches.findLast((m) => m.ref === edit.hash_bounds[1]);
 			if (endMismatch && endMismatch.kind === "not_found") endMismatch.context = startResolved;
 		}
-		return { resolved: undefined, mismatches, boundaryDups };
+		return { resolved: undefined, mismatches };
 	}
-	const endLine = endResolved.line;
-	const rangeLines = fileLines.slice(startResolved.line - 1, endLine);
-	const canonCache = new Map<string, string>();
-	const canonLines = fileLines.map((line) => getCached(canonCache, line, canon));
-	boundaryDups.push(
-		...trailingDups(edit.content_lines, fileLines, endLine),
-		...leadingDups(edit.content_lines, fileLines, startResolved.line),
-		...firstNewAfterDups(edit.content_lines, rangeLines, canonLines, endLine),
-		...lastNewBeforeDups(edit.content_lines, rangeLines, canonLines, startResolved.line),
-	);
-
 	return {
 		resolved: {
 			content_lines: edit.content_lines,
 			hash_bounds: [startResolved, endResolved],
 		},
 		mismatches,
-		boundaryDups,
 	};
 }
 

package/src/insert.ts

@@ -119,7 +119,6 @@ export async function insertPreview(request: unknown, cwd: string, signal?: Abor
       accessMode: constants.R_OK,
       noPersist: true,
       preloadedNorm: preload,
-      skipBoundaryDedup: true,
       signal,
     });
     return previewFromPipe(pipe);
@@ -224,8 +223,6 @@ export function buildInsertToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): I
               signal,
               hedit,
               extraWarnings: [...anchorWarnings, ...insertWarnings, ...resWarnings],
-              skipBoundaryDedup: true,
-              strictBoundaryDedup: false,
               foldedLines: built.anchorLine === undefined ? 0 : 1,
             });
           }
@@ -239,7 +236,6 @@ export function buildInsertToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): I
             accessMode: constants.R_OK | constants.W_OK,
             signal,
             preloadedNorm: preload,
-            skipBoundaryDedup: true,
           });
           return commitEdit(pipe, {
             path: pipe.path,

package/src/replace-diff.ts

@@ -7,7 +7,7 @@ import {
   HASH_CLASS,
   changedRange,
 } from "./hashline";
-import { MAX_DIFF_INPUT_BYTES, DEDUP_ANCHOR } from "./constants";
+import { MAX_DIFF_INPUT_BYTES } from "./constants";
 import { splitLines } from "./utils";
 import {
   detectEnding,
@@ -23,8 +23,6 @@ export interface DiffSpan {
   start: number;
   end: number;
   replacementCount: number;
-  dedupAbove?: string[];
-  dedupBelow?: string[];
 }
 
 interface PlacedSpan {
@@ -32,16 +30,6 @@ interface PlacedSpan {
   oldEnd: number;
   newStart: number;
   newEnd: number;
-  dedupAbove?: string[];
-  dedupBelow?: string[];
-}
-
-export function fmtDedupRow(line: string): string {
-  const row = `${DEDUP_ANCHOR}${HASH_SEP}${line}`;
-  if (Buffer.byteLength(row, "utf-8") <= DEFAULT_MAX_BYTES) return row;
-  const size = formatSize(Buffer.byteLength(row, "utf-8"));
-  const limit = formatSize(DEFAULT_MAX_BYTES);
-  return `${DEDUP_ANCHOR}${HASH_SEP}[Row is ${size}, exceeds ${limit}; content not shown. Use read to see the full line.]`;
 }
 
 function fmtDiffLine(
@@ -168,7 +156,7 @@ function placeSpans(
     if (span.replacementCount === 0) {
       if (newEnd !== newStart - 1) return undefined;
     } else if (newEnd >= newLen) return undefined;
-    placed.push({ oldStart: span.start, oldEnd: span.end, newStart, newEnd, dedupAbove: span.dedupAbove, dedupBelow: span.dedupBelow });
+    placed.push({ oldStart: span.start, oldEnd: span.end, newStart, newEnd });
     offset += span.replacementCount - spanLen;
     removedSum += spanLen;
     addedSum += span.replacementCount;
@@ -197,7 +185,7 @@ function trimPlacedSpans(
       newEnd -= 1;
     }
     if (oldStart > oldEnd && newStart > newEnd) continue;
-    out.push({ oldStart, oldEnd, newStart, newEnd, dedupAbove: span.dedupAbove, dedupBelow: span.dedupBelow });
+    out.push({ oldStart, oldEnd, newStart, newEnd });
   }
   return out;
 }
@@ -212,7 +200,6 @@ function createRowEmitter(
   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;
@@ -247,26 +234,11 @@ function createRowEmitter(
     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,
   };
 }
 
@@ -279,7 +251,7 @@ function genSpanDiff(
   maxLineBytes: number,
   maxBytes: number,
   spans: DiffSpan[],
-): { diff: string; firstChangedLine: number | undefined; lineNumbers: (number | undefined)[]; dedupEmitted: boolean } | undefined {
+): { diff: string; firstChangedLine: number | undefined; lineNumbers: (number | undefined)[] } | undefined {
   const oldLines = splitLines(oldContent);
   const newLines = splitLines(newContent);
   if (oldHashes.length !== oldLines.length || newHashes.length !== newLines.length) return undefined;
@@ -301,7 +273,6 @@ function genSpanDiff(
     return undefined;
   }
   const output: string[] = [];
-  let dedupEmitted = false;
   const lineNumbers: (number | undefined)[] = [];
   let firstChangedLine: number | undefined;
   const em = createRowEmitter(output, lineNumbers, maxLineBytes, maxBytes);
@@ -360,20 +331,12 @@ function genSpanDiff(
     emitGap(newPos, gapLen, spanIdx === 0 ? "leading" : "middle");
     if (em.stopped) break;
     if (firstChangedLine === undefined) firstChangedLine = span.newStart + 1;
-    for (const dedup of span.dedupAbove ?? []) {
-      if (em.stopped) break;
-      if (em.emitDedup(dedup)) dedupEmitted = true;
-    }
     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 && !em.stopped; newIdx++) {
       em.emitRow("+", newLines[newIdx]!, newHashes[newIdx], newIdx + 1);
     }
-    for (const dedup of span.dedupBelow ?? []) {
-      if (em.stopped) break;
-      if (em.emitDedup(dedup)) dedupEmitted = true;
-    }
     oldPos = span.oldEnd + 1;
     newPos = span.newEnd + 1;
   }
@@ -387,7 +350,7 @@ function genSpanDiff(
     output.push(`[diff truncated at ${formatSize(maxBytes)}; use read to see the rest.]`);
     lineNumbers.push(undefined);
   }
-  return { diff: output.join("\n"), firstChangedLine, lineNumbers, dedupEmitted };
+  return { diff: output.join("\n"), firstChangedLine, lineNumbers };
 }
 
 function overDiffInputLimit(oldContent: string, newContent: string): boolean {
@@ -402,14 +365,14 @@ export function genDiff(
   oldContentHashes?: string[],
   limits?: DiffLimits,
   spans?: DiffSpan[],
-): { diff: string; firstChangedLine: number | undefined; lineNumbers: (number|undefined)[]; spanDedupEmitted?: boolean } {
+): { diff: string; firstChangedLine: number | undefined; lineNumbers: (number|undefined)[] } {
   const maxLineBytes = limits?.unlimited ? Number.POSITIVE_INFINITY : (limits?.maxLineBytes ?? DEFAULT_MAX_BYTES);
   const maxBytes = limits?.unlimited ? Number.POSITIVE_INFINITY : (limits?.maxBytes ?? DEFAULT_MAX_BYTES);
   if (spans && newContentHashes && oldContentHashes) {
     const anchored = genSpanDiff(oldContent, newContent, contextLines, newContentHashes, oldContentHashes, maxLineBytes, maxBytes, spans);
     if (anchored) {
       const diff = disambiguateDuplicateAnchors(anchored.diff);
-      return { diff, firstChangedLine: anchored.firstChangedLine, lineNumbers: anchored.lineNumbers, ...(anchored.dedupEmitted ? { spanDedupEmitted: true as const } : {}) };
+      return { diff, firstChangedLine: anchored.firstChangedLine, lineNumbers: anchored.lineNumbers };
     }
   }
   if (!limits?.unlimited && overDiffInputLimit(oldContent, newContent)) {

package/src/replace-render.ts

@@ -3,7 +3,6 @@ import { keyHint, type Theme } from "@earendil-works/pi-coding-agent";
 import type { ReplaceDetails } from "./replace";
 import { abortedBatchMessageFor } from "./batch";
 import { withLineNumbers } from "./utils";
-import { isDedupRow } from "./replace-response";
 import { getPreviewInput } from "./payload-contract";
 export { getPreviewInput };
 
@@ -28,7 +27,6 @@ type DiffRowKind = "added" | "removed" | "context";
 
 function diffRowKind(line: string): DiffRowKind {
 	const withoutGutter = line.replace(/^\s*\d+\s+│\s*/, "");
-	if (isDedupRow(withoutGutter) || isDedupRow(withoutGutter.replace(/^\s*│\s*/, ""))) return "removed";
 	if (withoutGutter.startsWith("+") && !withoutGutter.startsWith("+++")) return "added";
 	if (withoutGutter.startsWith("-") && !withoutGutter.startsWith("---")) return "removed";
 	return "context";