@modelstatus/cli 0.1.36 → 0.1.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelstatus/cli",
-  "version": "0.1.36",
+  "version": "0.1.38",
   "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/tui/app.js

@@ -17,6 +17,7 @@ import { AlertsView, meta as alertsMeta } from "./views/alerts.js";
 import { AccountView, meta as accountMeta } from "./views/account.js";
 import { IntegrationsView, meta as integrationsMeta } from "./views/integrations.js";
 import { SignIn } from "./signin.js";
+import { playGameInTui, gameFitsTerminal } from "./game/launch.js";
 
 // `needsAuth: true` views show a sign-in card when there's no apiKey; Local +
 // What's New are public (signed registry over HTTP, no account needed).
@@ -141,6 +142,18 @@ export function App({ apiBase, apiKey, dir, initialView, onSignedIn, fresh }) {
         if (handlesBackRef.current) return undefined;
         return setIdx((i) => (i - 1 + VIEWS.length) % VIEWS.length);
       }
+      // Shift-P: play Donkey Kong from ANY tab, any time. The Scan tab owns its
+      // own P (same launcher) so it isn't double-fired here.
+      if (input === "P" && curKeyRef.current !== "scan") {
+        const w = (stdout && stdout.columns) || outer;
+        const hh = (stdout && stdout.rows) || termRows;
+        if (!gameFitsTerminal(w, hh)) return showToast("terminal too small for the game — resize a bit", "#d97706");
+        playGameInTui({
+          dir, width: w, height: hh, initialView: curKeyRef.current, scanPhase: "play",
+          onError: (e) => showToast(`couldn't start the game: ${e?.message || e}`, "#dc2626"),
+        });
+        return;
+      }
       if (input === "q") return exit();
     },
     { isActive: !prompt && !capturing },
@@ -209,7 +222,7 @@ export function App({ apiBase, apiKey, dir, initialView, onSignedIn, fresh }) {
     h(Text, {}, ""),
     toast ? h(Text, { color: toast.color }, ` ${toast.msg}`) : h(Text, {}, ""),
     h(StatusBar, { segsLeft, segsRight, width: W }),
-    h(KeyBar, { keys, width: W }),
+    h(KeyBar, { keys: keys.some((k) => k.k === "P") ? keys : [...keys, { k: "P", label: "play" }], width: W }),
   );
 }
 

package/src/tui/game/dk-core.js

@@ -57,7 +57,7 @@ export const AIR_MAX = 130;
 export const GRAVITY = 14; // fx/tick added to vy while airborne (full jump → apex ≈ 3 cells)
 export const JUMP_CUT_GRAVITY = 42; // stronger gravity while RISING after release → short hop (~1.5 cells)
 export const TERMINAL_VY = 220; // fx/tick max fall speed
-export const JUMP_VY = -150; // initial up-velocity → apex ≈ 3 cells, hang ≈ 21 ticks
+export const JUMP_VY = -180; // initial up-velocity → apex ≈ 4.5 cells (higher, snappier)
 export const COYOTE_TICKS = 5; // jump still allowed N ticks after walking off
 export const JUMP_BUFFER_TICKS = 6; // a press N ticks before landing still fires on land
 
@@ -157,9 +157,11 @@ function girderIndexAt(platforms, x, y) {
   return -1;
 }
 
-/** The ladder occupying column x within [yTop..yBottom] at row y, or null. */
+/** Ladders are DOUBLE-WIDE: they occupy columns [col, col+1]. The ladder at
+ * column x within [yTop..yBottom] at row y, or null. The 2-col catch makes
+ * mounting forgiving (a single-col ladder was too narrow to latch reliably). */
 function ladderAt(ladders, x, y) {
-  for (const l of ladders) if (l.col === x && y >= l.yTop && y <= l.yBottom) return l;
+  for (const l of ladders) if ((x === l.col || x === l.col + 1) && y >= l.yTop && y <= l.yBottom) return l;
   return null;
 }
 
@@ -184,7 +186,10 @@ export function initGame({
   const { BOARD_W, BOARD_H } = boardSize(width, height);
   if (BOARD_W < MIN_W || BOARD_H < MIN_H) return { tooSmall: true, BOARD_W, BOARD_H };
 
-  const N = Math.max(4, Math.min(5, Math.floor(BOARD_H / 3)));
+  // Fewer girders → bigger vertical gaps → real jump headroom (a jump head-bonks
+  // the girder overhead, so girders ~3 rows apart capped jumps at ~1 cell; ~4+
+  // rows lets the higher JUMP_VY actually read as a tall jump).
+  const N = Math.max(3, Math.min(4, Math.floor(BOARD_H / 4)));
   const gap = Math.floor((BOARD_H - 2) / N);
   const amp = Math.max(0, Math.min(2, Math.floor((gap - 1) / 2)));
   const platforms = [];
@@ -394,12 +399,20 @@ function stepPlaying(s, input, dt) {
   // (and isn't trying to jump). Up only latches if there's run above; down only
   // if there's run below — so standing at an endpoint and pressing "off" doesn't
   // glue you to the ladder.
-  const wantUp = input.up && onLad && row > onLad.yTop;
-  const wantDown = input.down && onLad && row < onLad.yBottom;
+  // Gate on the FIXED-POINT position, not the rounded cell: once the player rounds
+  // into the top cell (cell(py)===yTop) but py hasn't yet reached the exact snap
+  // point toFx(yTop), `cell(py) > yTop` is false — the climb would stall a fraction
+  // below the girder AND the unlatch can't fire while up is held → a deadlock at
+  // the top of every ladder. Comparing px/py in fx lets the climb finish onto the
+  // girder (the step-off below snaps + unlatches). Same fix for descending.
+  const wantUp = input.up && onLad && p.py > toFx(onLad.yTop);
+  const wantDown = input.down && onLad && p.py < toFx(onLad.yBottom);
   if ((wantUp || wantDown) && !input.jump) {
     p.onLadder = true;
     p.vx = 0; p.vy = 0;
-    p.px = toFx(onLad.col); // snap to the ladder column while latched
+    // Snap to whichever of the two rails the player mounted (double-wide ladder).
+    const railCol = cell(p.px) >= onLad.col + 1 ? onLad.col + 1 : onLad.col;
+    p.px = toFx(railCol);
     if (wantUp) p.py = Math.max(toFx(onLad.yTop), p.py - CLIMB_SPEED);
     else p.py = Math.min(toFx(onLad.yBottom), p.py + CLIMB_SPEED);
     // Reached an endpoint EXACTLY → step off onto that girder (off the ladder).
@@ -407,7 +420,7 @@ function stepPlaying(s, input, dt) {
     else if (p.py >= toFx(onLad.yBottom)) { p.onLadder = false; p.onGround = true; p.py = toFx(onLad.yBottom); }
   } else if (p.onLadder) {
     // Left the column, pressed jump, or no climb input → unlatch.
-    const stillOn = onLad && cell(p.px) === onLad.col;
+    const stillOn = onLad && (cell(p.px) === onLad.col || cell(p.px) === onLad.col + 1);
     if (!stillOn || input.jump || !(input.up || input.down)) {
       p.onLadder = false;
       // settle onto a girder if one is at/below this cell; else gravity takes over.

package/src/tui/game/dk-render.js

@@ -62,9 +62,10 @@ function buildGrid(state, glyph) {
   for (const p of platforms) {
     for (let x = 0; x < BOARD_W; x++) put(x, p.slopeOffsets[x], glyph.girder, "girder");
   }
-  // ladders
+  // ladders — DOUBLE-WIDE: draw both rails (col and col+1) to match the 2-col
+  // climb hit-test in dk-core.ladderAt (easier to mount, reads as a real ladder).
   for (const l of ladders) {
-    for (let y = l.yTop; y <= l.yBottom; y++) put(l.col, y, glyph.ladder, "ladder");
+    for (let y = l.yTop; y <= l.yBottom; y++) { put(l.col, y, glyph.ladder, "ladder"); put(l.col + 1, y, glyph.ladder, "ladder"); }
   }
   // goal + actors
   put(princess.x, princess.y, glyph.princess, "princess");

package/src/tui/game/launch.js

@@ -0,0 +1,83 @@
+/* Shared TUI -> game handoff. Used by the global Shift-P shortcut (app.js, any
+ * tab) and the Scan tab. Unmounts Ink (releasing raw mode + stdin), runs the
+ * direct-ANSI game loop (which owns its own raw mode + alt screen), then remounts
+ * the TUI at the requested tab. A TRUE background scan SUBPROCESS feeds the game
+ * HUD and survives the unmount because it's a separate OS process. */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { track } from "../../telemetry.js";
+import { boardSize, MIN_W, MIN_H } from "./dk-core.js";
+
+let launching = false; // module-level re-entrancy guard (one game at a time)
+
+/** Does the board fit this terminal? (mirrors the loop's too-small refusal). */
+export function gameFitsTerminal(width, height) {
+  const { BOARD_W, BOARD_H } = boardSize(width, height);
+  return BOARD_W >= MIN_W && BOARD_H >= MIN_H;
+}
+
+/**
+ * Launch Donkey Kong from inside the running TUI.
+ *   { dir, width, height, initialView, scanPhase, onError }
+ * Returns when the player quits the game and the TUI has been remounted.
+ */
+export async function playGameInTui({ dir, width, height, initialView = "scan", scanPhase = "idle", onError } = {}) {
+  if (launching) return;
+  launching = true;
+  track("game_opened", { game: "donkey_kong", scan_phase: scanPhase });
+  try {
+    const [{ runGame }, { startScanProcess }, { appController }, { writeDiskScan, loadRegistry }] = await Promise.all([
+      import("./loop.js"),
+      import("../../sources/scan-process.js"),
+      import("../app.js"),
+      import("../scan-stream.js"),
+    ]);
+
+    // (1) Start a TRUE background scan SUBPROCESS over `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 view loads 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). Let teardown settle.
+    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 where the player was (so quitting returns you there).
+    appController.remount({ initialView, fresh: false });
+  } catch (e) {
+    if (onError) onError(e); else throw e;
+  } finally {
+    launching = false;
+  }
+}

package/src/tui/views/scan.js

@@ -45,7 +45,8 @@ 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
+    { k: "P", label: "play" }, // launches anytime (also the global Shift-P)
+    { k: "N", label: "new project" },
   ],
 };
 
@@ -79,68 +80,16 @@ export function ScanView({ client, dir, ui, active, width = 78, height = 14, fre
     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;
-    }
+    // either. Production passes nothing → the shared launcher runs.
     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");
+      if (launchGameImpl) { await launchGameImpl({ dir, width, height }); return; }
+      const { playGameInTui } = await import("../game/launch.js");
+      await playGameInTui({
+        dir, width, height, initialView: "scan", scanPhase: scan.phase,
+        onError: (e) => ui?.showToast?.(`couldn't start the game: ${e?.message || e}`, "#dc2626"),
+      });
     } finally {
       launchingRef.current = false;
     }
@@ -322,13 +271,10 @@ 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") {
-        // 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 });
-      }
+      // P always launches Donkey Kong (any time, not just mid-scan) to match the
+      // global Shift-P shortcut. "New project" moved to N.
+      if (input === "P") { launchGame(); return; }
+      if (input === "N") return ui.askPrompt("New project", { onSubmit: createProject });
       if (input === "g") return scan.reload();
       if (input === "u") return upload();
       if (input === "l") {