modelstat 0.0.25 → 0.0.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modelstat",
-  "version": "0.0.25",
+  "version": "0.0.26",
   "description": "modelstat companion — reads local AI-tool usage and ships tokenised events to modelstat.",
   "license": "Apache-2.0",
   "type": "module",
@@ -10,6 +10,7 @@
   },
   "files": [
     "dist",
+    "scripts/postinstall.mjs",
     "vendor/tray-mac",
     "README.md",
     "LICENSE"
@@ -24,12 +25,14 @@
     "prepack": "pnpm run build && pnpm run build:tray",
     "pack:tarball": "pnpm run build && npm pack --pack-destination ../..",
     "install:local": "bash ./scripts/install-local.sh",
+    "postinstall": "node ./scripts/postinstall.mjs",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
     "chokidar": "^4.0.3",
     "conf": "^13.1.0",
     "dotenv": "^16.4.7",
+    "node-llama-cpp": "^3.18.0",
     "ulid": "^2.3.0",
     "undici": "^7.1.0"
   },

package/scripts/postinstall.mjs

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+/**
+ * Post-install hook for the @modelstat/agent CLI.
+ *
+ * Runs after `npm install -g modelstat` (or `npx modelstat` cache
+ * population) and downloads the bundled summariser GGUF (~2.7 GB)
+ * with visible progress, so the user sees the heavy download
+ * attached to the install they just kicked off — not as a surprise
+ * 7-minute hang the first time they run `modelstat scan`.
+ *
+ * Skipped when:
+ *   - Running inside this repo's pnpm workspace (we don't want every
+ *     dev `pnpm install` to pull 2.7 GB; the developer can opt in by
+ *     running `modelstat connect` once or pre-pulling the model).
+ *   - `MODELSTAT_SKIP_POSTINSTALL=1` is set (CI escape hatch, or for
+ *     packagers who handle the model out-of-band).
+ *   - `CI=true` is set (most CI providers; avoids blocking automated
+ *     installs on a multi-GB pull).
+ *   - stdout isn't a TTY AND CI isn't set (likely a scripted
+ *     install that doesn't want long-running side-effects).
+ *
+ * In all skip cases the model still downloads lazily on first
+ * `modelstat scan` — the agent always preflights the summariser
+ * before producing any segments (see src/pipeline.ts), so users in
+ * skip-mode just see the download then, instead of now.
+ */
+
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+function inThisMonorepo() {
+  // Walk up from this script looking for the repo's pnpm-workspace.yaml.
+  // When npm installs us into a global node_modules, this file isn't an
+  // ancestor — so we know we're in a real install and should download.
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 10; i++) {
+    if (existsSync(join(dir, "pnpm-workspace.yaml"))) return true;
+    const up = resolve(dir, "..");
+    if (up === dir) return false;
+    dir = up;
+  }
+  return false;
+}
+
+async function main() {
+  if (process.env.MODELSTAT_SKIP_POSTINSTALL === "1") {
+    console.log(
+      "[modelstat] postinstall skipped (MODELSTAT_SKIP_POSTINSTALL=1) — model downloads lazily on first scan",
+    );
+    return;
+  }
+  if (process.env.CI === "true" || process.env.CI === "1") {
+    console.log(
+      "[modelstat] postinstall skipped (CI=1) — model downloads lazily on first scan",
+    );
+    return;
+  }
+  if (inThisMonorepo()) {
+    // Dev environment — don't pull 2.7 GB on every workspace install.
+    return;
+  }
+  if (!process.stdout.isTTY) {
+    console.log(
+      "[modelstat] postinstall: non-TTY — model will download lazily on first `modelstat scan`",
+    );
+    return;
+  }
+
+  // Resolve the helper from the workspace package the bundle uses.
+  // companion-core is bundled into dist/cli.mjs by tsup, but we need
+  // the helper as a standalone import here (postinstall runs against
+  // the unbundled source layout).
+  let ensureLlamaModel;
+  let defaultLlamaConfig;
+  try {
+    ({ ensureLlamaModel, defaultLlamaConfig } = await import(
+      "@modelstat/companion-core/node"
+    ));
+  } catch (err) {
+    console.warn(
+      `[modelstat] postinstall: couldn't import summariser helper (${err && err.message ? err.message : err}); model will download lazily on first scan`,
+    );
+    return;
+  }
+
+  console.log("");
+  console.log("━".repeat(60));
+  console.log("  Pre-downloading the local summariser model");
+  console.log("");
+  console.log("  modelstat ships with a small LLM that runs ON YOUR MACHINE");
+  console.log("  to summarise every coding session. The model is ~2.7 GB —");
+  console.log("  pulling it now so the first `modelstat scan` is instant.");
+  console.log("━".repeat(60));
+  console.log("");
+
+  try {
+    await ensureLlamaModel(defaultLlamaConfig());
+    console.log("");
+    console.log("[modelstat] ✓ summariser ready — run `modelstat connect` next");
+  } catch (err) {
+    // Don't fail the npm install. The model will retry-download on
+    // first scan; better to leave the user with a working binary
+    // than to abort because their network blipped.
+    console.warn(
+      `[modelstat] ⚠ couldn't pre-download summariser (${err && err.message ? err.message : err})`,
+    );
+    console.warn(
+      "[modelstat]   the model will download lazily on first `modelstat scan` instead",
+    );
+  }
+}
+
+main().catch((err) => {
+  console.warn(
+    `[modelstat] postinstall failed: ${err && err.message ? err.message : err}`,
+  );
+  // Never fail the install for a postinstall problem.
+  process.exit(0);
+});

package/vendor/tray-mac/Sources/ModelstatTray/main.swift

@@ -149,12 +149,17 @@ final class TrayController: NSObject {
       return
     }
     let p = Process()
+    // --force: the tray owns the daemon. If a stale lock from a prior
+    // run (crash, kill -9, OS reboot mid-write) is left behind, the
+    // unforced `start` exits in <1s with "already running" and the
+    // tray's terminationHandler retries it forever. With --force we
+    // claim the lock unconditionally and become the live daemon.
     if cli.pathExtension == "mjs" {
       p.launchPath = "/usr/bin/env"
-      p.arguments = ["node", cli.path, "start"]
+      p.arguments = ["node", cli.path, "start", "--force"]
     } else {
       p.launchPath = cli.path
-      p.arguments = ["start"]
+      p.arguments = ["start", "--force"]
     }
     // Bolt stdout/stderr onto the same log the launchd plist uses so
     // `modelstat status` still sees the same tail.
@@ -208,6 +213,10 @@ final class TrayController: NSObject {
     do {
       try p.run()
     } catch {
+      // Surface the failure in the menu instead of leaving the title
+      // stuck on whatever it was last (e.g. "Starting…" forever). Most
+      // likely cause is `node` not being on the launchd-inherited PATH.
+      statusMI.title = "stats failed: \(error.localizedDescription)"
       return
     }
     // Run on a background queue so we don't block the main loop.
@@ -336,11 +345,23 @@ final class TrayController: NSObject {
 // TrayController is @MainActor, so its init must run on the main
 // actor. We wrap the bootstrap in a main-actor function to satisfy
 // Swift 6's strict concurrency without bloating the controller.
+//
+// IMPORTANT: nothing in AppKit retains TrayController for us. The
+// NSStatusItem holds the menu, and NSMenuItem.target is a weak
+// reference, so the controller has no strong owners. Without a
+// global anchor, ARC deallocates the controller as soon as init
+// returns — which leaves the timer's `[weak self]` callback firing
+// against nil and the menu title frozen on "Starting…" forever.
+// The `controller` global below is the strong reference that keeps
+// the controller alive for the entire app lifetime.
+@MainActor
+private var controller: TrayController?
+
 @MainActor
 func bootstrap() {
   let app = NSApplication.shared
   app.setActivationPolicy(.accessory)
-  _ = TrayController()
+  controller = TrayController()
   app.run()
 }