@modelstatus/cli 0.1.34 → 0.1.36

package/src/tui/views/scan.js

@@ -3,9 +3,23 @@
  * retirement display, and lets you select + upload to your inventory. Server
  * model_ids are resolved only at upload time so uploads stay correct.
  * Scrollable (j/k/↑↓), filterable (/), with a full-width detail panel; ↵ drills
- * into the highlighted model's usage locations and ↵ opens one in your editor. */
+ * into the highlighted model's usage locations and ↵ opens one in your editor.
+ *
+ * BACKGROUND RUNNER: the live view's walk runs on the shared cooperative engine
+ * via useStreamingScan (scan-stream.js) → scanFilesystemStreaming.
+ *
+ * PLAY-WHILE-YOU-WAIT: P launches Donkey Kong via a clean Ink↔game handoff (NOT
+ * an Ink overlay anymore). We (1) start a TRUE background scan SUBPROCESS
+ * (scan-process.js) that survives Ink being unmounted because it's a separate OS
+ * process, (2) UNMOUNT the whole Ink tree (releasing raw mode + stdin), (3) run
+ * the direct-ANSI 60Hz game loop (loop.js — its own raw mode + alt screen +
+ * diff renderer, zero flicker), then (4) on game exit REMOUNT the TUI at the
+ * Scan tab. When the subprocess scan finishes during play we persist its
+ * candidates to the on-disk scan cache, so the remounted Scan view loads the
+ * fresh results on its fast path. Mid-scan only: P opens the game. */
 import React from "react";
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { Box, Text, useInput } from "ink";
 import {
@@ -20,6 +34,7 @@ import { readSnippet } from "../snippet.js";
 import { buildUsages, assignProjects } from "../../upload.js";
 import { track } from "../../telemetry.js";
 import { openUrl, openLocation } from "../../openUrl.js";
+import { boardSize, MIN_W, MIN_H } from "../game/dk-core.js";
 
 export const meta = {
   keys: [
@@ -30,12 +45,13 @@ export const meta = {
     { k: "/", label: "search" },
     { k: "g", label: "rescan" },
     { k: "u", label: "upload all" },
+    { k: "P", label: "play" }, // only meaningful mid-scan; shown when running
   ],
 };
 
 const PANEL_H = 6;
 
-export function ScanView({ client, dir, ui, active, width = 78, height = 14, fresh = false }) {
+export function ScanView({ client, dir, ui, active, width = 78, height = 14, fresh = false, launchGameImpl = null }) {
   // Reuse the SHARED cached scan engine (same module-level cache as the Here
   // tab) instead of re-walking the repo on every visit. Switching to Scan after
   // Here is now instant; `g` forces a fresh walk for both.
@@ -51,6 +67,85 @@ export function ScanView({ client, dir, ui, active, width = 78, height = 14, fre
   const tick = useTick(80, running || busy);
   const search = useSearch();
 
+  // "Play Donkey Kong while you wait." The board fits only if the terminal is
+  // large enough (boardSize ≥ MIN_W×MIN_H), so the affordance is hidden on tiny
+  // terminals and the open is a no-op there. launchingRef guards against a
+  // double-launch (the handoff is async).
+  const { BOARD_W, BOARD_H } = boardSize(width, height);
+  const canPlay = BOARD_W >= MIN_W && BOARD_H >= MIN_H;
+  const launchingRef = React.useRef(false);
+
+  async function launchGame() {
+    if (launchingRef.current) return;
+    if (!canPlay) return ui?.showToast?.("terminal too small for the game — resize a bit", "#d97706");
+    launchingRef.current = true;
+    track("game_opened", { game: "donkey_kong", scan_phase: scan.phase });
+    // Test seam: a caller may inject the launcher so the Ink↔game handoff (which
+    // grabs the real terminal + spawns a subprocess) can be asserted without
+    // either. Production passes nothing → the real handoff below runs.
+    if (launchGameImpl) {
+      try { await launchGameImpl({ dir, width, height }); }
+      finally { launchingRef.current = false; }
+      return;
+    }
+    try {
+      const [{ runGame }, { startScanProcess }, { appController }, { writeDiskScan, loadRegistry }] = await Promise.all([
+        import("../game/loop.js"),
+        import("../../sources/scan-process.js"),
+        import("../app.js"),
+        import("../scan-stream.js"),
+      ]);
+
+      // (1) Start a TRUE background scan SUBPROCESS over the same dir. It survives
+      // the Ink unmount (separate OS process). Pre-fetch + cache the registry so
+      // the worker skips the network; on done, persist candidates to the disk
+      // cache so the remounted Scan view loads the fresh results.
+      let cacheFile = null;
+      try {
+        const snapshot = await loadRegistry().catch(() => null);
+        if (snapshot) {
+          cacheFile = path.join(os.tmpdir(), `mm-reg-game-${process.pid}.json`);
+          fs.writeFileSync(cacheFile, JSON.stringify(snapshot));
+        }
+      } catch { /* worker fetches itself */ }
+
+      let handle = null;
+      try {
+        handle = startScanProcess(
+          { root: dir, registryCachePath: cacheFile || undefined },
+          { onDone: (r) => { try { if (r?.candidates?.length) writeDiskScan(dir, r.candidates); } catch { /* best effort */ } } },
+        );
+      } catch { handle = null; }
+
+      // (2) Unmount the Ink tree (releases raw mode + stdin). Wait a tick so the
+      // teardown fully settles before the game grabs raw mode + alt screen.
+      appController.unmount();
+      await new Promise((r) => setImmediate(r));
+
+      // (3) Run the game. Its loop owns raw mode / alt screen / the diff renderer
+      // and restores the terminal (cooked, main buffer, cursor shown) on exit.
+      try {
+        await runGame({
+          width: process.stdout.columns || width,
+          height: process.stdout.rows || height,
+          level: 1,
+          scanStore: handle,
+        });
+      } finally {
+        try { handle && handle.abort(); } catch { /* ignore */ }
+        try { if (cacheFile) fs.unlinkSync(cacheFile); } catch { /* ignore */ }
+      }
+
+      // (4) Remount the TUI at the Scan tab. fresh:false → the view loads the
+      // (now-updated) disk scan cache on its fast path.
+      appController.remount({ initialView: "scan", fresh: false });
+    } catch (e) {
+      ui?.showToast?.(`couldn't start the game: ${e?.message || e}`, "#dc2626");
+    } finally {
+      launchingRef.current = false;
+    }
+  }
+
   // Upload-target projects (cheap; independent of the scan).
   const projQ = useAsync(() => client.listProjects().then((r) => r.data || []).catch(() => []), []);
   const projects = projQ.data || [];
@@ -123,7 +218,7 @@ export function ScanView({ client, dir, ui, active, width = 78, height = 14, fre
   }, [items, selCount, project, ui]);
 
   // Tell the shell when backspace should back out *within* this view (drilled
-  // into refs, or an active filter) rather than stepping to the previous tab.
+  // into refs or an active filter) rather than stepping to the previous tab.
   const setHandlesBack = ui?.setHandlesBack;
   React.useEffect(() => {
     setHandlesBack?.(focus === "refs" || !!search.query);
@@ -227,7 +322,13 @@ export function ScanView({ client, dir, ui, active, width = 78, height = 14, fre
       if (input === "a") return setItems((its) => its.map((it) => ({ ...it, selected: true })));
       if (input === "x") return setItems((its) => its.map((it) => ({ ...it, selected: false })));
       if (input === "p") return setProjectIdx((i) => (i + 1) % projOptions.length);
-      if (input === "P") return ui.askPrompt("New project", { onSubmit: createProject });
+      if (input === "P") {
+        // Mid-scan, P launches "Play Donkey Kong while you wait" (a clean Ink↔
+        // game handoff); otherwise it keeps its original meaning (create a new
+        // upload-target project).
+        if (running) { launchGame(); return; }
+        return ui.askPrompt("New project", { onSubmit: createProject });
+      }
       if (input === "g") return scan.reload();
       if (input === "u") return upload();
       if (input === "l") {
@@ -239,7 +340,13 @@ export function ScanView({ client, dir, ui, active, width = 78, height = 14, fre
   );
 
   if (scan.phase === "error") return h(StateLine, { kind: "error", text: scan.error });
-  if (running && !items.length) return h(StateLine, { kind: "scanning", spin: SPINNER[tick % SPINNER.length], text: `scanning ${dir}…` });
+  if (running && !items.length)
+    return h(
+      Box,
+      { flexDirection: "column" },
+      h(StateLine, { kind: "scanning", spin: SPINNER[tick % SPINNER.length], text: `scanning ${dir}…` }),
+      canPlay ? h(Text, { color: C.FG_FAINT }, `  ${GLYPH.spark} press P to play Donkey Kong while you wait`) : null,
+    );
   if (!items.length)
     return h(EmptyCard, { icon: GLYPH.spark, title: `No models found in ${path.basename(dir)} — yet`, lines: ["We looked through code, config, and prompt files for model ids.", "Press g to rescan, 1 Here to try another project, or 5 Add to enter one by hand."], width });
 
@@ -264,10 +371,13 @@ export function ScanView({ client, dir, ui, active, width = 78, height = 14, fre
     return h(ListRow, { key: it.key + realIdx, active: isCur, selected: it.selected, cells, width });
   });
 
+  // While the walk is still running (and the terminal fits a board), nudge the
+  // "Play Donkey Kong while you wait" affordance on the showing line.
+  const playHint = running && canPlay ? " · P play" : "";
   const showingLine = h(
     Text,
     { color: C.FG_FAINT },
-    `  ${fmtNum(filtered.length)} ref${filtered.length === 1 ? "" : "s"}${filtered.length > pageSize ? ` · ${nav.start + 1}-${Math.min(nav.end, filtered.length)}` : ""}${search.query ? ` · filter "${search.query}"` : ""}${scan.fromCache ? " · cached" : ""} · ${selCount === items.length ? `all ${selCount}` : `${selCount}/${items.length}`} selected · u uploads them all`,
+    `  ${fmtNum(filtered.length)} ref${filtered.length === 1 ? "" : "s"}${filtered.length > pageSize ? ` · ${nav.start + 1}-${Math.min(nav.end, filtered.length)}` : ""}${search.query ? ` · filter "${search.query}"` : ""}${scan.fromCache ? " · cached" : ""} · ${selCount === items.length ? `all ${selCount}` : `${selCount}/${items.length}`} selected · u uploads them all${playHint}`,
   );
   const footer = busy
     ? h(Text, { color: C.ACCENT }, ` ${SPINNER[tick % SPINNER.length]} uploading…`)