@modelstatus/cli 0.1.62 → 0.1.64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelstatus/cli",
-  "version": "0.1.62",
+  "version": "0.1.64",
   "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

@@ -16,8 +16,62 @@
  *    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";
 
+/**
+ * Follow a replacement chain to the first CURRENT model. Replacements can
+ * themselves be dying (davinci → gpt-3-5-turbo [deprecating] → gpt-4o-mini), and
+ * 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).
+ */
+export function terminalReplacement(startSlug, getModel, isCurrent) {
+  let cur = startSlug;
+  const seen = new Set();
+  while (cur && !seen.has(cur)) {
+    seen.add(cur);
+    const m = getModel(cur);
+    if (!m || isCurrent(m) || !m.replacement_slug) break;
+    cur = m.replacement_slug;
+  }
+  return cur || startSlug;
+}
+
+/* ------------------------------------------------------------ fix history */
+
+// MM_FIXES_FILE override keeps tests off the real user history.
+const FIXES_FILE = process.env.MM_FIXES_FILE || path.join(os.homedir(), ".config", "llmstatus", "fixes.json");
+const FIXES_CAP = 300;
+
+/** Append applied fixes to the local history (newest first, capped). Read by
+ * the TUI's What's New → Fixes section. Best-effort — never throws. */
+export function recordFixes(dir, applied, { source = "tui" } = {}) {
+  if (!applied?.length) return;
+  try {
+    let log = [];
+    try {
+      const j = JSON.parse(fs.readFileSync(FIXES_FILE, "utf8"));
+      if (Array.isArray(j)) log = j;
+    } catch { /* first write */ }
+    const ts = Date.now();
+    const entries = applied.map((p) => ({ ts, dir: path.resolve(dir), file: p.file, line: p.line, from: p.from, to: p.to, source }));
+    log = [...entries, ...log].slice(0, FIXES_CAP);
+    fs.mkdirSync(path.dirname(FIXES_FILE), { recursive: true, mode: 0o700 });
+    fs.writeFileSync(FIXES_FILE, JSON.stringify(log));
+  } catch { /* best effort */ }
+}
+
+/** The recorded fix history, newest first. Never throws. */
+export function readFixes() {
+  try {
+    const j = JSON.parse(fs.readFileSync(FIXES_FILE, "utf8"));
+    return Array.isArray(j) ? j : [];
+  } catch {
+    return [];
+  }
+}
+
 /** 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) {
@@ -70,6 +124,39 @@ export function planFixes(refs, replacementSlug) {
   );
 }
 
+/**
+ * READ-ONLY preview of what applyFixes would do: each plan gains the full line
+ * text before/after (the TUI's diff visual). Nothing is written. Plans whose
+ * line no longer carries the string come back in `stale`.
+ */
+export function previewFixes(dir, plans) {
+  const previews = [];
+  const stale = [];
+  const cache = new Map(); // file -> lines[] | null
+  for (const p of plans) {
+    if (!cache.has(p.file)) {
+      try {
+        cache.set(p.file, fs.readFileSync(path.resolve(dir, p.file), "utf8").split(/\r?\n/));
+      } catch {
+        cache.set(p.file, null);
+      }
+    }
+    const lines = cache.get(p.file);
+    const before = 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);
+    if (n === 0) {
+      stale.push({ ...p, error: "string not on that line anymore — rescan" });
+      continue;
+    }
+    previews.push({ ...p, before, after: out });
+  }
+  return { previews, stale };
+}
+
 /**
  * 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

package/src/index.js

@@ -541,7 +541,7 @@ 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 { planFixes, applyFixes, terminalReplacement, recordFixes } = 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);
@@ -562,18 +562,28 @@ async function cmdFix(positional, flags) {
     byModel.set(r.model_slug, e);
   }
 
+  const bySlug = new Map(snapshot.models.map((m) => [m.slug, m]));
+  const isCurrent = (m) => computeHealth(m, 90, today) === "ok";
   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 });
+    // Chase the replacement chain — rewriting to a model that's ITSELF dying
+    // (davinci → gpt-3-5-turbo → gpt-4o-mini) just means fixing twice.
+    const target = terminalReplacement(model.replacement_slug, (slug) => bySlug.get(slug) ?? null, isCurrent);
+    for (const p of planFixes(refs, target)) all.push({ ...p, slug: model.slug, health });
   }
   if (!all.length) {
+    if (flags.json) return console.log(JSON.stringify({ applied: [], stale: [], failed: [], reason: "nothing to fix" }, null, 2));
     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}`);
+  // --json = machine output: NOTHING but JSON on stdout.
+  if (!flags.json) {
+    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"]) {
+    if (flags.json) return console.log(JSON.stringify({ planned: all, dryRun: true }, null, 2));
     console.log("\n(dry run — nothing written. Re-run without --dry-run to apply.)");
     return;
   }
@@ -587,6 +597,7 @@ async function cmdFix(positional, flags) {
   }
 
   const res = applyFixes(dir, all);
+  recordFixes(dir, res.applied, { source: "cli" });
   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}`);

package/src/tui/views/local.js

@@ -18,6 +18,7 @@ import { buildUsages, assignProjects } from "../../upload.js";
 import { readSnippet } from "../snippet.js";
 import { openLocation } from "../../openUrl.js";
 import { addGlobalIgnore } from "../../sources/filesystem.js";
+import { computeHealth } from "../../registry/local.js";
 
 // Ordered by survival priority — KeyBar drops trailing entries on narrow
 // terminals, so the primary verb (u push) and recovery (g rescan) must come
@@ -80,39 +81,56 @@ 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. */
+  /** Fix flow, two beats: `f` opens a PREVIEW (the real diff — old line red,
+   * new line green) and `y` on the preview applies it. One ref from the
+   * drill-in, or all of them from the list. */
+  const [fixPreview, setFixPreview] = React.useState(null); // { previews, stale, repl, what }
   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, styleReplacement }) => {
+    if (!cur.model.replacement_slug) return ui?.showToast?.("no replacement in the registry yet", "#d97706");
+    import("../../fix.js").then(({ planFixes, previewFixes, terminalReplacement }) => {
+      // Chase the replacement chain to the first CURRENT model — rewriting to a
+      // model that's itself dying just means pressing f twice.
+      const models = scan.snapshot?.models || [];
+      const bySlug = new Map(models.map((m) => [m.slug, m]));
+      const today = new Date();
+      const repl = terminalReplacement(
+        cur.model.replacement_slug,
+        (slug) => bySlug.get(slug) ?? null,
+        (m) => computeHealth(m, 90, today) === "ok",
+      );
       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) {
-            // Update the in-memory scan IN PLACE (no filesystem re-walk — on a big
-            // workspace a surprise full rescan reads as "what is it doing?!").
-            // Any candidate at a rewritten file:line whose string overlaps the
-            // applied rewrite re-styles to the replacement; g still re-verifies.
-            scan.applyEdit?.((cands) => cands.map((c) => {
-              const hit = res.applied.find((p) => p.file === c.source_path && p.line === c.source_line
-                && (p.from === c.model_string || p.from.includes(c.model_string) || c.model_string.includes(p.from)));
-              if (!hit) return c;
-              const to = styleReplacement(c.model_string, repl);
-              return to ? { ...c, model_string: to } : c;
-            }));
-            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` : ""}`);
-          } else {
-            ui?.showToast?.(res.stale.length ? "files changed since the scan — press g to rescan first" : "nothing rewritten", "#dc2626");
-          }
-        },
-      });
+      const { previews, stale } = previewFixes(dir, plans);
+      if (!previews.length) return ui?.showToast?.("files changed since the scan — press g to rescan first", "#dc2626");
+      setFixPreview({ previews, stale, repl, what });
+    });
+  }
+
+  /** y on the preview: write the files, log history, patch the scan in place. */
+  function applyFixPreview() {
+    const fp = fixPreview;
+    if (!fp) return;
+    setFixPreview(null);
+    import("../../fix.js").then(({ applyFixes, styleReplacement, recordFixes }) => {
+      const res = applyFixes(dir, fp.previews);
+      recordFixes(dir, res.applied, { source: "tui" });
+      const files = new Set(res.applied.map((p) => p.file)).size;
+      if (res.applied.length) {
+        // Update the in-memory scan IN PLACE (no filesystem re-walk — on a big
+        // workspace a surprise full rescan reads as "what is it doing?!").
+        scan.applyEdit?.((cands) => cands.map((c) => {
+          const hit = res.applied.find((p) => p.file === c.source_path && p.line === c.source_line
+            && (p.from === c.model_string || p.from.includes(c.model_string) || c.model_string.includes(p.from)));
+          if (!hit) return c;
+          const to = styleReplacement(c.model_string, fp.repl);
+          return to ? { ...c, model_string: to } : c;
+        }));
+        ui?.showToast?.(`${GLYPH.check} rewrote ${res.applied.length} ref${res.applied.length === 1 ? "" : "s"} in ${files} file${files === 1 ? "" : "s"} → ${fp.repl}${res.stale.length ? ` · ${res.stale.length} stale skipped` : ""}`);
+      } else {
+        ui?.showToast?.(res.stale.length ? "files changed since the scan — press g to rescan first" : "nothing rewritten", "#dc2626");
+      }
     });
   }
 
@@ -205,23 +223,30 @@ export function LocalView({ client, me, dir, ui, width = 78, height = 14, active
   // into refs, or an active filter) rather than stepping to the previous tab.
   const setHandlesBack = ui?.setHandlesBack;
   React.useEffect(() => {
-    setHandlesBack?.(focus === "refs" || !!search.query);
+    setHandlesBack?.(focus === "refs" || !!search.query || !!fixPreview);
     return () => setHandlesBack?.(false);
-  }, [setHandlesBack, focus, search.query]);
+  }, [setHandlesBack, focus, search.query, fixPreview]);
 
   // The refs drill-in swaps the keymap (↵ opens in editor, esc backs out) — the
   // keybar must say so instead of advertising the dead list keys.
   const setKeys = ui?.setKeys;
   React.useEffect(() => {
-    setKeys?.(focus === "refs"
-      ? [{ k: "↑↓", label: "nav" }, { k: "↵", label: "open in editor" }, { k: "f", label: "fix ref" }, { k: "e", label: "exclude path" }, { k: "esc", label: "back" }]
-      : null);
+    setKeys?.(fixPreview
+      ? [{ k: "y", label: "apply" }, { k: "esc", label: "cancel" }]
+      : focus === "refs"
+        ? [{ 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]);
+  }, [setKeys, focus, fixPreview]);
 
   useInput(
     (input, key) => {
       if (!active) return;
+      if (fixPreview) {
+        if (input === "y" || key.return) return applyFixPreview();
+        if (key.escape || key.backspace || key.delete || input === "n") { setFixPreview(null); return ui?.showToast?.("fix cancelled"); }
+        return; // modal: ignore other keys while the diff is up
+      }
       if (search.isSearchingNow()) {
         if (key.escape) { search.clear(); ui?.setCapturing?.(false); return; }
         if (key.return) { search.confirm(); ui?.setCapturing?.(false); return; }
@@ -265,6 +290,34 @@ export function LocalView({ client, me, dir, ui, width = 78, height = 14, active
 
   if (phase === "error") return h(StateLine, { kind: "error", text: scan.error, hint: "g rescans" });
 
+  // ----- fix preview (modal): the real diff before anything is written -----
+  if (fixPreview) {
+    const { previews, stale, repl, what } = fixPreview;
+    const perChange = 3; // file:line + the - / + pair
+    const maxShow = Math.max(1, Math.floor((height - 3) / perChange));
+    const shown = previews.slice(0, maxShow);
+    const lineW = Math.max(20, width - 4);
+    return h(
+      Box,
+      { flexDirection: "column" },
+      h(Text, {},
+        h(Text, { color: C.ACCENT, bold: true }, ` ${GLYPH.spark} fix preview `),
+        h(Text, { color: C.FG_DIM }, `— ${what} → `),
+        h(Text, { color: "#16a34a", bold: true }, repl),
+        h(Text, { color: C.FG_DIM }, `   (${previews.length} change${previews.length === 1 ? "" : "s"}${stale.length ? ` · ${stale.length} stale skipped` : ""})`),
+      ),
+      h(Text, {}, ""),
+      ...shown.flatMap((p, i) => [
+        h(Text, { key: `f${i}`, color: C.FG_DIM }, ` ${cellE(`${p.file}:${p.line}`, lineW)}`),
+        h(Text, { key: `b${i}`, color: "#f87171" }, cellE(` - ${p.before.trimEnd()}`, lineW)),
+        h(Text, { key: `a${i}`, color: "#4ade80" }, cellE(` + ${p.after.trimEnd()}`, lineW)),
+      ]),
+      previews.length > maxShow ? h(Text, { color: C.FG_DIM }, `  … ${previews.length - maxShow} more change${previews.length - maxShow === 1 ? "" : "s"} (all applied together)`) : null,
+      h(Text, {}, ""),
+      h(Text, { color: C.FG_DIM }, " nothing is written until you press y · esc cancels"),
+    );
+  }
+
   // ----- strip (1 line) -----
   const counters = `${fmtNum(filesScanned)} files · ${fmtNum(dirsSeen)} dirs · ${fmtNum(candidateCount)} refs${catalogsSkipped ? ` · ${catalogsSkipped} catalog${catalogsSkipped === 1 ? "" : "s"} skipped` : ""}`;
   const attention = rows.filter((r) => r.health !== "ok").length;

package/src/tui/views/whatsnew.js

@@ -10,8 +10,11 @@ import {
 } from "../ui.js";
 import { collectFrom } from "../../sources/index.js";
 import { loadConfig, setConfigValue } from "../../config.js";
+import { readFixes } from "../../fix.js";
+import { openLocation } from "../../openUrl.js";
+import path from "node:path";
 
-const TABS = ["Registry", "Alerts", "Drift"];
+const TABS = ["Registry", "Alerts", "Drift", "Fixes"];
 
 // Per-section keybars — the active actions differ by tab (Registry: mark seen ·
 // Notifications: mark read · Drift: rescan + archive). Published via ui.setKeys()
@@ -20,6 +23,7 @@ const TAB_KEYS = [
   [{ k: "←→", label: "section" }, { k: "↑↓", label: "nav" }, { k: "m", label: "mark all seen" }, { k: "g", label: "refresh" }],
   [{ k: "←→", label: "section" }, { k: "↑↓", label: "nav" }, { k: "o", label: "mark read" }, { k: "g", label: "refresh" }],
   [{ k: "←→", label: "section" }, { k: "↑↓", label: "nav" }, { k: "r", label: "rescan" }, { k: "a", label: "archive" }],
+  [{ k: "←→", label: "section" }, { k: "↑↓", label: "nav" }, { k: "o", label: "open in editor" }, { k: "g", label: "refresh" }],
 ];
 
 // The static fallback must match the default (Registry) section exactly —
@@ -43,6 +47,8 @@ export function WhatsNewView({ client, dir, ui, active, width = 78, height = 14
     return { events: ev.data || [], models, provs };
   }, []);
   const notif = useAsync(async () => (await client.listNotifications({})).data || [], []);
+  const [fixes, setFixes] = React.useState(() => readFixes());
+  React.useEffect(() => { if (tab === 3) setFixes(readFixes()); }, [tab]);
   const [drift, setDrift] = React.useState(null);
   // Gate the spinner tick on actual loading — not tab focus — so an idle
   // What's New tab doesn't re-render ~12×/sec forever.
@@ -93,6 +99,7 @@ export function WhatsNewView({ client, dir, ui, active, width = 78, height = 14
       if (input === "g") {
         if (tab === 0) return reg.reload();
         if (tab === 1) return notif.reload();
+        if (tab === 3) return setFixes(readFixes());
         return runDrift();
       }
 
@@ -109,6 +116,12 @@ export function WhatsNewView({ client, dir, ui, active, width = 78, height = 14
             ui.showToast("marked read");
             notif.reload();
           }).catch((e) => ui.showToast(e.message, "red"));
+      } else if (tab === 3) {
+        const cur = fixes[clampCursor(cursor, fixes.length)];
+        if (input === "o" && cur) {
+          openLocation(path.resolve(cur.dir, cur.file), cur.line);
+          ui.showToast(`opened ${cur.file}:${cur.line}`);
+        }
       } else if (tab === 2) {
         if (input === "r") return runDrift();
         const gone = drift?.gone || [];
@@ -131,9 +144,10 @@ export function WhatsNewView({ client, dir, ui, active, width = 78, height = 14
     let context;
     if (tab === 0) context = reg.error ? "offline" : `${reg.data?.events.length || 0} changes`;
     else if (tab === 1) context = notif.error ? "offline" : `${(notif.data || []).length} alerts`;
+    else if (tab === 3) context = `${fixes.length} fix${fixes.length === 1 ? "" : "es"}`;
     else context = drift && !drift.loading && !drift.error ? `+${drift.added.length} / -${drift.gone.length}` : "drift";
     ui?.reportStatus?.({ context });
-  }, [tab, reg.data, reg.error, notif.data, notif.error, drift, ui]);
+  }, [tab, reg.data, reg.error, notif.data, notif.error, drift, fixes, ui]);
 
   let body;
   if (tab === 0) {
@@ -188,6 +202,36 @@ export function WhatsNewView({ client, dir, ui, active, width = 78, height = 14
         }),
       );
     }
+  } else if (tab === 3) {
+    if (!fixes.length) {
+      body = h(Text, { color: C.FG_DIM }, "  No fixes applied yet. Press f on the Here tab (or run mm fix) to rewrite dying model ids.");
+    } else {
+      // Windowed like the Alerts section so ↑↓ reaches every row.
+      const cur = clampCursor(cursor, fixes.length);
+      const start = Math.max(0, Math.min(cur - ROWS + 1, fixes.length - ROWS));
+      const ago = (ts) => {
+        const m = Math.max(0, Math.round((Date.now() - ts) / 60000));
+        if (m < 1) return "now";
+        if (m < 60) return `${m}m ago`;
+        const hr = Math.round(m / 60);
+        if (hr < 24) return `${hr}h ago`;
+        return `${Math.round(hr / 24)}d ago`;
+      };
+      body = h(
+        Box,
+        { flexDirection: "column" },
+        ...fixes.slice(start, start + ROWS).map((f, i) => {
+          const cells = [
+            { text: `${GLYPH.check} `, color: "#16a34a" },
+            { text: cellE(`${path.basename(f.dir)} · ${f.file}:${f.line}`, 38), color: C.FG },
+            { text: " ", color: C.FG },
+            { text: cellE(`${f.from} → ${f.to}`, Math.max(16, width - 58)), color: C.FG_DIM },
+            { text: cellE(ago(f.ts), 8), color: C.FG_FAINT },
+          ];
+          return h(ListRow, { key: `f${start + i}`, active: start + i === cur, cells, width });
+        }),
+      );
+    }
   } else {
     if (!drift) body = h(Text, { color: C.FG_DIM }, `  Press r to scan ${dir} and compare against tracked usages.`);
     else if (drift.loading) body = h(StateLine, { kind: "loading", spin, text: "scanning for drift…" });