@modelstatus/cli 0.1.61 → 0.1.63

package/package.json

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

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/scan-stream.js

@@ -230,5 +230,22 @@ export function useStreamingScan(dir, opts = {}) {
   }, [dir, nonce]);
 
   const reload = React.useCallback(() => { SCAN_CACHE.delete(dir); setNonce((n) => n + 1); }, [dir]);
-  return { ...state, paused, reload, togglePause };
+
+  /** Surgically transform the in-memory candidates (e.g. after `f` fix rewrites
+   * a model id on disk) and re-summarize — NO filesystem walk. Keeps the
+   * session + disk caches in sync so the edit survives tab switches/restarts.
+   * A full `reload()` stays the way to re-verify against the real tree. */
+  const applyEdit = React.useCallback((updater) => {
+    setState((s) => {
+      if (!s.snapshot) return s;
+      const next = updater(s.candidates || []);
+      const sum = summarize(s.snapshot, next);
+      const prev = SCAN_CACHE.get(dir) || {};
+      SCAN_CACHE.set(dir, { ...prev, snapshot: s.snapshot, candidates: next, scannedAt: s.scannedAt || Date.now(), fromCache: s.fromCache });
+      try { writeDiskScan(dir, next); } catch { /* best effort */ }
+      return { ...s, candidates: next, candidateCount: next.length, ...sum };
+    });
+  }, [dir]);
+
+  return { ...state, paused, reload, togglePause, applyEdit };
 }

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
@@ -27,7 +28,7 @@ export const meta = {
   keys: [
     { k: "↑↓", label: "nav" },
     { k: "↵", label: "refs" },
-    { k: "f", label: "fix → repl" },
+    { k: "f", label: "fix all" },
     { k: "u", label: "push → Inv" },
     { k: "g", label: "rescan" },
     { k: "/", label: "search" },
@@ -83,22 +84,41 @@ export function LocalView({ client, me, dir, ui, width = 78, height = 14, active
   /** 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 }) => {
+    if (!cur.model.replacement_slug) return ui?.showToast?.("no replacement in the registry yet", "#d97706");
+    import("../../fix.js").then(({ planFixes, applyFixes, styleReplacement, terminalReplacement, recordFixes }) => {
+      // 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);
+          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?!").
+            // 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` : ""}`);
-            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");
           }

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…" });