@modelstatus/cli 0.1.63 → 0.1.64

package/package.json

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

@@ -124,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/tui/views/local.js

@@ -81,13 +81,15 @@ 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) {
     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 (!cur.model.replacement_slug) return ui?.showToast?.("no replacement in the registry yet", "#d97706");
-    import("../../fix.js").then(({ planFixes, applyFixes, styleReplacement, terminalReplacement, recordFixes }) => {
+    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 || [];
@@ -100,30 +102,35 @@ export function LocalView({ client, me, dir, ui, width = 78, height = 14, active
       );
       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` : ""}`);
-          } 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");
+      }
     });
   }
 
@@ -216,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; }
@@ -276,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;