lumira 1.8.1 → 1.9.0

package/.claude-plugin/marketplace.json

@@ -0,0 +1,37 @@
+{
+  "name": "lumira",
+  "owner": {
+    "name": "Carlos Cativo"
+  },
+  "metadata": {
+    "description": "Real-time statusline HUD for Claude Code and Qwen Code — analytics, quota projection, themes, powerline",
+    "version": "1.9.0",
+    "homepage": "https://github.com/cativo23/lumira"
+  },
+  "plugins": [
+    {
+      "name": "lumira",
+      "source": "./",
+      "description": "Real-time statusline HUD for Claude Code and Qwen Code. Session analytics, API latency widget, 7-day quota projection, auto-compact warnings, 7 themes, powerline support. Zero runtime dependencies. Run /lumira:setup after install to activate.",
+      "version": "1.9.0",
+      "author": {
+        "name": "Carlos Cativo"
+      },
+      "homepage": "https://github.com/cativo23/lumira#readme",
+      "repository": "https://github.com/cativo23/lumira",
+      "license": "MIT",
+      "keywords": [
+        "statusline",
+        "hud",
+        "claude-code",
+        "qwen-code",
+        "analytics",
+        "metrics",
+        "terminal",
+        "powerline",
+        "themes"
+      ]
+    }
+  ],
+  "version": "1.9.0"
+}

package/.claude-plugin/plugin.json

@@ -0,0 +1,25 @@
+{
+  "name": "lumira",
+  "version": "1.9.0",
+  "description": "Real-time statusline HUD for Claude Code and Qwen Code — session analytics, API latency, 7-day quota projection, auto-compact warnings, 7 themes, powerline. Zero runtime deps.",
+  "author": {
+    "name": "Carlos Cativo"
+  },
+  "repository": "https://github.com/cativo23/lumira",
+  "homepage": "https://github.com/cativo23/lumira#readme",
+  "license": "MIT",
+  "keywords": [
+    "claude-code",
+    "qwen-code",
+    "statusline",
+    "hud",
+    "terminal",
+    "analytics",
+    "session",
+    "metrics",
+    "nerd-font",
+    "powerline",
+    "themes"
+  ],
+  "skills": "./skills/"
+}

package/README.md

@@ -26,7 +26,7 @@ Interactive wizard — preset, theme, icons — previewed live before write.
 
 > 3,400+ monthly downloads, zero marketing. Try it for one session — `npx lumira install`.
 
-> **What's new in v1.8.1:** the GSD widget now mirrors get-shit-done (GSD)'s own statusline — phase/milestone lifecycle, a milestone progress bar, and `⬆ /gsd:update` / `⚠ stale hooks` indicators that show in any project. GSD support is on by default and self-gates (no GSD project → nothing renders). Earlier releases added the compaction counter `⊙ N` (v1.8.0), added-dirs badge + worktree breadcrumb (v1.7.0), [`lumira stats` CLI](#stats-cli) (v1.5), `API N%` latency widget (v1.4.0), 7-day quota projection (v1.3.0), and the auto-compact proximity glyph ⚠ (v1.4.1).
+> **What's new in v1.8.2:** the installer now writes a fast per-render command — it runs the compiled `lumira` binary directly (~10× faster than `npx lumira@latest`, which hit the npm registry on every render) and migrates existing setups automatically. v1.8.1 brought the GSD widget to parity with get-shit-done (GSD)'s own statusline — phase/milestone lifecycle, a milestone progress bar, and `⬆ /gsd:update` / `⚠ stale hooks` indicators that show in any project (on by default, self-gating). Earlier releases added the compaction counter `⊙ N` (v1.8.0), added-dirs badge + worktree breadcrumb (v1.7.0), [`lumira stats` CLI](#stats-cli) (v1.5), `API N%` latency widget (v1.4.0), 7-day quota projection (v1.3.0), and the auto-compact proximity glyph ⚠ (v1.4.1).
 
 ## Table of contents
 
@@ -103,6 +103,8 @@ npx lumira install
 
 The installer walks you through three choices — **preset** (`full` / `balanced` / `minimal`), **theme**, and **icons** — showing a live preview at each step. Press `Esc` to abort without writing anything. In non-interactive shells (piped stdin, CI), the installer skips the wizard and writes sensible defaults (`preset: balanced`, `icons: nerd`). If Qwen Code is detected (`~/.qwen/` exists), the `/lumira` skill is installed for both CLIs.
 
+For the fastest statusline (the command runs on **every** render), the installer offers to install lumira globally so it can invoke the compiled binary directly (`lumira`, ~60ms) instead of `npx` (which is ~10× slower). It also migrates older `npx lumira@latest` setups to the faster form automatically.
+
 Or install globally:
 
 ```bash
@@ -120,19 +122,19 @@ Your preferences are saved to `~/.config/lumira/config.json` — hand-edited key
 
 ### Manual setup
 
-Add to `~/.claude/settings.json`:
+The `statusLine.command` runs on every render, so prefer the **direct binary**. Install globally (`npm install -g lumira`), then add to `~/.claude/settings.json`:
 
 ```json
 {
   "statusLine": {
     "type": "command",
-    "command": "npx lumira@latest",
+    "command": "lumira",
     "padding": 0
   }
 }
 ```
 
-If installed from source:
+If installed from source, point at the compiled entry:
 
 ```json
 {
@@ -144,6 +146,8 @@ If installed from source:
 }
 ```
 
+> Without a global install you can use `"command": "npx lumira"` — it works, but resolves through npx on every render (~10× slower). Avoid `npx lumira@latest`: the `@latest` hits the npm registry on every render.
+
 ## Display
 
 ### Custom Mode (default, >=70 columns)

package/dist/installer.js

@@ -1,6 +1,7 @@
 import { readFileSync, existsSync, copyFileSync, unlinkSync, mkdirSync, rmdirSync, renameSync, openSync, writeSync, fsyncSync, closeSync } from 'node:fs';
 import { join, dirname, resolve } from 'node:path';
 import { homedir } from 'node:os';
+import { execFileSync } from 'node:child_process';
 import { sanitizeTermString } from './normalize.js';
 import { fileURLToPath } from 'node:url';
 import { createInterface } from 'node:readline';
@@ -17,11 +18,67 @@ const ok = (msg) => `${GREEN}✓${RST} ${msg}`;
 const warn = (msg) => `${YELLOW}⚠${RST} ${msg}`;
 const header = () => `\n${CYAN} lumira installer${RST}\n`;
 // ── StatusLine value ────────────────────────────────────────────────
-const LUMIRA_STATUSLINE = {
-    type: 'command',
-    command: 'npx lumira@latest',
-    padding: 0,
-};
+// The per-render command. `lumira` (a real global bin) runs the compiled
+// binary directly (~60ms). `npx lumira` resolves from cache (~150-300ms).
+// `npx lumira@latest` hits the npm registry EVERY render (~600ms) — never
+// write that form; it's the perf bug this installer migrates away from.
+function makeStatusLine(command) {
+    return { type: 'command', command, padding: 0 };
+}
+// Rank a statusLine command by per-render speed (higher = faster).
+//   2 = direct binary  (`lumira`, `node …/dist/index.js`, ${CLAUDE_PLUGIN_ROOT})
+//   1 = npx, cached    (`npx lumira`)
+//   0 = npx, registry  (`npx lumira@latest` / any pinned `@version`)
+// Used to decide migration: only ever rewrite TOWARD a faster form.
+export function commandSpeed(command) {
+    const c = command.trim();
+    // `npx` as a bare word or a path basename (e.g. /usr/local/bin/npx, …\npx).
+    if (/(^|[\s/\\])npx(\s|$)/.test(c)) {
+        return /@(latest|\d)/.test(c) ? 0 : 1;
+    }
+    return 2;
+}
+// Is `lumira` resolvable as a global bin on PATH?
+function defaultHasGlobalBin() {
+    const probe = process.platform === 'win32' ? 'where' : 'which';
+    try {
+        execFileSync(probe, ['lumira'], { stdio: 'ignore', timeout: 3000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// Install lumira globally so the per-render command can invoke it directly.
+function defaultInstallGlobal() {
+    try {
+        execFileSync('npm', ['install', '-g', 'lumira'], { stdio: 'inherit', timeout: 120000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// Resolve the fastest statusLine command available in this environment.
+// In a TTY with no global bin, offer to `npm i -g lumira` (confirmed) so the
+// command can be the direct `lumira`; otherwise fall back to cached `npx lumira`.
+async function resolveStatusLineCommand(ctx) {
+    if (ctx.hasGlobalBin())
+        return 'lumira';
+    if (ctx.isTTY) {
+        const accepted = await ctx.confirm('Install lumira globally for ~10× faster rendering (npm i -g lumira)?');
+        if (accepted) {
+            if (ctx.installGlobal()) {
+                ctx.lines.push(ok('Installed lumira globally — statusline runs the compiled binary directly'));
+                return 'lumira';
+            }
+            ctx.lines.push(warn('Global install failed — using npx for now (run npm i -g lumira later for full speed)'));
+            return 'npx lumira';
+        }
+        ctx.lines.push(`  ${DIM}Tip: npm i -g lumira for ~10× faster rendering${RST}`);
+    }
+    return 'npx lumira';
+}
 function defaultSettingsPath() {
     return join(homedir(), '.claude', 'settings.json');
 }
@@ -95,6 +152,8 @@ export async function install(opts = {}) {
     const confirm = opts.confirm ?? promptYN;
     const stdin = opts.stdin ?? process.stdin;
     const stdout = opts.stdout ?? process.stdout;
+    const hasGlobalBin = opts.hasGlobalBin ?? defaultHasGlobalBin;
+    const installGlobal = opts.installGlobal ?? defaultInstallGlobal;
     const lines = [];
     // Build banner prelude (shown on each wizard frame so it survives screen clears)
     let prelude = '';
@@ -159,20 +218,41 @@ export async function install(opts = {}) {
         wizard = { preset: 'balanced', icons: 'nerd' };
         lines.push(ok('Non-interactive mode — using defaults (preset: balanced, icons: nerd)'));
     }
-    // ── settings.json replace/backup ───────────────────────────────
-    if (settings.statusLine) {
-        if (isLumira(settings.statusLine)) {
-            lines.push(ok('lumira is already configured as your statusline'));
-            saveConfig(wizard, configPath);
-            lines.push(ok(`Saved config → ${DIM}${configPath}${RST}`));
-            emitFooter(lines, opts.homeOverride);
-            return lines.join('\n') + '\n';
+    // Save config + emit footer + render output. Shared by every exit below.
+    const finalize = () => {
+        saveConfig(wizard, configPath);
+        lines.push(ok(`Saved config → ${DIM}${configPath}${RST}`));
+        emitFooter(lines, opts.homeOverride);
+        return lines.join('\n') + '\n';
+    };
+    // ── settings.json replace / backup / migrate ───────────────────
+    const existingIsLumira = !!settings.statusLine && isLumira(settings.statusLine);
+    const existingCmd = existingIsLumira
+        ? String(settings.statusLine.command ?? '')
+        : '';
+    // Already on the fastest form (direct binary) — nothing to rewrite.
+    if (existingIsLumira && commandSpeed(existingCmd) >= 2) {
+        lines.push(ok('lumira is already configured (optimal command)'));
+        return finalize();
+    }
+    // Resolve the fastest per-render command this environment can offer.
+    const resolvedCmd = await resolveStatusLineCommand({
+        isTTY: !!stdin?.isTTY, confirm, hasGlobalBin, installGlobal, lines,
+    });
+    if (existingIsLumira) {
+        // Existing lumira command (npx form) — only rewrite if strictly faster,
+        // so we never downgrade a user's direct binary to npx.
+        if (commandSpeed(resolvedCmd) <= commandSpeed(existingCmd)) {
+            lines.push(ok('lumira is already configured'));
+            return finalize();
         }
+    }
+    else if (settings.statusLine) {
         // Foreign statusLine already confirmed above — back it up and replace.
         copyFileSync(settingsPath, backupPath);
         lines.push(ok(`Backed up existing settings → ${DIM}settings.json.lumira.bak${RST}`));
     }
-    settings.statusLine = { ...LUMIRA_STATUSLINE };
+    settings.statusLine = makeStatusLine(resolvedCmd);
     mkdirSync(dirname(settingsPath), { recursive: true });
     const tmp = `${settingsPath}.${process.pid}.${Date.now()}.lumira.tmp`;
     try {
@@ -189,11 +269,10 @@ export async function install(opts = {}) {
         catch { }
         throw e;
     }
-    lines.push(ok('Configured lumira as statusline'));
-    saveConfig(wizard, configPath);
-    lines.push(ok(`Saved config → ${DIM}${configPath}${RST}`));
-    emitFooter(lines, opts.homeOverride);
-    return lines.join('\n') + '\n';
+    lines.push(ok(existingIsLumira
+        ? `Upgraded statusline command → ${DIM}${resolvedCmd}${RST} (faster)`
+        : 'Configured lumira as statusline'));
+    return finalize();
 }
 // ── Uninstall ───────────────────────────────────────────────────────
 export function uninstall(opts = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lumira",
-  "version": "1.8.1",
+  "version": "1.9.0",
   "description": "Real-time statusline HUD for Claude Code and Qwen Code. Includes session analytics CLI, API latency overhead widget, 7d quota projection, auto-compact proximity warnings, themes, and powerline. Zero deps.",
   "type": "module",
   "main": "dist/index.js",
@@ -15,6 +15,7 @@
     "test:coverage": "vitest run --coverage",
     "lint": "tsc --noEmit",
     "themes:validate": "npm run build && node scripts/validate-themes.mjs",
+    "version": "node scripts/bump-plugin-version.mjs",
     "prepublishOnly": "npm run build && npm run lint && node scripts/validate-themes.mjs && npm run test"
   },
   "devDependencies": {
@@ -50,6 +51,7 @@
   "files": [
     "dist",
     "skills",
+    ".claude-plugin",
     "!dist/**/*.map",
     "!dist/**/*.d.ts"
   ]

package/skills/setup/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: setup
+description: Use after installing the lumira plugin to activate the statusline. Writes statusLine.command to ~/.claude/settings.json pointing to the plugin-cached binary. Run this once after /plugin marketplace add cativo23/lumira.
+allowed-tools: Bash, Read, Write
+license: MIT
+---
+
+# /lumira:setup — Activate lumira statusline
+
+You activate the **lumira** statusline for Claude Code after plugin installation.
+
+## Workflow
+
+1. **Find install path** — Read `~/.claude/plugins/installed_plugins.json`. Look for any key matching `lumira@*` (the exact marketplace key depends on how the user installed it). Extract `installPath` from the first match.
+2. **Verify binary** — Check that `<installPath>/dist/index.js` exists.
+3. **Read settings** — Read `~/.claude/settings.json`. If the file is **missing**, start from `{}`. If it is **present but invalid JSON**, stop and report the parse error — do not overwrite.
+4. **Check existing** — If `statusLine.command` is already set to any non-empty value, tell the user what's currently set and ask if they want to replace it. Do not proceed until they confirm. If it is empty or absent, skip this step.
+5. **Write command** — Set `statusLine.command` to `node "<installPath>/dist/index.js"`.
+6. **Init config** — If `~/.config/lumira/config.json` does not exist, create it with `{"preset": "balanced"}`. Never overwrite an existing config.
+7. **Confirm and instruct** — Tell the user what was written and that they must restart Claude Code.
+
+## Finding the install path
+
+```bash
+cat ~/.claude/plugins/installed_plugins.json
+```
+
+Parse the JSON and find the entry whose key starts with `lumira@`. The `installPath` field is the absolute path to the cached plugin directory.
+
+If multiple entries match (unlikely), use the one with the most recent `lastUpdated`.
+
+## settings.json merge rules
+
+- Always read the full file first, then patch only `statusLine.command`.
+- Write back the complete merged object — never truncate other fields.
+- If the file is missing, create it with just `{"statusLine": {"command": "<node command>"}}`.
+- If the file is not valid JSON, report the parse error and stop. Do not overwrite.
+
+## Success output
+
+After writing, tell the user:
+- The exact command written
+- That they need to **restart Claude Code** for the statusline to appear
+- "Run /lumira:lumira to customize preset, theme, or display widgets"
+
+## Error cases
+
+- No `lumira@*` key in installed_plugins.json → "Lumira doesn't appear to be installed as a plugin. Run: `/plugin marketplace add cativo23/lumira` then try again."
+- `dist/index.js` missing at install path → "Plugin installed but dist/ is missing. Reinstall: uninstall lumira then `/plugin marketplace add cativo23/lumira`."
+- settings.json parse error → show the exact error, stop, do not write.
+
+## Language
+
+Respond in the user's language. Spanish input → Rioplatense Spanish (voseo: "vos tenés", "reiniciá", "fijate").