pi-hashline-edit-pro 2.6.2 → 2.6.4

package/README.md

@@ -66,7 +66,7 @@ Lines up to 200KB are shown in full. Larger lines are replaced by a marker with
 Edge cases:
 
 - Images (JPEG, PNG, GIF, WebP, BMP) come back as visual attachments. Other image formats (for example AVIF, HEIC/HEIF, TIFF, ICO, JPEG 2000, JPEG XL, PSD, APNG) are rejected as binary, since the built-in renderer cannot attach them.
-- Binary files and directories are rejected with a descriptive error. A magic-signature match is ignored when the sampled bytes contain no NUL bytes and decode as UTF-8, so a text file whose first bytes happen to match a binary or image signature (for example starting with `BM` or `8BPS`) is still read as text.
+- Binary files and directories are rejected with a descriptive error. A magic-signature match is ignored when the sampled bytes contain no NUL bytes and decode as UTF-8, so a text file whose first bytes happen to match a binary or image signature (for example starting with `BM` or `8BPS`) is still read as text. The NUL-byte check covers the whole file, not just the sampled bytes: a file with a NUL byte anywhere is rejected as binary.
 - UTF-16 and UTF-32 text (detected via BOM) is rejected, since editing it would corrupt the file.
 - Empty files come back as a single empty-line hash (`HASH│`); use `replace` on that hash to insert content.
 - BOMs are stripped for display. Non-UTF-8 bytes are shown as `U+FFFD`; editing such a file rewrites it as UTF-8, with a warning.
@@ -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 payload; copied `HASH│` prefixes, diff markers, and stray whitespace in the resend are normalized before matching, so a copy-paste resend still hits it. Any applied edit clears it, and a successful `write` also 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/index.ts

@@ -14,6 +14,7 @@ import {
 } from "./src/config";
 import { loadHashStore, pruneMissing } from "./src/hash-store";
 import { recordServedSafe, clearServed } from "./src/served";
+import { clearBoundaryBypass } from "./src/boundary-bypass";
 import { readNormFile } from "./src/file-reader";
 import { loadFileKindAndText } from "./src/file-kind";
 import { toCwd } from "./src/paths";
@@ -64,6 +65,7 @@ export default function (pi: ExtensionAPI): void {
         try {
           const target = await resolveTarget(toCwd(writtenPath, ctx.cwd));
           await clearUndo(target);
+          clearBoundaryBypass(target);
           const store = await loadHashStore();
           clearServed(store, target);
         } catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "2.6.2",
+  "version": "2.6.4",
   "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,53 @@
+import { parseText } from "./hashline/parse";
+import { ANCHOR_ROW_RE } from "./hashline/resolve";
+import { HL_BARE_PREFIX_RE, HL_PREFIX_PLUS_RE, HL_PREFIX_MINUS_RE } from "./hashline/hash";
+
+function canonRef(ref: string): string {
+  const trimmed = ref.trim();
+  const match = trimmed.match(ANCHOR_ROW_RE);
+  return match ? match[2]! : trimmed;
+}
+
+function canonLines(lines: string[]): string[] {
+  return parseText(lines).map((line) => {
+    const bare = line.match(HL_BARE_PREFIX_RE);
+    if (bare) return line.slice(bare[0].length);
+    const plus = line.match(HL_PREFIX_PLUS_RE);
+    if (plus) return line.slice(plus[0].length);
+    const minus = line.match(HL_PREFIX_MINUS_RE);
+    if (minus) return line.slice(minus[0].length);
+    return line;
+  });
+}
+
+const boundaryBypassTracker = new Map<string, string>();
+
+export function noopPayloadKey(
+  absolutePath: string,
+  removeFrom: string,
+  removeTo: string,
+  replacementLines: string[],
+): string {
+  return JSON.stringify([
+    absolutePath,
+    canonRef(removeFrom),
+    canonRef(removeTo),
+    canonLines(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/file-kind.ts

@@ -125,6 +125,7 @@ export async function loadFileKindAndText(
 
     const decoder = new TextDecoder("utf-8", { fatal: false, ignoreBOM: true });
     let hadUtf8DecodeErrors = false;
+    let containsNul = false;
     let newlineCount = 0;
     const parts: string[] = [];
 
@@ -133,6 +134,9 @@ export async function loadFileKindAndText(
       if (!hadUtf8DecodeErrors && decoded.includes("\uFFFD")) {
         hadUtf8DecodeErrors = true;
       }
+      if (!containsNul && decoded.includes("\0")) {
+        containsNul = true;
+      }
       if (options?.maxLines !== undefined) {
         for (let i = 0; i < decoded.length; i++) {
           if (decoded.charCodeAt(i) === 10) newlineCount++;
@@ -166,6 +170,10 @@ export async function loadFileKindAndText(
     }
     parts.push(decodeChunk(new Uint8Array(0), false));
 
+    if (containsNul) {
+      return { kind: "binary", description: "contains NUL bytes" };
+    }
+
     return {
       kind: "text",
       text: parts.join(""),

package/src/fs-write.ts

@@ -142,7 +142,7 @@ export async function writeAtomic(
     }
     await tempHandle.sync();
   } catch (error: unknown) {
-    await tempHandle.close();
+    try { await tempHandle.close(); } catch {}
     try { await rm(tempPath, { force: true }); } catch {}
     throw error;
   }

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

@@ -84,11 +84,19 @@ function resToSpan(
   }
 
   if (edit.content_lines.length > 0) {
+    const lastReplacementLine = edit.content_lines[edit.content_lines.length - 1]!;
+    const endsWithBlank = lastReplacementLine.length === 0;
+    const endsAtEofWithoutNewline =
+      endLine === fileLines.length && !content.endsWith("\n");
+    const replacement = edit.content_lines.join("\n");
     return {
       kind: "replace",
       start: lineStarts[startLine - 1]!,
       end: lineStarts[endLine - 1]! + fileLines[endLine - 1]!.length,
-      replacement: edit.content_lines.join("\n"),
+      replacement:
+        endsAtEofWithoutNewline && endsWithBlank
+          ? `${replacement}\n`
+          : replacement,
     };
   }
 
@@ -147,6 +155,7 @@ export function applyEdit(
 	precomputedHashes?: string[],
 	filePath?: string,
 	servedHashes?: ReadonlySet<string>,
+	skipBoundaryDedup?: boolean,
 	): {
 	content: string;
 	firstChangedLine: number | undefined;
@@ -188,7 +197,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 +250,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})│`);
+export const ANCHOR_ROW_RE = new RegExp(`^([+-]?)(${HASH_RUN})│`);
 
 export function resEdit(edit: HTEdit, warnings?: string[]): HEdit {
   assertItem(edit as Record<string, unknown>);

package/src/prompts.ts

@@ -1,23 +1,11 @@
 import { readFileSync } from "fs";
 
-export function loadP(relativePath: string, replacements?: Record<string, string>): string {
-  let content = readFileSync(new URL(relativePath, import.meta.url), "utf-8").trim();
-  if (replacements) {
-    for (const [key, value] of Object.entries(replacements)) {
-      content = content.split(`{{${key}}}`).join(value);
-    }
-  }
-  return content;
+export function loadP(relativePath: string): string {
+  return readFileSync(new URL(relativePath, import.meta.url), "utf-8").trim();
 }
 
-export function loadGuide(relativePath: string, replacements?: Record<string, string>): string[] {
-  let content = readFileSync(new URL(relativePath, import.meta.url), "utf-8");
-  if (replacements) {
-    for (const [key, value] of Object.entries(replacements)) {
-      content = content.split(`{{${key}}}`).join(value);
-    }
-  }
-  return content
+export function loadGuide(relativePath: string): string[] {
+  return readFileSync(new URL(relativePath, import.meta.url), "utf-8")
     .split("\n")
     .map((line) => line.trim())
     .filter((line) => line.startsWith("- "))

package/src/replace-render.ts

@@ -50,14 +50,19 @@ export function getPreviewInput(
 	return request;
 }
 
+type DiffRowKind = "added" | "removed" | "context";
+
+function diffRowKind(line: string): DiffRowKind {
+	if (line.startsWith("+") && !line.startsWith("+++")) return "added";
+	if (line.startsWith("-") && !line.startsWith("---")) return "removed";
+	return "context";
+}
+
 export function colorLines(lines: string[], theme: FgT): string[] {
 	return lines.map((line) => {
-		if (line.startsWith("+") && !line.startsWith("+++")) {
-			return theme.fg("success", line);
-		}
-		if (line.startsWith("-") && !line.startsWith("---")) {
-			return theme.fg("error", line);
-		}
+		const kind = diffRowKind(line);
+		if (kind === "added") return theme.fg("success", line);
+		if (kind === "removed") return theme.fg("error", line);
 		return theme.fg("dim", line);
 	});
 }
@@ -194,12 +199,9 @@ export function mkMdTheme(theme: MdTheme) {
 		highlightCode: (code: string, lang?: string) =>
 			code.split("\n").map((line) => {
 				if (lang === "diff") {
-					if (line.startsWith("+") && !line.startsWith("+++")) {
-						return theme.fg("toolDiffAdded", line);
-					}
-					if (line.startsWith("-") && !line.startsWith("---")) {
-						return theme.fg("toolDiffRemoved", line);
-					}
+					const kind = diffRowKind(line);
+					if (kind === "added") return theme.fg("toolDiffAdded", line);
+					if (kind === "removed") return theme.fg("toolDiffRemoved", line);
 					return theme.fg("toolDiffContext", line);
 				}
 

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 = {