@modelstatus/cli 0.1.86 → 0.1.88

package/src/fix.js

@@ -9,15 +9,23 @@
  *  - Replace ONLY on the recorded line. If the string is no longer there (file
  *    changed since the scan), the ref is reported "stale" and skipped — never
  *    guess. A rescan refreshes the locations.
- *  - Boundary-aware matching: "gpt-4" must never rewrite inside "gpt-4o" /
- *    "gpt-4-turbo". A model-id character ([A-Za-z0-9._-]) on either side of the
- *    match blocks it.
+ *  - Boundary-aware matching in LOCKSTEP with detect/core.js (same predicates,
+ *    same case-insensitivity): "gpt-4" must never rewrite inside "gpt-4o" /
+ *    "gpt-4-turbo", but provider prefixes ("anthropic.claude-…", "openai/…")
+ *    are fine on the left — exactly what the scan matched, fix can rewrite.
+ *  - Version-pinned occurrences ("claude-3-sonnet@20240229", Bedrock "-v1:0",
+ *    ft ":acme", template "-${ver}") are NEVER base-swapped — the old model's
+ *    pin glued to the new id is a nonexistent id. They skip with an explicit
+ *    "pinned variant — review manually" note.
+ *  - Never corrupt bytes: non-UTF-8 files are skipped loudly, and every line
+ *    keeps its own \n / \r\n ending (one stray CRLF never converts the file).
  *  - Style-preserving replacement: if the code says "openai/gpt-4" the new id
  *    keeps the provider prefix; if it says "gpt-4" it stays bare.
  */
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { isTokenChar, isPrefixSep, MODEL_SUFFIX } from "./detect/core.js";
 
 /**
  * Follow a replacement chain to the first CURRENT model. Replacements can
@@ -25,6 +33,12 @@ import path from "node:path";
  * rewriting to a dying model just means fixing twice — land on the live one.
  * `getModel(slug)` → model|null; `isCurrent(model)` → bool. Cycle-guarded;
  * unknown slugs end the walk (best known answer wins).
+ *
+ * Returns the WRITE-FORM of the target — "provider/canonical_id" when the
+ * model is known (e.g. "openai/gpt-5.5"), else the registry slug. Registry
+ * slugs dash-encode dots ("openai/gpt-5-5"), and providers reject the slug
+ * form ("gpt-5-5" 404s where the API id is "gpt-5.5") — canonical_id is the
+ * provider's real API id. styleReplacement() derives both styles from it.
  */
 export function terminalReplacement(startSlug, getModel, isCurrent) {
   let cur = startSlug;
@@ -35,7 +49,14 @@ export function terminalReplacement(startSlug, getModel, isCurrent) {
     if (!m || isCurrent(m) || !m.replacement_slug) break;
     cur = m.replacement_slug;
   }
-  return cur || startSlug;
+  const slug = cur || startSlug;
+  const m = getModel(slug);
+  if (m?.canonical_id) {
+    const provider = m.provider_slug
+      || (typeof m.slug === "string" && m.slug.includes("/") ? m.slug.slice(0, m.slug.indexOf("/")) : "");
+    return provider ? `${provider}/${m.canonical_id}` : m.canonical_id;
+  }
+  return slug; // no canonical known — the slug is the best answer we have
 }
 
 /* ------------------------------------------------------------ fix history */
@@ -73,43 +94,94 @@ export function readFixes() {
   }
 }
 
-/** The string to write into the file: the replacement slug, styled to match how
- * the old id was written (provider-prefixed vs bare). */
-export function styleReplacement(oldStr, replacementSlug) {
-  if (!replacementSlug) return null;
-  const i = replacementSlug.indexOf("/");
-  const bare = i >= 0 ? replacementSlug.slice(i + 1) : replacementSlug;
-  return oldStr.includes("/") ? replacementSlug : bare;
+/** The string to write into the file, styled to match how the old id was
+ * written (provider-prefixed vs bare). `replacement` is terminalReplacement's
+ * write-form ("provider/canonical_id", e.g. "openai/gpt-5.5") — bare originals
+ * get the canonical id after the first "/", prefixed originals the whole thing.
+ * (A plain registry slug still styles correctly, just without canonical ids.) */
+export function styleReplacement(oldStr, replacement) {
+  if (!replacement) return null;
+  const i = replacement.indexOf("/");
+  const bare = i >= 0 ? replacement.slice(i + 1) : replacement;
+  return oldStr.includes("/") ? replacement : bare;
 }
 
-const BOUND = "[A-Za-z0-9._-]";
-const escRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-
-/** Boundary-safe replace of every occurrence of `from` in one line of text.
- * Returns { out, n } — the rewritten line and how many occurrences changed. */
+/** Boundary-safe replace of every occurrence of `from` in one line of text,
+ * with the SAME boundary semantics (and case-insensitivity) as detection —
+ * whatever the scan matched, this can find. Occurrences whose right context is
+ * a version pin of the OLD model ("@20240229", "-v1:0", ":acme", "-${ver}")
+ * are never base-swapped (the old pin glued to the new id is a nonexistent
+ * id); they're returned in `pinned` so callers can report them honestly.
+ * Returns { out, n, pinned } — the rewritten line, how many occurrences
+ * changed, and the pinned occurrences (with a bit of right context). */
 export function replaceOnLine(lineText, from, to) {
-  const re = new RegExp(`(?<!${BOUND})${escRe(from)}(?!${BOUND})`, "g");
+  const lower = lineText.toLowerCase();
+  const f = String(from ?? "").toLowerCase();
+  let out = "";
+  let last = 0;
   let n = 0;
-  const out = lineText.replace(re, () => {
-    n += 1;
-    return to;
-  });
-  return { out, n };
+  const pinned = [];
+  let at = 0;
+  while (f && (at = lower.indexOf(f, at)) >= 0) {
+    const before = at > 0 ? lower[at - 1] : "";
+    if (before && isTokenChar(before) && !isPrefixSep(before)) {
+      at += 1; // inside a longer identifier — a later occurrence may be clean
+      continue;
+    }
+    const rest = lower.slice(at + f.length);
+    const after = rest[0] ?? "";
+    // Trailing separators the generic detector trims ("claude-3-5-sonnet-${ver}",
+    // "gpt-4."): a [-._]+ run NOT followed by more token chars.
+    const trimmedTail = rest.replace(/^[-._]+/, "");
+    const isPinned =
+      (after === "@" && /^@[a-z0-9]/.test(rest)) || // Vertex-style @-pin
+      (isTokenChar(after) && MODEL_SUFFIX.test(rest)) || // ':0' / '-v1' / '-20240229'
+      (/^[-._]/.test(rest) && !(trimmedTail && isTokenChar(trimmedTail[0])));
+    if (isPinned) {
+      const ctx = /^[^\s"'`]{0,16}/.exec(lineText.slice(at + f.length))?.[0] ?? "";
+      pinned.push(lineText.slice(at, at + f.length) + ctx);
+      at += f.length;
+      continue;
+    }
+    if (after === "" || !isTokenChar(after)) {
+      out += lineText.slice(last, at) + to;
+      last = at + f.length;
+      n += 1;
+      at += f.length;
+      continue;
+    }
+    at += 1; // embedded in a longer id (gpt-4 in gpt-4o) — keep looking
+  }
+  return { out: out + lineText.slice(last), n, pinned };
+}
+
+/** The skip reason for a line where nothing was rewritten. */
+function skipError(pinned) {
+  return pinned.length
+    ? `pinned variant "${pinned[0]}" — review manually`
+    : "string not on that line anymore — rescan";
+}
+
+/** Decode a buffer as UTF-8 only if it round-trips byte-for-byte — otherwise
+ * null (writing a lossy decode back would corrupt the file: 0xE9 → U+FFFD). */
+function decodeUtf8Strict(buf) {
+  const text = buf.toString("utf8");
+  return Buffer.from(text, "utf8").equals(buf) ? text : null;
 }
 
 /**
  * Build fix plans from scan refs. `refs` = [{ model_string, source_path,
- * source_line }] (the shape the scanner emits); `replacementSlug` is the
- * registry replacement for the model those refs belong to. Refs without a real
- * file path (integration scheme labels like vercel://) are skipped — only
- * filesystem refs are rewritable.
+ * source_line }] (the shape the scanner emits); `replacement` is
+ * terminalReplacement's write-form ("provider/canonical_id") for the model
+ * those refs belong to. Refs without a real file path (integration scheme
+ * labels like vercel://) are skipped — only filesystem refs are rewritable.
  */
-export function planFixes(refs, replacementSlug) {
+export function planFixes(refs, replacement) {
   const plans = [];
   const seen = new Set();
   for (const r of refs || []) {
     if (!r?.source_path || !r.source_line || !r.model_string) continue;
-    const to = styleReplacement(r.model_string, replacementSlug);
+    const to = styleReplacement(r.model_string, replacement);
     if (!to || to === r.model_string) continue;
     const key = `${r.source_path}:${r.source_line}:${r.model_string}`;
     if (seen.has(key)) continue;
@@ -133,24 +205,29 @@ export function planFixes(refs, replacementSlug) {
 export function previewFixes(dir, plans) {
   const previews = [];
   const stale = [];
-  const cache = new Map(); // file -> lines[] | null
+  const cache = new Map(); // file -> { lines } | { error } | {}
   for (const p of plans) {
     if (!cache.has(p.file)) {
+      let entry = {}; // unreadable → "file or line missing" below
       try {
-        cache.set(p.file, fs.readFileSync(path.resolve(dir, p.file), "utf8").split(/\r?\n/));
-      } catch {
-        cache.set(p.file, null);
-      }
+        const text = decodeUtf8Strict(fs.readFileSync(path.resolve(dir, p.file)));
+        entry = text == null ? { error: "not valid UTF-8 — skipped" } : { lines: text.split(/\r?\n/) };
+      } catch { /* keep {} */ }
+      cache.set(p.file, entry);
     }
-    const lines = cache.get(p.file);
-    const before = lines?.[p.line - 1];
+    const ent = cache.get(p.file);
+    if (ent.error) {
+      stale.push({ ...p, error: ent.error });
+      continue;
+    }
+    const before = ent.lines?.[p.line - 1];
     if (before == null) {
       stale.push({ ...p, error: "file or line missing — rescan" });
       continue;
     }
-    const { out, n } = replaceOnLine(before, p.from, p.to);
+    const { out, n, pinned } = replaceOnLine(before, p.from, p.to);
     if (n === 0) {
-      stale.push({ ...p, error: "string not on that line anymore — rescan" });
+      stale.push({ ...p, error: skipError(pinned) });
       continue;
     }
     previews.push({ ...p, before, after: out });
@@ -177,13 +254,20 @@ export function applyFixes(dir, plans) {
     const abs = path.resolve(dir, file);
     let text;
     try {
-      text = fs.readFileSync(abs, "utf8");
+      text = decodeUtf8Strict(fs.readFileSync(abs));
+      if (text == null) {
+        // A lossy decode written back would corrupt every non-UTF-8 byte in
+        // the file (0xE9 → U+FFFD) — refuse loudly instead.
+        for (const p of filePlans) failed.push({ ...p, error: "not valid UTF-8 — skipped" });
+        continue;
+      }
     } catch (e) {
       for (const p of filePlans) failed.push({ ...p, error: e.code === "ENOENT" ? "file not found" : e.message });
       continue;
     }
-    const eol = text.includes("\r\n") ? "\r\n" : "\n";
-    const lines = text.split(/\r?\n/);
+    // Split KEEPING each line's own terminator so untouched lines round-trip
+    // byte-identical — one stray CRLF line must never convert the whole file.
+    const lines = text.split(/(?<=\n)/);
     let dirty = false;
     for (const p of filePlans) {
       const idx = p.line - 1;
@@ -191,19 +275,21 @@ export function applyFixes(dir, plans) {
         stale.push({ ...p, error: "line out of range — rescan" });
         continue;
       }
-      const before = lines[idx];
-      const { out, n } = replaceOnLine(before, p.from, p.to);
+      const raw = lines[idx];
+      const nl = /\r?\n$/.exec(raw)?.[0] ?? "";
+      const body = nl ? raw.slice(0, -nl.length) : raw;
+      const { out, n, pinned } = replaceOnLine(body, p.from, p.to);
       if (n === 0) {
-        stale.push({ ...p, error: "string not on that line anymore — rescan" });
+        stale.push({ ...p, error: skipError(pinned) });
         continue;
       }
-      lines[idx] = out;
+      lines[idx] = out + nl;
       dirty = true;
-      applied.push({ ...p, count: n, before, after: out });
+      applied.push({ ...p, count: n, before: body, after: out });
     }
     if (dirty) {
       try {
-        fs.writeFileSync(abs, lines.join(eol));
+        fs.writeFileSync(abs, lines.join(""));
       } catch (e) {
         // Roll the bookkeeping back: everything in this file actually failed.
         for (let i = applied.length - 1; i >= 0; i--) {