pi-hashline-edit-pro 2.6.3 → 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.
@@ -97,7 +97,7 @@ 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 (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.
+- 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.

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.3",
+  "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

@@ -1,3 +1,25 @@
+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(
@@ -6,7 +28,12 @@ export function noopPayloadKey(
   removeTo: string,
   replacementLines: string[],
 ): string {
-  return JSON.stringify([absolutePath, removeFrom, removeTo, replacementLines]);
+  return JSON.stringify([
+    absolutePath,
+    canonRef(removeFrom),
+    canonRef(removeTo),
+    canonLines(replacementLines),
+  ]);
 }
 
 export function markBoundaryNoop(absolutePath: string, payload: string): void {

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/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,
     };
   }
 

package/src/hashline/resolve.ts

@@ -162,7 +162,7 @@ function assertItem(edit: Record<string, unknown>): void {
   }
 }
 
-const ANCHOR_ROW_RE = new RegExp(`^([+-]?)(${HASH_RUN})│`);
+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);
 				}