decorated-pi 0.7.3 → 0.8.1

package/tools/patch/core.ts

@@ -11,7 +11,12 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
-import * as fsPromises from "node:fs/promises";
+import {
+  detectFileEncoding,
+  readFileDecoded,
+  writeFileEncoded,
+  type FileEncoding,
+} from "./encoding.js";
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Types
@@ -63,6 +68,14 @@ export interface ReplacementInfo {
   oldLines: string[];
   /** The new lines that replaced them */
   newLines: string[];
+  /** Verbatim normalized replacement text (for byte-faithful writeback). */
+  newStr?: string;
+  /** Offset in normalized content where the matched region starts (writeback). */
+  normStart?: number;
+  /** Offset one past the matched region in normalized content (writeback). */
+  normEnd?: number;
+  /** Anchor was provided but appeared multiple times; matcher fell back to a global old_str search. */
+  anchorNotUnique?: boolean;
   /** Optional anchor text (first line only, for hunk display) */
   anchor?: string;
   /** Anchor was provided but not found, and patch fell back to global old_str search */
@@ -156,13 +169,20 @@ function applyOverwrite(
   content: string,
   result: PatchResult,
 ): void {
-  const oldContent = fs.existsSync(absPath) ? fs.readFileSync(absPath, "utf8") : "";
+  // Detect encoding from the existing file so we round-trip in the same
+  // bytes. New files default to UTF-8 (no BOM).
+  const enc: FileEncoding | null = fs.existsSync(absPath)
+    ? detectFileEncoding(absPath)
+    : null;
+  const oldContent = enc ? readFileDecoded(absPath, enc) : "";
 
   // Write to temp file in the same directory (same filesystem → mv is atomic)
   ensureParentDir(absPath);
   const dir = path.dirname(absPath);
   const tmpName = path.join(dir, `.pi-patch-${randomId()}.tmp`);
-  fs.writeFileSync(tmpName, content, "utf8");
+  // Overwrite semantics: write exactly what the caller passed, in the
+  // detected encoding (UTF-8 for new files).
+  writeFileEncoded(tmpName, content, enc ?? { encoding: "utf-8", hasBOM: false, isUtf8: true });
   fs.renameSync(tmpName, absPath);
 
   if (oldContent) {
@@ -184,6 +204,7 @@ type LocateEditResult =
       matchIdx: number;
       displayAnchor?: string;
       anchorMissing: boolean;
+      anchorNotUnique: boolean;
     }
   | {
       found: false;
@@ -207,6 +228,7 @@ function locateEdit(
   let searchFrom = 0;
   let displayAnchor: string | undefined;
   let anchorMissing = false;
+  let anchorNotUnique = false;
   let anchorState: "ok" | "missing" | "not_unique" = "ok";
   let anchorMessage: string | undefined;
 
@@ -235,7 +257,11 @@ function locateEdit(
   // ── Global exact match fallback (when anchor was missing/unusable) ──
   if (matchIdx === -1 && anchorMessage) {
     displayAnchor = edit.anchor;
-    anchorMissing = true;
+    // Distinguish the two degradation modes: a not-unique anchor still
+    // appeared in the file (just more than once), whereas a missing anchor
+    // did not appear at all. The diff label differs accordingly.
+    if (anchorState === "not_unique") anchorNotUnique = true;
+    else anchorMissing = true;
     matchIdx = content.indexOf(oldNorm, 0);
     if (matchIdx !== -1) {
       const secondGlobalMatch = content.indexOf(oldNorm, matchIdx + 1);
@@ -270,7 +296,7 @@ function locateEdit(
     }
   }
 
-  return { found: true, oldNorm, newNorm, matchIdx, displayAnchor, anchorMissing };
+  return { found: true, oldNorm, newNorm, matchIdx, displayAnchor, anchorMissing, anchorNotUnique };
 }
 
 async function applyEdits(
@@ -287,8 +313,8 @@ async function applyEdits(
     throw new ApplyError(`Cannot patch directory: ${displayPath}`);
   }
 
-  const rawContent = fs.readFileSync(absPath, "utf8");
-  const lineEnding = detectLineEnding(rawContent);
+  const enc = detectFileEncoding(absPath);
+  const rawContent = readFileDecoded(absPath, enc);
   const originalContent = normalizeLineEndings(rawContent);
 
   // Precompute line offsets for the original file (used throughout)
@@ -345,10 +371,12 @@ async function applyEdits(
         );
       }
 
-      const { oldNorm, newNorm, matchIdx, displayAnchor, anchorMissing } = located;
+      const { oldNorm, newNorm, matchIdx, displayAnchor, anchorMissing, anchorNotUnique } = located;
 
       const oldStartLine = lineAtOffset(lineOffsets, matchIdx - cumulativeOffset);
       const oldEndLine = lineAtOffset(lineOffsets, matchIdx - cumulativeOffset + oldNorm.length - 1);
+      const normStart = matchIdx - cumulativeOffset;
+      const normEnd = normStart + oldNorm.length;
 
       content =
         content.substring(0, matchIdx) +
@@ -364,8 +392,12 @@ async function applyEdits(
         newEndLine: 0,
         oldLines: oldNorm.split("\n").filter((l, i, arr) => !(i === arr.length - 1 && l === "")),
         newLines: newNorm.split("\n").filter((l, i, arr) => !(i === arr.length - 1 && l === "")),
+        newStr: newNorm,
+        normStart,
+        normEnd,
         anchor: displayAnchor ? displayAnchor.split("\n")[0] : undefined,
         anchorMissing,
+        anchorNotUnique,
       });
     }
 
@@ -392,12 +424,18 @@ async function applyEdits(
       result.diff = fileDiff;
     }
 
-    const finalContent = restoreLineEndings(content, lineEnding);
-    if (lineEnding === "\r\n" && rawContent.includes("\r\n")) {
-      result.warnings.push(`${displayPath}: CRLF line endings were normalized to LF during editing.`);
-    }
+    const finalContent = spliceOntoRaw(
+      rawContent,
+      cleanReplacements
+        .map((r) => ({
+          normStart: r.normStart ?? 0,
+          normEnd: r.normEnd ?? 0,
+          newStr: r.newStr ?? r.newLines.join("\n"),
+        }))
+        .sort((a, b) => a.normStart - b.normStart),
+    );
 
-    fs.writeFileSync(absPath, finalContent, "utf8");
+    writeFileEncoded(absPath, finalContent, enc);
     result.modified.push(displayPath);
     result.replacements.set(displayPath, cleanReplacements);
     return;
@@ -461,6 +499,7 @@ async function applyEdits(
       newLines: p.newNorm.split("\n").filter((l, i, arr) => !(i === arr.length - 1 && l === "")),
       anchor: p.displayAnchor ? p.displayAnchor.split("\n")[0] : undefined,
       anchorMissing: p.anchorMissing,
+      anchorNotUnique: p.anchorNotUnique,
     });
 
     neededRanges.push({
@@ -495,14 +534,16 @@ async function applyEdits(
     result.diff = fileDiff;
   }
 
-  // Restore line endings
-  const finalContent = restoreLineEndings(content, lineEnding);
-
-  if (lineEnding === "\r\n" && rawContent.includes("\r\n")) {
-    result.warnings.push(`${displayPath}: CRLF line endings were normalized to LF during editing.`);
-  }
+  const finalContent = spliceOntoRaw(
+    rawContent,
+    sorted.map((p) => ({
+      normStart: p.matchIdx,
+      normEnd: p.matchIdx + p.oldNorm.length,
+      newStr: p.newNorm,
+    })),
+  );
 
-  fs.writeFileSync(absPath, finalContent, "utf8");
+  writeFileEncoded(absPath, finalContent, enc);
   result.modified.push(displayPath);
   result.replacements.set(displayPath, replacements);
 }
@@ -541,7 +582,8 @@ export async function computePatchPreview(
         return { error: "File not found" };
       }
 
-      const rawContent = await fsPromises.readFile(absPath, "utf8");
+      const enc = detectFileEncoding(absPath);
+      const rawContent = readFileDecoded(absPath, enc);
     const lineOffsets = buildLineOffsets(rawContent);
     const totalLines = lineOffsets.length - 1;
     let content = normalizeLineEndings(rawContent);
@@ -556,60 +598,26 @@ export async function computePatchPreview(
 
       for (const edit of patch.edits) {
         if (!edit.old_str) continue;
-        let oldNorm = normalizeLineEndings(edit.old_str);
-        let newNorm = normalizeLineEndings(edit.new_str);
-
-        let searchFrom = 0;
-        let displayAnchor: string | undefined;
-        let anchorMissing = false;
-        let anchorNotFoundMessage: string | undefined;
-        if (edit.anchor) {
-          const anchorNorm = normalizeLineEndings(edit.anchor);
-          const idx = content.indexOf(anchorNorm);
-          if (idx === -1) {
-            anchorNotFoundMessage = `Anchor not found: "${truncate(edit.anchor)}"`;
-          } else {
-            const secondAnchor = content.indexOf(anchorNorm, idx + 1);
-            if (secondAnchor !== -1) {
-              anchorNotFoundMessage = `Anchor is not unique: "${truncate(edit.anchor)}"`;
-            } else {
-              searchFrom = Math.max(0, idx - (oldNorm.length - 1));
-              displayAnchor = edit.anchor;
-              anchorMissing = false;
-            }
-          }
-        }
 
-        let matchIdx = anchorNotFoundMessage ? -1 : content.indexOf(oldNorm, searchFrom);
-        if (matchIdx === -1 && anchorNotFoundMessage) {
-          displayAnchor = edit.anchor;
-          anchorMissing = true;
-          matchIdx = content.indexOf(oldNorm, 0);
-          if (matchIdx !== -1) {
-            const secondGlobalMatch = content.indexOf(oldNorm, matchIdx + 1);
-            if (secondGlobalMatch !== -1) {
-              const dupDiag = diagnoseOldStrNotUnique(oldNorm, content);
-              return { error: `${anchorNotFoundMessage}\n${dupDiag}` };
-            }
-          }
+        // Reuse the shared locator so preview and apply can never drift
+        // apart on anchor / fuzzy / uniqueness semantics. The only
+        // difference is error reporting: apply throws, preview returns.
+        let located: LocateEditResult;
+        try {
+          located = locateEdit(edit, content, patch.path);
+        } catch (e) {
+          return { error: e instanceof Error ? e.message : String(e) };
         }
-
-        if (matchIdx === -1) {
-          const searchLine = 0;
-          const fuzzy = tryFuzzyLineMatch(oldNorm, content, searchLine);
-          if (fuzzy) {
-            oldNorm = fuzzy.matched;
-            matchIdx = fuzzy.idx;
-            newNorm = normalizeIndentForFuzzy(fuzzy.matched.split("\n")[0] ?? "", newNorm);
-          } else if (anchorNotFoundMessage) {
-            const diag = diagnoseOldStrMismatch(oldNorm, content);
-            return { error: `${anchorNotFoundMessage}\nold_str not found: "${truncate(edit.old_str)}"\n${diag}` };
-          } else {
-            const diag = diagnoseOldStrMismatch(oldNorm, content);
-            return { error: `old_str not found: "${truncate(edit.old_str)}".\n${diag}` };
+        if (!located.found) {
+          const diag = diagnoseOldStrMismatch(located.oldNorm, content);
+          if (located.anchorState === "missing" || located.anchorState === "not_unique") {
+            return { error: `${located.anchorMessage}\nold_str not found: "${truncate(edit.old_str)}"\n${diag}` };
           }
+          return { error: `old_str not found: "${truncate(edit.old_str)}".${edit.anchor ? ` after anchor "${truncate(edit.anchor)}"` : ""}\n${diag}` };
         }
 
+        const { oldNorm, newNorm, matchIdx, displayAnchor, anchorMissing, anchorNotUnique } = located;
+
         const origMatchIdx = matchIdx - cumulativeOffset;
         const oldStartLine = lineAtOffset(lineOffsets, origMatchIdx);
         const oldEndLine = lineAtOffset(lineOffsets, origMatchIdx + oldNorm.length - 1);
@@ -623,7 +631,7 @@ export async function computePatchPreview(
           startLine: Math.max(1, oldStartLine - CONTEXT_LINES),
           endLine: Math.min(totalLines, oldEndLine + CONTEXT_LINES),
         });
-        allReplacements.push({ oldStartLine, oldEndLine, newStartLine, newEndLine, oldLines, newLines, anchor: displayAnchor ? displayAnchor.split("\n")[0] : undefined, anchorMissing });
+        allReplacements.push({ oldStartLine, oldEndLine, newStartLine, newEndLine, oldLines, newLines, anchor: displayAnchor ? displayAnchor.split("\n")[0] : undefined, anchorMissing, anchorNotUnique });
         cumulativeOffset += newNorm.length - oldNorm.length;
       }
 
@@ -712,6 +720,7 @@ function buildReplacementChunks(
 interface ChunkAnchor {
   text: string;
   missing: boolean;
+  notUnique?: boolean;
 }
 
 function getChunkAnchors(chunk: ReplacementChunk): ChunkAnchor[] {
@@ -724,9 +733,13 @@ function getChunkAnchors(chunk: ReplacementChunk): ChunkAnchor[] {
     for (const text of texts) {
       const existing = byText.get(text);
       if (!existing) {
-        byText.set(text, { text, missing: Boolean(rep.anchorMissing) });
-      } else if (!rep.anchorMissing) {
-        existing.missing = false;
+        byText.set(text, { text, missing: Boolean(rep.anchorMissing), notUnique: Boolean(rep.anchorNotUnique) });
+      } else {
+        // A later rep with the same anchor text that did NOT degrade clears
+        // the stale flag — the anchor is usable in at least one rep, so
+        // don't keep a stale warning for the other.
+        if (!rep.anchorMissing) existing.missing = false;
+        if (!rep.anchorNotUnique) existing.notUnique = false;
       }
     }
   }
@@ -734,7 +747,9 @@ function getChunkAnchors(chunk: ReplacementChunk): ChunkAnchor[] {
 }
 
 function formatAnchorLabel(anchor: ChunkAnchor): string {
-  return anchor.text + (anchor.missing ? " (missing)" : "");
+  if (anchor.notUnique) return anchor.text + " (not unique)";
+  if (anchor.missing) return anchor.text + " (missing)";
+  return anchor.text;
 }
 
 function formatChunkHeader(chunk: ReplacementChunk): string {
@@ -1053,16 +1068,68 @@ function ensureParentDir(absPath: string): void {
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
 }
 
-function detectLineEnding(content: string): string {
-  return content.includes("\r\n") ? "\r\n" : "\n";
-}
-
 function normalizeLineEndings(text: string): string {
   return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
 }
 
-function restoreLineEndings(text: string, ending: string): string {
-  return ending === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
+/** A replacement expressed in coordinates of the normalized (\n-only) content,
+ *  paired with the exact new_str to drop in. Used by spliceOntoRaw to rebuild
+ *  the file byte-for-byte on the original rawContent. */
+interface RawSplice {
+  /** Offset in the normalized content where the matched text starts. */
+  normStart: number;
+  /** Offset in the normalized content one past the matched text. */
+  normEnd: number;
+  /** Verbatim replacement text (already normalized to \n). */
+  newStr: string;
+}
+
+/** Map every index of the normalized content to its offset in rawContent.
+ *  The two strings differ only by `\r` bytes (CRLF→LF normalization removed
+ *  them), so we walk both in lockstep. O(n). */
+function buildNormToRawMap(raw: string, norm: string): Int32Array {
+  const map = new Int32Array(norm.length + 1);
+  let ri = 0;
+  for (let ni = 0; ni <= norm.length; ni++) {
+    // Skip any `\r` in raw that the normalization folded into `\n`.
+    // norm[ni] corresponds to raw[ri]; when norm advances past a `\n` that
+    // came from `\r\n`, raw must skip the `\r` first.
+    if (ni < norm.length) {
+      map[ni] = ri;
+      const ch = norm.charCodeAt(ni);
+      const rawCh = raw.charCodeAt(ri);
+      if (ch === 10 /* \n */ && rawCh === 13 /* \r */) {
+        // raw had \r\n; advance past \r then \n
+        ri += 2;
+      } else {
+        ri += 1;
+      }
+    } else {
+      map[ni] = raw.length;
+    }
+  }
+  return map;
+}
+
+/** Rebuild the file on top of the original rawContent: untouched regions keep
+ *  their original bytes (including CRLF / mixed endings), edited regions get
+ *  the verbatim newStr the caller supplied. Splices must be sorted by
+ *  normStart and non-overlapping. */
+function spliceOntoRaw(rawContent: string, splices: RawSplice[]): string {
+  if (splices.length === 0) return rawContent;
+  const norm = normalizeLineEndings(rawContent);
+  const map = buildNormToRawMap(rawContent, norm);
+  let out = "";
+  let rawCursor = 0;
+  for (const s of splices) {
+    const rawStart = map[s.normStart] ?? 0;
+    const rawEnd = map[s.normEnd] ?? rawContent.length;
+    if (rawStart > rawCursor) out += rawContent.substring(rawCursor, rawStart);
+    out += s.newStr;
+    rawCursor = rawEnd;
+  }
+  if (rawCursor < rawContent.length) out += rawContent.substring(rawCursor);
+  return out;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -1203,8 +1270,12 @@ function collapseSequentialReplacements(
         newEndLine: merged.oldStartLine + next.newLines.length - 1,
         oldLines: merged.oldLines,
         newLines: next.newLines,
+        newStr: next.newStr,
+        normStart: merged.normStart,
+        normEnd: merged.normEnd,
         anchor: undefined,
         anchorMissing: merged.anchorMissing || next.anchorMissing,
+        anchorNotUnique: merged.anchorNotUnique || next.anchorNotUnique,
       };
       j++;
     }
@@ -1530,4 +1601,6 @@ export const __patchCoreTest = {
   truncate,
   collapseSequentialReplacements,
   generateReplacementDiff,
+  spliceOntoRaw,
+  buildNormToRawMap,
 };

package/tools/patch/encoding.ts

@@ -0,0 +1,172 @@
+/**
+ * Encoding detection and conversion for patch.
+ *
+ * - chardet analyses raw bytes (BOM + histogram heuristics) → encoding name.
+ * - iconv-lite decodes/encodes between Buffer and string.
+ *
+ * For UTF-8 (the overwhelmingly common case) we bypass iconv-lite and use
+ * Node's native string<->Buffer conversion — zero behaviour change vs the
+ * pre-encoding-aware tool, and no iconv runtime cost for ASCII/UTF-8 files.
+ */
+
+import * as fs from "node:fs";
+import chardet, { type Match } from "chardet";
+import * as iconv from "iconv-lite";
+
+export interface FileEncoding {
+  /** iconv-lite-compatible encoding name (e.g. "utf-8", "gb18030", "utf-16le"). */
+  encoding: string;
+  /** True when the file starts with a BOM that should be preserved on write. */
+  hasBOM: boolean;
+  /** True when the file is UTF-8 (with or without BOM). Native path is used. */
+  isUtf8: boolean;
+}
+
+// chardet emits "UTF-8" for plain UTF-8. iconv-lite accepts any case.
+const UTF8_ALIASES = new Set(["utf-8", "utf8", "ascii"]);
+const UTF8_BOM = Buffer.from([0xef, 0xbb, 0xbf]);
+const UTF16LE_BOM = Buffer.from([0xff, 0xfe]);
+const UTF16BE_BOM = Buffer.from([0xfe, 0xff]);
+
+/** Returns true if `buf` is valid UTF-8 (every byte parses, no U+FFFD
+ *  replacement). Pure-ASCII and any well-formed UTF-8 qualify. */
+function isValidUtf8(buf: Buffer): boolean {
+  // Writing then reading back would corrupt invalid sequences into U+FFFD;
+  // detect that by comparing round-trip byte lengths. The cheap, correct
+  // check is Node's built-in: toString('utf8') replaces bad sequences with
+  // U+FFFD, so we scan the decoded string for it.
+  if (buf.length === 0) return true;
+  const s = buf.toString("utf8");
+  return !s.includes("\uFFFD");
+}
+
+function looksLikeUtf8Bom(buf: Buffer): boolean {
+  return buf.length >= 3 && buf[0] === 0xef && buf[1] === 0xbb && buf[2] === 0xbf;
+}
+
+function looksLikeUtf16LeBom(buf: Buffer): boolean {
+  return buf.length >= 2 && buf[0] === 0xff && buf[1] === 0xfe;
+}
+
+function looksLikeUtf16BeBom(buf: Buffer): boolean {
+  return buf.length >= 2 && buf[0] === 0xfe && buf[1] === 0xff;
+}
+
+/**
+ * Detect a file's encoding by reading its bytes.
+ * Falls back to UTF-8 if detection fails or the detected encoding is not
+ * supported by iconv-lite.
+ */
+export function detectFileEncoding(filePath: string): FileEncoding {
+  const buf = fs.readFileSync(filePath);
+
+  // BOM takes precedence for the UTF-16/UTF-32 family (endianness matters).
+  if (looksLikeUtf8Bom(buf)) {
+    return { encoding: "utf-8", hasBOM: true, isUtf8: true };
+  }
+  if (looksLikeUtf16LeBom(buf)) {
+    return { encoding: "utf-16le", hasBOM: true, isUtf8: false };
+  }
+  if (looksLikeUtf16BeBom(buf)) {
+    return { encoding: "utf-16be", hasBOM: true, isUtf8: false };
+  }
+
+  // Any well-formed UTF-8 (including pure ASCII) is UTF-8. This short-circuits
+  // chardet's tendency to mis-classify short or ASCII-only buffers as exotic
+  // encodings (e.g. 2-byte "x\n" as utf-32le).
+  if (isValidUtf8(buf)) {
+    return { encoding: "utf-8", hasBOM: false, isUtf8: true };
+  }
+
+  // Not valid UTF-8 — trust chardet's heuristic for the legacy encoding.
+  // chardet mis-classifies short or mixed CJK samples (it often ties GBK,
+  // Big5, Shift_JIS, EUC-JP, EUC-KR at the same low confidence). Use the
+  // full ranked list and prefer Chinese encodings — GB18030 is a superset
+  // of GBK/GB2312 and the most common non-UTF-8 encoding for Chinese text,
+  // which is the primary use case for this tool.
+  const candidates = chardet.analyse(buf);
+  let encoding = pickLegacyEncoding(candidates);
+  let hasBOM = false;
+
+  // Verify iconv-lite actually ships a codec for this label; otherwise fall
+  // back to UTF-8 (the previous behaviour) instead of throwing mid-edit.
+  if (!iconv.encodingExists(encoding)) {
+    encoding = "utf-8";
+    hasBOM = false;
+  }
+
+  // Last-resort safety net: if the chosen encoding still produces U+FFFD
+  // replacement chars on decode, the file is not actually in that encoding
+  // and we would corrupt it on write-back. Fall back to ISO-8859-1 (Latin1),
+  // which is a lossless 1:1 byte<->code-point mapping for 0x00–0xFF and can
+  // never introduce U+FFFD — round-tripping is byte-identical.
+  if (!UTF8_ALIASES.has(encoding) && iconv.decode(buf, encoding).includes("\uFFFD")) {
+    encoding = "iso-8859-1";
+    hasBOM = false;
+  }
+
+  return {
+    encoding,
+    hasBOM,
+    isUtf8: UTF8_ALIASES.has(encoding),
+  };
+}
+
+/** Preference order for breaking chardet ties. Chinese first (GB18030 is a
+ *  superset of GBK/GB2312), then other CJK, then everything else. */
+const ENCODING_PRIORITY: string[] = [
+  "gb18030", "gbk", "gb2312",  // Chinese (mainland)
+  "big5",                       // Chinese (traditional)
+  "shift_jis", "euc-jp",        // Japanese
+  "euc-kr", "windows-949",      // Korean
+  "windows-1252", "iso-8859-1", // Western (rarely reached: isValidUtf8 short-circuits)
+];
+
+function pickLegacyEncoding(candidates: Match[]): string {
+  if (candidates.length === 0) return "iso-8859-1";
+  const top = candidates[0]!.confidence;
+  // Keep only candidates tied with the top confidence (±5 tolerance —
+  // chardet's scores are coarse).
+  const tied = candidates.filter((c) => Math.abs(c.confidence - top) <= 5);
+  for (const pref of ENCODING_PRIORITY) {
+    const hit = tied.find((c) => c.name.toLowerCase() === pref);
+    if (hit) return pref;
+  }
+  // We only reach here when isValidUtf8 already failed (there are high
+  // bytes), so "ascii" / "UTF-8" from chardet are wrong. ISO-8859-1 is the
+  // safe single-byte fallback — lossless for 0x00–0xFF, no U+FFFD.
+  return "iso-8859-1";
+}
+
+/** Read a file as a string, decoding via the detected encoding. */
+export function readFileDecoded(filePath: string, enc: FileEncoding): string {
+  const buf = fs.readFileSync(filePath);
+  if (enc.isUtf8) {
+    // Native path: identical to the old fs.readFileSync(p, "utf8").
+    // For UTF-8 with BOM, slice off the BOM so it does not leak into content
+    // matching (it would prefix the first line and break old_str lookups).
+    const slice = enc.hasBOM ? buf.subarray(3) : buf;
+    return slice.toString("utf8");
+  }
+  return iconv.decode(buf, enc.encoding, { stripBOM: true });
+}
+
+/** Write a string back to a file, encoding via the detected encoding. */
+export function writeFileEncoded(
+  filePath: string,
+  content: string,
+  enc: FileEncoding,
+): void {
+  if (enc.isUtf8) {
+    if (enc.hasBOM) {
+      const body = Buffer.from(content, "utf8");
+      const out = Buffer.concat([UTF8_BOM, body]);
+      fs.writeFileSync(filePath, out);
+      return;
+    }
+    fs.writeFileSync(filePath, content, "utf8");
+    return;
+  }
+  const buf = iconv.encode(content, enc.encoding, { addBOM: enc.hasBOM });
+  fs.writeFileSync(filePath, buf);
+}

package/tools/patch/index.ts

@@ -162,13 +162,17 @@ function createSingleLineComponent(text: string) {
     };
 }
 
-function formatPatchMetaLine(line: string, theme: any): string {
-    const missingSuffix = " (missing)";
-    if (line.endsWith(missingSuffix)) {
-        return (
-            theme.fg("accent", line.slice(0, -missingSuffix.length)) +
-            theme.fg("warning", missingSuffix)
-        );
+export function formatPatchMetaLine(line: string, theme: any): string {
+    // Anchor status suffixes share the same warning color so a degraded
+    // anchor (missing or not-unique) stands out from the diff body.
+    const suffixes = [" (missing)", " (not unique)"];
+    for (const suffix of suffixes) {
+        if (line.endsWith(suffix)) {
+            return (
+                theme.fg("accent", line.slice(0, -suffix.length)) +
+                theme.fg("warning", suffix)
+            );
+        }
     }
     return theme.fg("accent", line);
 }