@modelstatus/cli 0.1.60 → 0.1.61

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelstatus/cli",
-  "version": "0.1.60",
+  "version": "0.1.61",
   "description": "Track which AI models you use, where, and never get surprised by a retirement. Free offline model-health for any repo (mm status), browser sign-in for cloud inventory + alerts.",
   "keywords": [
     "llm",

package/src/fix.js

@@ -0,0 +1,127 @@
+/* Auto-fix: rewrite model ids in source files to their registry replacement.
+ *
+ * The scan already knows every reference's file:line + the exact matched string,
+ * and the registry knows each dying model's replacement_slug — so a fix is a
+ * boundary-safe string substitution at a known location. Used by the TUI Here
+ * tab (`f` fix one ref / all refs of a model) and `mm fix` (whole repo).
+ *
+ * Safety rules:
+ *  - 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.
+ *  - 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 path from "node:path";
+
+/** 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;
+}
+
+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. */
+export function replaceOnLine(lineText, from, to) {
+  const re = new RegExp(`(?<!${BOUND})${escRe(from)}(?!${BOUND})`, "g");
+  let n = 0;
+  const out = lineText.replace(re, () => {
+    n += 1;
+    return to;
+  });
+  return { out, n };
+}
+
+/**
+ * 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.
+ */
+export function planFixes(refs, replacementSlug) {
+  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);
+    if (!to || to === r.model_string) continue;
+    const key = `${r.source_path}:${r.source_line}:${r.model_string}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    plans.push({ file: r.source_path, line: r.source_line, from: r.model_string, to });
+  }
+  // The detector can emit BOTH "gpt-4" and "openai/gpt-4" for the same spot. At
+  // one file:line, keep only the most specific plan (drop a `from` that is a
+  // substring of a sibling's) — the longer rewrite covers the shorter one, and
+  // the duplicate would otherwise report a confusing "stale" skip.
+  return plans.filter(
+    (p) => !plans.some((q) => q !== p && q.file === p.file && q.line === p.line && q.from.includes(p.from) && q.from !== p.from),
+  );
+}
+
+/**
+ * Apply plans to files under `dir`. Groups by file so multi-ref files are one
+ * read+write. Returns { applied, stale, failed } — applied entries carry the
+ * occurrence count actually rewritten on that line.
+ */
+export function applyFixes(dir, plans) {
+  const byFile = new Map();
+  for (const p of plans) {
+    const arr = byFile.get(p.file) || [];
+    arr.push(p);
+    byFile.set(p.file, arr);
+  }
+  const applied = [];
+  const stale = [];
+  const failed = [];
+  for (const [file, filePlans] of byFile) {
+    const abs = path.resolve(dir, file);
+    let text;
+    try {
+      text = fs.readFileSync(abs, "utf8");
+    } 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/);
+    let dirty = false;
+    for (const p of filePlans) {
+      const idx = p.line - 1;
+      if (idx < 0 || idx >= lines.length) {
+        stale.push({ ...p, error: "line out of range — rescan" });
+        continue;
+      }
+      const { out, n } = replaceOnLine(lines[idx], p.from, p.to);
+      if (n === 0) {
+        stale.push({ ...p, error: "string not on that line anymore — rescan" });
+        continue;
+      }
+      lines[idx] = out;
+      dirty = true;
+      applied.push({ ...p, count: n });
+    }
+    if (dirty) {
+      try {
+        fs.writeFileSync(abs, lines.join(eol));
+      } catch (e) {
+        // Roll the bookkeeping back: everything in this file actually failed.
+        for (let i = applied.length - 1; i >= 0; i--) {
+          if (applied[i].file === file) failed.push({ ...applied.splice(i, 1)[0], error: e.message });
+        }
+      }
+    }
+  }
+  return { applied, stale, failed };
+}

package/src/index.js

@@ -88,7 +88,7 @@ function parseArgs(argv) {
   const flags = {};
   const positional = [];
   const valueFlags = new Set([
-    "api", "key", "project", "dir", "fail-on", "diff", "json-out",
+    "api", "key", "project", "dir", "fail-on", "diff", "json-out", "model",
     "sources", "region", "namespace", "kube-context", "db", "sql-table", "env",
     // Per-integration scope flags (non-secret): consumed by the 4 live sources.
     "vercel-project", "vercel-team", "gh-repo", "supabase-ref",
@@ -532,6 +532,68 @@ async function cmdClear(_positional, flags) {
   console.log(`✓ Cleared ${res.usages ?? 0} usage(s)${res.projects ? ` + ${res.projects} project(s)` : ""}. Your inventory is clean — rescan to repopulate.`);
 }
 
+/** `mm fix [dir]` — rewrite dying model ids to their registry replacement,
+ * in-place, and print the change list. The scan knows file:line + the exact
+ * string; the registry knows the replacement. --dry-run previews; --yes skips
+ * the confirm; --model <slug> limits to one model. Only filesystem refs are
+ * rewritable (vercel:// etc. are skipped). */
+async function cmdFix(positional, flags) {
+  const dir = path.resolve(positional[1] || flags.dir || ".");
+  const { getRegistry } = await import("./registry/fetch.js");
+  const { resolveLocal, computeHealth } = await import("./registry/local.js");
+  const { planFixes, applyFixes } = await import("./fix.js");
+  const snapshot = await getRegistry({ offline: !!flags.offline, log: (m) => process.stderr.write(`! ${m}\n`) });
+
+  const candidates = await collectFrom(["filesystem"], { root: dir }, snapshot.detection);
+  const resolved = resolveLocal(snapshot, [...new Set(candidates.map((c) => c.model_string))]);
+  const byStr = new Map(resolved.map((r) => [r.input.toLowerCase(), r]));
+  const today = new Date();
+
+  // Group rewritable refs by model; keep only dying models WITH a replacement.
+  const byModel = new Map(); // slug -> { model, health, refs }
+  for (const c of candidates) {
+    const r = byStr.get(c.model_string.toLowerCase());
+    if (!r?.model_slug || !r.model?.replacement_slug) continue;
+    const health = computeHealth(r.model, 90, today);
+    if (health === "ok") continue;
+    if (flags.model && r.model_slug !== flags.model) continue;
+    const e = byModel.get(r.model_slug) || { model: r.model, health, refs: [] };
+    e.refs.push(c);
+    byModel.set(r.model_slug, e);
+  }
+
+  const all = [];
+  for (const { model, health, refs } of byModel.values()) {
+    for (const p of planFixes(refs, model.replacement_slug)) all.push({ ...p, slug: model.slug, health });
+  }
+  if (!all.length) {
+    console.log("Nothing to fix — no deprecated/retiring model with a registry replacement found in scannable files.");
+    return;
+  }
+
+  console.log(`mm fix — ${all.length} reference(s) across ${new Set(all.map((p) => p.file)).size} file(s):\n`);
+  for (const p of all) console.log(`  ${p.file}:${p.line}  ${p.from} → ${p.to}`);
+  if (flags["dry-run"]) {
+    console.log("\n(dry run — nothing written. Re-run without --dry-run to apply.)");
+    return;
+  }
+  if (!flags.yes) {
+    if (!process.stdin.isTTY) {
+      console.error("\nRefusing to rewrite files without confirmation. Re-run with --yes (or --dry-run to preview).");
+      process.exit(1);
+    }
+    const ok = await confirm(`\nRewrite these ${all.length} reference(s) in place? [y/N] `);
+    if (!ok) return console.log("Aborted — nothing changed.");
+  }
+
+  const res = applyFixes(dir, all);
+  if (flags.json) return console.log(JSON.stringify(res, null, 2));
+  console.log(`\n✓ rewrote ${res.applied.length} reference(s) in ${new Set(res.applied.map((p) => p.file)).size} file(s).`);
+  for (const s of res.stale) console.log(`  ! skipped ${s.file}:${s.line} — ${s.error}`);
+  for (const f of res.failed) console.log(`  × failed ${f.file}:${f.line} — ${f.error}`);
+  if (res.applied.length) console.log("\nRe-run your tests, then `mm status` to confirm everything reads current.");
+}
+
 /** List detection sources and whether each can run right now. Live integrations
  * also show their on/off toggle (the `int` column) so toggled state is visible
  * here too. */
@@ -687,6 +749,7 @@ Usage:
   mm signup                Create an account in the browser, then poll
   mm logout                Forget the saved API key
   mm scan [dir]            Scan for model usage; interactive TUI, or --ci/--json for pipelines
+  mm fix [dir]             Rewrite dying model ids to their replacement, in place (--dry-run previews; --model <slug> limits; --yes skips the confirm)
   mm ci [dir]              CI gate: fail the build on deprecated/retiring models (GitHub annotations)
                           (--diff <base> limits findings to files changed vs base; auto on PRs via GITHUB_BASE_REF)
   mm sources               List detection sources and whether each can run here
@@ -800,6 +863,7 @@ async function main() {
     else if (cmd === "signup") await cmdSignup(positional, flags);
     else if (cmd === "logout") cmdLogout();
     else if (cmd === "scan") await cmdScan(positional, flags);
+    else if (cmd === "fix") await cmdFix(positional, flags);
     else if (cmd === "ci") await cmdCi(positional, flags);
     else if (cmd === "status") await cmdStatus(positional, flags);
     else if (cmd === "sources") await cmdSources(positional, flags);

package/src/tui/views/local.js

@@ -27,6 +27,7 @@ export const meta = {
   keys: [
     { k: "↑↓", label: "nav" },
     { k: "↵", label: "refs" },
+    { k: "f", label: "fix → repl" },
     { k: "u", label: "push → Inv" },
     { k: "g", label: "rescan" },
     { k: "/", label: "search" },
@@ -79,6 +80,33 @@ export function LocalView({ client, me, dir, ui, width = 78, height = 14, active
       setPushing(false);
     }
   }
+  /** Rewrite refs of the focused model to its registry replacement (in place,
+   * boundary-safe, y-confirmed). One ref from the drill-in, or all of them. */
+  function fixRefs(refs, what) {
+    const repl = cur?.model?.replacement_slug;
+    if (!cur?.model) return ui?.showToast?.("custom model — no registry replacement known", "#d97706");
+    if (cur.health === "ok") return ui?.showToast?.(`${cur.slug} is current — nothing to fix`, "#d97706");
+    if (!repl) return ui?.showToast?.("no replacement in the registry yet", "#d97706");
+    import("../../fix.js").then(({ planFixes, applyFixes }) => {
+      const plans = planFixes(refs, repl);
+      if (!plans.length) return ui?.showToast?.("no rewritable file refs (integration-sourced?)", "#d97706");
+      ui?.askPrompt?.(`Rewrite ${what} → ${repl}? type y`, {
+        onSubmit: (v) => {
+          if (String(v || "").trim().toLowerCase() !== "y") return ui?.showToast?.("fix cancelled");
+          const res = applyFixes(dir, plans);
+          const files = new Set(res.applied.map((p) => p.file)).size;
+          if (res.applied.length) {
+            ui?.showToast?.(`${GLYPH.check} rewrote ${res.applied.length} ref${res.applied.length === 1 ? "" : "s"} in ${files} file${files === 1 ? "" : "s"} → ${repl}${res.stale.length ? ` · ${res.stale.length} stale skipped` : ""}`);
+            justReloadedRef.current = true;
+            scan.reload(); // re-scan so the list reflects the rewritten files
+          } else {
+            ui?.showToast?.(res.stale.length ? "files changed since the scan — press g to rescan first" : "nothing rewritten", "#dc2626");
+          }
+        },
+      });
+    });
+  }
+
   const tick = useTick(80, running || pushing);
   const spin = SPINNER[tick % SPINNER.length];
   const search = useSearch();
@@ -177,7 +205,7 @@ export function LocalView({ client, me, dir, ui, width = 78, height = 14, active
   const setKeys = ui?.setKeys;
   React.useEffect(() => {
     setKeys?.(focus === "refs"
-      ? [{ k: "↑↓", label: "nav" }, { k: "↵", label: "open in editor" }, { k: "e", label: "exclude path" }, { k: "esc", label: "back" }]
+      ? [{ k: "↑↓", label: "nav" }, { k: "↵", label: "open in editor" }, { k: "f", label: "fix ref" }, { k: "e", label: "exclude path" }, { k: "esc", label: "back" }]
       : null);
     return () => setKeys?.(null);
   }, [setKeys, focus]);
@@ -200,6 +228,7 @@ export function LocalView({ client, me, dir, ui, width = 78, height = 14, active
         if (key.upArrow || input === "k") { refIdxRef.current = clampCursor(refIdxRef.current - 1, drefs.length); return setRefIdx(refIdxRef.current); }
         if (key.return || input === "o") return openRef(drefs[clampCursor(refIdxRef.current, drefs.length)]);
         if (input === "e") return excludeRef(drefs[clampCursor(refIdxRef.current, drefs.length)]);
+        if (input === "f") return fixRefs([drefs[clampCursor(refIdxRef.current, drefs.length)]], "this reference");
         return;
       }
       if (typeof input === "string" && input.startsWith("/")) {
@@ -217,6 +246,7 @@ export function LocalView({ client, me, dir, ui, width = 78, height = 14, active
       if (key.downArrow || input === "j") return nav.down();
       if (key.upArrow || input === "k") return nav.up();
       if (input === "e") return excludeRef(drefs[0]); // exclude the highlighted model's location (editable)
+      if (input === "f") return fixRefs(cur?.refs || [], `all ${cur?.count ?? 0} references`);
       if (input === "p" && running) return scan.togglePause();
       if (input === "g") { justReloadedRef.current = true; return scan.reload(); }
       if (input === "u" && !pushing) return pushToInventory();