pi-hashline-edit-pro 2.6.2 → 2.6.3

package/README.md

@@ -96,8 +96,8 @@ One edit per call, with `remove_from`, `remove_to`, and `replacement_lines` at t
 Notes:
 
 - The request is checked before any file I/O, so a bad request never touches the file.
-- Common copy-paste slips are fixed automatically and reported: a leftover `HASH│` prefix in `replacement_lines` or `remove_from`/`remove_to`, diff-preview rows pasted into the replacement, a reversed range, or a boundary line pasted twice. New lines that re-include a block adjacent to the range are stripped automatically when that block is unique in the file — the whole run is stripped as one unit (including repeated structural lines like `}`), so re-including an unchanged block next to the range never duplicates it. A missing `path` is resolved from the anchors when they uniquely identify a file in the hash store (reported as a warning); when the anchors match multiple known files the request is rejected with the candidate paths named. `file_path` works as an alias for `path` in all three tools.
-- An edit that produces identical content reports `No changes made` and leaves the anchors alone.
+- Common copy-paste slips are fixed automatically and reported: a leftover `HASH│` prefix (including a truncated or expanded prefix of up to 6 characters, e.g. `L3│` or `ab12│`) in `replacement_lines` or `remove_from`/`remove_to`, diff-preview rows pasted into the replacement, a reversed range, or a boundary line pasted twice. New lines that re-include a block adjacent to the range are stripped automatically when that block is unique in the file — the whole run is stripped as one unit (including repeated structural lines like `}`), so re-including an unchanged block next to the range never duplicates it. A missing `path` is resolved from the anchors when they uniquely identify a file in the hash store (reported as a warning); when the anchors match multiple known files the request is rejected with the candidate paths named. `file_path` works as an alias for `path` in all three tools.
+- An edit that produces identical content reports `No changes made` and leaves the anchors alone. When such a noop happened because a boundary anti-duplication cut removed lines from the replacement (the cut blocked a line that duplicates the block next to the range from being added), the exact same replacement sent once more runs with the edge anti-duplication turned off for that single call and is applied literally — the duplicated lines are kept, and the result carries a `[E_BOUNDARY_BYPASS]` notice. The pending bypass is per file and keyed to that exact payload; any applied edit clears it.
 - Every line in the removed range must match what was last shown to you. The extension records the `HASH│content` rows it serves — `read` output, the auto-read block after `write`, the `+HASH│`/` HASH│` rows of post-edit diffs (replace and undo), the current-range rows of `[E_RANGE_STALE]` feedback, and the context rows of stale/ambiguous-anchor feedback — and verifies the whole range against that record before writing. If an interior line changed on disk since it was shown (external editor, formatter-on-save, code generation) or was never shown, the edit is refused with `[E_RANGE_STALE]` and the current range is returned with fresh anchors, so the retry needs no `read`. Edits outside the served record are only possible for files that were never read (for example right after a `write` with auto-read disabled); once the file has been served, every replaced line must have been shown.
 - After a successful edit you get the post-edit diff with fresh anchors, so you can keep editing without re-reading.
 - Do not issue multiple replace calls on the same file in one message; parallel edits split attention across the post-edit diffs and removed lines are easy to miss. Verify each diff before the next edit on that file.
@@ -181,6 +181,7 @@ A no-op replace never changes the file, so anchors remain valid. On first run af
 | `[E_UNDO_STALE]` | `undo_last_replace` refused: the file was modified or deleted after the last replace. |
 | `[E_UNDO_UNAVAILABLE]` | Undo history could not be persisted to the hash store; the `replace` was refused and the file was left unchanged. |
 | `[E_RANGE_STALE]` | A line in the replaced range no longer matches what was last shown (the file changed on disk, or the line was never shown). The edit was refused; the current range is returned with fresh anchors. |
+| `[E_BOUNDARY_BYPASS]` | The boundary anti-duplication was turned off for one replace call (an identical replacement had previously been cut to a noop); the duplicate lines were applied literally. The dedup is restored for the next call. |
 | `[E_FILE_TOO_LARGE]` | The file exceeds the 238,328-line hashline limit or the 100MB size limit. |
 
 ## Troubleshooting

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "2.6.2",
+  "version": "2.6.3",
   "type": "module",
   "description": "Hash-anchored read/replace/undo tools for pi-coding-agent. Every line gets a unique 3-char hash (A-Za-z0-9) that stays stable across edits; stale or ambiguous anchors are rejected, never fuzzy-matched. Undo persists across restarts.",
   "main": "index.ts",

package/src/boundary-bypass.ts

@@ -0,0 +1,26 @@
+const boundaryBypassTracker = new Map<string, string>();
+
+export function noopPayloadKey(
+  absolutePath: string,
+  removeFrom: string,
+  removeTo: string,
+  replacementLines: string[],
+): string {
+  return JSON.stringify([absolutePath, removeFrom, removeTo, replacementLines]);
+}
+
+export function markBoundaryNoop(absolutePath: string, payload: string): void {
+  boundaryBypassTracker.set(absolutePath, payload);
+}
+
+export function consumeBoundaryBypass(absolutePath: string, payload: string): boolean {
+  if (boundaryBypassTracker.get(absolutePath) === payload) {
+    boundaryBypassTracker.delete(absolutePath);
+    return true;
+  }
+  return false;
+}
+
+export function clearBoundaryBypass(absolutePath: string): void {
+  boundaryBypassTracker.delete(absolutePath);
+}

package/src/hashline/alphabet.ts

@@ -9,4 +9,6 @@ export const ALPH_RE = new RegExp(`^[${ALPH_SAFE}]+$`);
 
 export const HASH_CLASS = `[${ALPH_SAFE}]{${HASH_LEN}}`;
 
+export const HASH_RUN = `[${ALPH_SAFE}]{1,${HASH_LEN * 2}}`;
+
 export const HASH_RE = new RegExp(`^${HASH_CLASS}$`);

package/src/hashline/apply.ts

@@ -147,6 +147,7 @@ export function applyEdit(
 	precomputedHashes?: string[],
 	filePath?: string,
 	servedHashes?: ReadonlySet<string>,
+	skipBoundaryDedup?: boolean,
 	): {
 	content: string;
 	firstChangedLine: number | undefined;
@@ -188,7 +189,7 @@ export function applyEdit(
 
 	let resolved = initialResolved;
 	let autoFixes: AutoFix[] | undefined;
-	if (boundaryDups.length > 0) {
+	if (boundaryDups.length > 0 && !skipBoundaryDedup) {
 		autoFixes = [];
 		const correctedEdit: HEdit = {
 			...prefixFixed,
@@ -241,6 +242,7 @@ export function applyEdit(
 			firstChangedLine: undefined,
 			lastChangedLine: undefined,
 			...(warnings.length ? { warnings } : {}),
+			...(autoFixes ? { autoFixes } : {}),
 			noopEdit: { loc: spanResult.loc, currentContent: spanResult.currentContent },
 		};
 	}

package/src/hashline/hash.ts

@@ -6,8 +6,8 @@ import {
   upsertSnapshot,
 } from "../hash-store";
 import { xxh32, contentChecksum, initHasher } from "./hasher";
-import { HASH_LEN, ALPH, ALPH_RE, HASH_CLASS } from "./alphabet";
-export { initHasher, HASH_LEN, ALPH_RE, HASH_CLASS };
+import { HASH_LEN, ALPH, ALPH_RE, HASH_CLASS, HASH_RUN } from "./alphabet";
+export { initHasher, HASH_LEN, ALPH_RE, HASH_CLASS, HASH_RUN };
 
 export const ANCHOR_LEN = HASH_LEN;
 
@@ -39,13 +39,13 @@ function hashAt(idx: number): string {
 }
 
 export const HL_PREFIX_PLUS_RE = new RegExp(
-	`^\\+${HASH_CLASS}│`,
+	`^\\+${HASH_RUN}│`,
 );
 export const HL_PREFIX_MINUS_RE = new RegExp(
-	`^-(?:${HASH_CLASS}│| {${ANCHOR_LEN}}│)`,
+	`^-(?:${HASH_RUN}│| {${ANCHOR_LEN}}│)`,
 );
 
-export const HL_BARE_PREFIX_RE = new RegExp(`^\\s*(${HASH_CLASS})│`);
+export const HL_BARE_PREFIX_RE = new RegExp(`^\\s*(${HASH_RUN})│`);
 
 export function canon(line: string): string {
 	return line.replace(/\r/g, "").trimEnd();

package/src/hashline/index.ts

@@ -3,6 +3,7 @@ export {
 	ANCHOR_LEN,
 	HASH_SEP,
 	HASH_CLASS,
+	HASH_RUN,
 	HASH_SPACE,
 	HASH_PROBE_STRIDE,
 	MAX_HASH_LINES,

package/src/hashline/resolve.ts

@@ -1,5 +1,5 @@
 import { abortIf, rejectUnknownFields, firstNonEmptyIndex, lastNonEmptyIndex, clipLine } from "../utils";
-import { HASH_CLASS, HASH_SEP, HL_BARE_PREFIX_RE, HL_PREFIX_PLUS_RE, HL_PREFIX_MINUS_RE, canon } from "./hash";
+import { HASH_SEP, HASH_RUN, HL_BARE_PREFIX_RE, HL_PREFIX_PLUS_RE, HL_PREFIX_MINUS_RE, canon } from "./hash";
 import { parseHashRef, parseText, type Anchor } from "./parse";
 import { NEW_CONTENT_NOT_ARRAY_MSG, MAX_RANGE_STALE_LINES } from "../constants";
 
@@ -162,7 +162,7 @@ function assertItem(edit: Record<string, unknown>): void {
   }
 }
 
-const ANCHOR_ROW_RE = new RegExp(`^([+-]?)(${HASH_CLASS})│`);
+const ANCHOR_ROW_RE = new RegExp(`^([+-]?)(${HASH_RUN})│`);
 
 export function resEdit(edit: HTEdit, warnings?: string[]): HEdit {
   assertItem(edit as Record<string, unknown>);

package/src/replace.ts

@@ -47,6 +47,7 @@ import { loadP, loadGuide } from "./prompts";
 import { saveUndo } from "./replace-undo";
 import { loadHashStore, findSnapshotPaths, type HashStore } from "./hash-store";
 import { getServed, recordServedSafe, recordServedDiffSafe } from "./served";
+import { noopPayloadKey, markBoundaryNoop, consumeBoundaryBypass, clearBoundaryBypass } from "./boundary-bypass";
 
 const replacementLinesSchema = Type.Array(
   Type.String({
@@ -107,6 +108,7 @@ interface PipelineResult {
   resultHashes: string[];
   totalAddedLines: number;
   totalRemovedLines: number;
+  hadBoundaryDedup: boolean;
 }
 
 const PREVIEW_DEBOUNCE_MS = 150;
@@ -179,6 +181,7 @@ export interface ExecPipelineOptions {
   signal?: AbortSignal;
   store?: HashStore;
   noPersist?: boolean;
+  skipBoundaryDedup?: boolean;
 }
 
 function collectRemovedHashes(
@@ -252,6 +255,7 @@ export async function execPipeline(
       originalHashes,
       path,
       served,
+      options?.skipBoundaryDedup,
     );
   } catch (error) {
     if (options?.noPersist !== true) {
@@ -298,6 +302,7 @@ export async function execPipeline(
     originalHashes,
     totalAddedLines,
     totalRemovedLines,
+    hadBoundaryDedup: (anchorResult.autoFixes?.length ?? 0) > 0,
   };
 }
 
@@ -477,6 +482,8 @@ export function buildToolDef(): ToolDef {
       const path = normalizedParams.path;
       const absolutePath = toCwd(path, ctx.cwd);
       const mutationTargetPath = await resolveTarget(absolutePath);
+      const noopPayload = noopPayloadKey(mutationTargetPath, normalizedParams.remove_from, normalizedParams.remove_to, normalizedParams.replacement_lines);
+      const boundaryBypass = consumeBoundaryBypass(mutationTargetPath, noopPayload);
       return withFileMutationQueue(mutationTargetPath, async () => {
         abortIf(signal);
 
@@ -492,21 +499,28 @@ export function buildToolDef(): ToolDef {
           firstChangedLine,
           lastChangedLine,
           resultHashes,
+          hadBoundaryDedup,
           totalAddedLines,
           totalRemovedLines,
         } = await execPipeline(
           normalizedParams,
           ctx.cwd,
-          { accessMode: constants.R_OK | constants.W_OK, signal },
+          { accessMode: constants.R_OK | constants.W_OK, signal, skipBoundaryDedup: boundaryBypass },
         );
 
         if (resolution) {
           warnings.unshift(resolution.warning);
         }
+        if (boundaryBypass && originalNormalized !== result) {
+          warnings.push("[E_BOUNDARY_BYPASS] Boundary dedup was off for this call. Boundary dedup is now restored.");
+        }
 
         const editsAttempted = 1;
         if (originalNormalized === result) {
           const noopSnapshotId = await safeSnapId(absolutePath, "noop edit");
+          if (hadBoundaryDedup) {
+            markBoundaryNoop(mutationTargetPath, noopPayload);
+          }
           return buildNoop({
             path,
             noopEdit,
@@ -550,6 +564,7 @@ export function buildToolDef(): ToolDef {
           await undo.restore();
           throw error;
         }
+        clearBoundaryBypass(mutationTargetPath);
         const updatedSnapshotId = await safeSnapId(absolutePath, "post-edit");
 
         const editMeta: RMeta = {