lumira 1.8.0 → 1.8.2

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.0:** compaction counter (`⊙ N` on line 2) — tracks how many times the session has been compacted, pairing with the auto-compact proximity glyph ⚠. Togglable via `display.compactionCount`, on by default in `full`/`balanced`. Combined with the added-dirs badge and worktree breadcrumb (v1.7.0), [`lumira stats` CLI](#stats-cli) (v1.5), `API N%` latency widget (v1.4.0), 7-day quota projection warning (v1.3.0), and auto-compact proximity glyph ⚠ (v1.4.1), recent releases add several diagnostic signals to the session.
+> **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/dist/parsers/gsd.js

@@ -14,13 +14,15 @@ export function parseStateMd(content) {
     const state = {};
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
     if (fmMatch) {
-        for (const line of fmMatch[1].split('\n')) {
+        const fmText = fmMatch[1];
+        // Parse simple scalar fields
+        for (const line of fmText.split('\n')) {
             const m = line.match(/^(\w+):\s*(.+)/);
             if (!m)
                 continue;
             const [, key, val] = m;
             const v = val.trim().replace(/^(["'])(.*)\1$/, '$2');
-            if (v === 'null')
+            if (v === 'null' || v === '')
                 continue;
             if (key === 'status')
                 state.status = v;
@@ -28,6 +30,51 @@ export function parseStateMd(content) {
                 state.milestone = v;
             else if (key === 'milestone_name')
                 state.milestoneName = v;
+            else if (key === 'active_phase')
+                state.activePhase = v;
+            else if (key === 'next_action')
+                state.nextAction = v;
+        }
+        // Parse next_phases: flow form [a, b]
+        const flowMatch = fmText.match(/^next_phases:\s*\[([^\]]*)\]/m);
+        if (flowMatch && flowMatch[1]) {
+            const items = flowMatch[1].split(',').map(s => {
+                const trimmed = s.trim().replace(/^(["'])(.*)\1$/, '$2');
+                return trimmed;
+            }).filter(s => s.length > 0);
+            if (items.length > 0)
+                state.nextPhases = items;
+        }
+        // Parse next_phases: block-list form
+        if (!state.nextPhases) {
+            const blockMatch = fmText.match(/^next_phases:\s*\n((?:[ \t]*-[ \t]*[^\n]+\n?)*)/m);
+            if (blockMatch && blockMatch[1]) {
+                const items = [];
+                for (const itemLine of blockMatch[1].split('\n')) {
+                    const itemM = itemLine.match(/^[ \t]*-[ \t]*(.+)/);
+                    if (itemM) {
+                        const itemVal = itemM[1].trim().replace(/^(["'])(.*)\1$/, '$2');
+                        if (itemVal)
+                            items.push(itemVal);
+                    }
+                }
+                if (items.length > 0)
+                    state.nextPhases = items;
+            }
+        }
+        // Parse progress block
+        const progressMatch = fmText.match(/^progress:\s*\n((?:[ \t]+\w+:.+\n?)+)/m);
+        if (progressMatch && progressMatch[1]) {
+            const progressText = progressMatch[1];
+            const completedM = progressText.match(/completed_phases:\s*(\d+)/);
+            if (completedM)
+                state.completedPhases = completedM[1];
+            const totalM = progressText.match(/total_phases:\s*(\d+)/);
+            if (totalM)
+                state.totalPhases = totalM[1];
+            const percentM = progressText.match(/percent:\s*(\d+)/);
+            if (percentM)
+                state.percent = percentM[1];
         }
     }
     const phaseMatch = content.match(/^Phase:\s*(\d+)\s+of\s+(\d+)(?:\s+\(([^)]+)\))?/m);
@@ -51,6 +98,24 @@ export function parseStateMd(content) {
     }
     return state;
 }
+/**
+ * Render a 10-segment progress bar: `█████░░░░░ 50%`.
+ *
+ * INTENTIONAL deviation from GSD's own statusline (gsd-statusline.js wraps the
+ * bar in brackets — `[█████░░░░░] 50%`). lumira drops the brackets so the
+ * milestone bar reads as distinct from the line-2 context bar. Do NOT re-add
+ * brackets when re-syncing GSD's format — this is a deliberate design choice.
+ */
+function renderProgressBar(percent) {
+    if (percent === undefined || percent === null)
+        return '';
+    const pct = Math.max(0, Math.min(100, parseInt(String(percent), 10)));
+    if (isNaN(pct))
+        return '';
+    const filled = Math.floor(pct / 10);
+    const bar = '█'.repeat(filled) + '░'.repeat(10 - filled);
+    return `${bar} ${pct}%`;
+}
 /** Walk up from `cwd` looking for `.planning/STATE.md`; stop at home or filesystem root. */
 export function findStateMd(cwd) {
     const home = homedir();
@@ -69,27 +134,64 @@ export function findStateMd(cwd) {
 /** Format a GSD state into a compact status string: `milestone · status · phase`. */
 function formatState(s) {
     const parts = [];
+    // Milestone segment with optional progress bar
     if (s.milestone || s.milestoneName) {
         const ver = s.milestone ?? '';
         const name = s.milestoneName && s.milestoneName !== 'milestone' ? s.milestoneName : '';
-        const ms = [ver, name].filter(Boolean).join(' ');
-        if (ms)
-            parts.push(ms);
+        const bar = renderProgressBar(s.percent);
+        const msParts = [ver, name, bar].filter(Boolean);
+        if (msParts.length > 0)
+            parts.push(msParts.join(' '));
+    }
+    // Scene selection: activePhase → nextAction → milestone-complete → default
+    const phasesStr = s.nextPhases?.length ? s.nextPhases.join('/') : null;
+    if (s.activePhase) {
+        // Scene 1: activePhase (with optional status)
+        parts.push(s.status ? `Phase ${s.activePhase} ${s.status}` : `Phase ${s.activePhase}`);
     }
-    if (s.status)
-        parts.push(s.status);
-    if (s.phaseNum && s.phaseTotal) {
-        const phase = s.phaseName ? `${s.phaseName} (${s.phaseNum}/${s.phaseTotal})` : `ph ${s.phaseNum}/${s.phaseTotal}`;
-        parts.push(phase);
+    else if (s.nextAction && phasesStr) {
+        // Scene 2: nextAction + phases when idle
+        parts.push(`next ${s.nextAction} ${phasesStr}`);
+    }
+    else if (Number(s.percent) === 100 || (s.completedPhases && s.totalPhases && s.completedPhases === s.totalPhases)) {
+        // Scene 3: milestone complete
+        parts.push('milestone complete');
+    }
+    else {
+        // Scene 4 (default): preserve existing behavior
+        if (s.status)
+            parts.push(s.status);
+        if (s.phaseNum && s.phaseTotal) {
+            const phase = s.phaseName ? `${s.phaseName} (${s.phaseNum}/${s.phaseTotal})` : `ph ${s.phaseNum}/${s.phaseTotal}`;
+            parts.push(phase);
+        }
     }
     return parts.join(' · ');
 }
+/** Compare two semver versions. Returns 1 if a > b, -1 if a < b, 0 if equal. */
+function semverCompare(a, b) {
+    const parseVer = (v) => {
+        const parts = v.replace(/^v/, '').split('.').map(p => parseInt(p, 10));
+        return { major: parts[0] ?? 0, minor: parts[1] ?? 0, patch: parts[2] ?? 0 };
+    };
+    const av = parseVer(a);
+    const bv = parseVer(b);
+    if (av.major !== bv.major)
+        return av.major > bv.major ? 1 : -1;
+    if (av.minor !== bv.minor)
+        return av.minor > bv.minor ? 1 : -1;
+    if (av.patch !== bv.patch)
+        return av.patch > bv.patch ? 1 : -1;
+    return 0;
+}
 /**
  * Read GSD update-check cache. Checks the shared tool-agnostic cache first
  * (`~/.cache/gsd/`, introduced by GSD #1421), then falls back to the legacy
  * per-runtime location (`~/.claude/cache/`) for older GSD installs.
+ * Returns update status, stale hooks flag, and dev install flag.
  */
 function readUpdateCache(sharedCacheFile, legacyCacheFile) {
+    const result = { updateAvailable: false, staleHooks: false, devInstall: false };
     const candidates = [
         ['shared', sharedCacheFile],
         ['legacy', legacyCacheFile],
@@ -100,19 +202,33 @@ function readUpdateCache(sharedCacheFile, legacyCacheFile) {
         try {
             const parsed = JSON.parse(readFileSync(file, 'utf8'));
             if (parsed.update_available) {
+                result.updateAvailable = true;
                 log('update cache:', source, file);
-                return true;
             }
+            if (Array.isArray(parsed.stale_hooks) && parsed.stale_hooks.length > 0) {
+                result.staleHooks = true;
+            }
+            // DevInstall: stale_hooks present AND installed is ahead of latest.
+            // Guard against an unknown/missing latest explicitly (mirrors GSD's own
+            // check) rather than relying on NaN comparison semantics in semverCompare.
+            if (result.staleHooks &&
+                parsed.installed &&
+                parsed.latest &&
+                parsed.latest !== 'unknown' &&
+                semverCompare(parsed.installed, parsed.latest) > 0) {
+                result.devInstall = true;
+            }
+            return result;
         }
         catch { /* ignore malformed */ }
     }
-    return false;
+    return result;
 }
 export function getGsdInfo(cwd, opts = {}) {
     const claudeDir = opts.claudeDir ?? process.env['CLAUDE_CONFIG_DIR'] ?? join(homedir(), '.claude');
     const sharedCacheFile = opts.sharedCacheFile ?? join(homedir(), '.cache', 'gsd', 'gsd-update-check.json');
     const legacyCacheFile = join(claudeDir, 'cache', 'gsd-update-check.json');
-    const updateAvailable = readUpdateCache(sharedCacheFile, legacyCacheFile);
+    const cacheData = readUpdateCache(sharedCacheFile, legacyCacheFile);
     let currentTask;
     const stateFile = findStateMd(cwd || process.cwd());
     if (stateFile) {
@@ -132,10 +248,15 @@ export function getGsdInfo(cwd, opts = {}) {
     else {
         log('no STATE.md found walking up from:', cwd || process.cwd());
     }
-    if (!updateAvailable && !currentTask) {
-        log('no gsd signal — update=false, task=none (line4 will be empty)');
+    if (!cacheData.updateAvailable && !cacheData.staleHooks && !currentTask) {
+        log('no gsd signal — update=false, staleHooks=false, task=none (line4 will be empty)');
         return null;
     }
-    return { updateAvailable, currentTask };
+    return {
+        updateAvailable: cacheData.updateAvailable || undefined,
+        staleHooks: cacheData.staleHooks || undefined,
+        devInstall: cacheData.devInstall || undefined,
+        currentTask,
+    };
 }
 //# sourceMappingURL=gsd.js.map

package/dist/render/line4.js

@@ -3,14 +3,23 @@ import { getCustomCommandsForLine, renderCustomCommand } from './shared.js';
 export function renderLine4(ctx, c) {
     const { gsd, icons } = ctx;
     const parts = [];
-    // GSD widget — only emit when GSD has something to display.
-    if (gsd && (gsd.currentTask || gsd.updateAvailable)) {
+    // GSD widget — only emit when GSD has something to display. Text and glyphs
+    // mirror GSD's own statusline (gsd-statusline.js) so the integration reads
+    // identically. The update/stale-hooks indicators render even without a
+    // current task, so a GSD update is visible in any project (gated only on the
+    // update-check cache, not on being inside a GSD project).
+    if (gsd && (gsd.currentTask || gsd.updateAvailable || gsd.staleHooks)) {
         parts.push(c.dim('GSD'));
         if (gsd.currentTask) {
-            parts.push(c.bold(`${icons.hammer} ${truncField(gsd.currentTask, 40)}`));
+            parts.push(c.bold(`${icons.hammer} ${truncField(gsd.currentTask, 60)}`));
         }
         if (gsd.updateAvailable) {
-            parts.push(c.yellow(`${icons.warning} GSD update available`));
+            parts.push(c.yellow('⬆ /gsd:update'));
+        }
+        if (gsd.staleHooks) {
+            parts.push(gsd.devInstall
+                ? c.yellow('⚠ dev install — re-run installer to sync hooks')
+                : c.red('⚠ stale hooks — run /gsd:update'));
         }
     }
     // Custom commands (issue #143 phase 3) — line 4 is the lowest-priority line

package/dist/types.js

@@ -113,7 +113,11 @@ export const DEFAULT_DISPLAY = {
 };
 export const DEFAULT_CONFIG = {
     layout: 'auto',
-    gsd: false,
+    // GSD on by default, mirroring GSD's own always-on statusline. Self-gates to
+    // nothing when there's no .planning/STATE.md and no update-check cache, so
+    // non-GSD users see no extra line and pay only a few cheap existsSync checks.
+    // Minimal/singleline returns early (renderMinimal) and never reaches line 4.
+    gsd: true,
     display: { ...DEFAULT_DISPLAY },
     colors: { mode: 'auto' },
     customCommands: { enabled: false, commands: [] },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lumira",
-  "version": "1.8.0",
+  "version": "1.8.2",
   "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",