lumira 1.14.0 → 1.15.0

package/.claude-plugin/marketplace.json

@@ -5,14 +5,14 @@
   },
   "metadata": {
     "description": "Real-time statusline HUD for Claude Code and Qwen Code — analytics, quota projection, themes, powerline",
-    "version": "1.14.0"
+    "version": "1.15.0"
   },
   "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.14.0",
+      "version": "1.15.0",
       "author": {
         "name": "Carlos Cativo"
       },
@@ -32,5 +32,5 @@
       ]
     }
   ],
-  "version": "1.14.0"
+  "version": "1.15.0"
 }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lumira",
-  "version": "1.14.0",
+  "version": "1.15.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"

package/README.md

@@ -321,6 +321,7 @@ Create `~/.config/lumira/config.json`:
   "theme": "tokyo-night",
   "icons": "nerd",
   "style": "classic",
+  "line1Align": "justified",
   "powerline": { "style": "auto" },
   "gsd": false,
   "colors": { "mode": "auto" },
@@ -364,7 +365,7 @@ Create `~/.config/lumira/config.json`:
 }
 ```
 
-All fields are optional — defaults are shown above. `display.health` defaults to `false` (opt-in widget).
+All fields are optional — defaults are shown above. `display.health` defaults to `false` (opt-in widget). `line1Align` controls line 1's classic layout: `"justified"` (default) pins the left cluster to the start and the right cluster to the end; `"packed"` packs every segment tightly to the left with no forced middle gap, except the app version string, which stays pinned to the true right edge (the same idiom line 2 uses for its small right-anchored indicators). On a terminal too narrow to fit the version alongside the packed content, the version disappears entirely rather than truncating — an intentional all-or-nothing tradeoff. Powerline mode always packs.
 
 **Context bar thresholds** — `contextWarningThreshold` (default 70) and `contextCriticalThreshold` (default 85) control when the bar transitions through yellow/orange/red. Both are clamped to `[0, 100]` and `warning < critical` is required (invalid pairs fall back to defaults with a one-shot stderr warning). Lower them for earlier warnings, raise them if your workflow tolerates fuller buffers.
 

package/dist/config.js

@@ -196,6 +196,7 @@ function mergeConfig(rawIn) {
         raw = { ...raw, preset: 'minimal' };
     }
     const layout = ['multiline', 'singleline', 'auto'].includes(raw.layout) ? raw.layout : DEFAULT_CONFIG.layout;
+    const line1Align = ['justified', 'packed'].includes(raw.line1Align) ? raw.line1Align : DEFAULT_CONFIG.line1Align;
     const colors = { ...DEFAULT_CONFIG.colors };
     if (raw.colors && typeof raw.colors === 'object') {
         const m = raw.colors.mode;
@@ -204,6 +205,7 @@ function mergeConfig(rawIn) {
     }
     const result = {
         layout,
+        line1Align,
         gsd: typeof raw.gsd === 'boolean' ? raw.gsd : DEFAULT_CONFIG.gsd,
         display: { ...DEFAULT_DISPLAY },
         colors,

package/dist/render/line1.js

@@ -6,7 +6,7 @@ import { hyperlink } from './hyperlink.js';
 import { formatDuration } from '../utils/format.js';
 import { isNamedAgentType } from '../parsers/subagents.js';
 export function renderLine1(ctx, c) {
-    const { input, git, transcript, config: { display }, cols, icons, memory, tokenSpeed } = ctx;
+    const { input, git, transcript, config: { display, line1Align }, cols, icons, memory, tokenSpeed } = ctx;
     const left = [];
     const right = [];
     // Model
@@ -27,7 +27,19 @@ export function renderLine1(ctx, c) {
         }
         left.push(branchStr);
     }
-    // Directory
+    // Repo segment — owner/name from workspace.repo, clickable to open the repo
+    // on its host. Sits right after branch: both are git-identity (where you are
+    // in the DAG + which remote it tracks), so they stay grouped. Distinct from
+    // the directory breadcrumb below (a local path): this is the canonical remote
+    // identity, and surfaces the owner that the bare cwd basename can't.
+    if (display.repo && input.repo) {
+        const { owner, name, url } = input.repo;
+        const repoLen = cols < 80 ? 14 : cols < 120 ? 24 : 36;
+        const label = c.brightBlue(`${icons.repo} ${truncField(`${owner}/${name}`, repoLen)}`);
+        left.push(hyperlink(url, label));
+    }
+    // Directory — local filesystem context (where on disk), orthogonal to the
+    // git identity above. Rendered after repo so the two git segments group.
     if (display.directory) {
         const cwd = input.cwd;
         if (cwd) {
@@ -40,16 +52,6 @@ export function renderLine1(ctx, c) {
             left.push(hyperlink(pathToFileURL(cwd).href, label));
         }
     }
-    // Repo segment — owner/name from workspace.repo, clickable to open the repo
-    // on its host. Distinct from the directory breadcrumb above (a local path):
-    // this is the canonical remote identity, and surfaces the owner that the
-    // bare cwd basename can't.
-    if (display.repo && input.repo) {
-        const { owner, name, url } = input.repo;
-        const repoLen = cols < 80 ? 14 : cols < 120 ? 24 : 36;
-        const label = c.brightBlue(`${icons.repo} ${truncField(`${owner}/${name}`, repoLen)}`);
-        left.push(hyperlink(url, label));
-    }
     // Added dirs badge — only when count > 0; warning color at >= 5
     if (display.addedDirs && input.addedDirsCount != null && input.addedDirsCount > 0) {
         const badge = `+${input.addedDirsCount} dirs`;
@@ -118,8 +120,11 @@ export function renderLine1(ctx, c) {
         right.push(c.gray(input.outputStyle));
     }
     // Version — link to the Claude Code npm page for quick changelog lookup.
+    // Kept as its own segment (not pushed straight into `right`) because packed
+    // mode pins it alone to the true right edge while everything else packs left.
+    let versionSeg = null;
     if (display.version && input.version) {
-        right.push(hyperlink(`https://www.npmjs.com/package/@anthropic-ai/claude-code/v/${encodeURIComponent(input.version)}`, c.dim(`v${input.version}`)));
+        versionSeg = hyperlink(`https://www.npmjs.com/package/@anthropic-ai/claude-code/v/${encodeURIComponent(input.version)}`, c.dim(`v${input.version}`));
     }
     // Custom commands (issue #143 phase 3) — appended last on the left so they
     // sit after core widgets and evict first under fitSegments' narrow-cols
@@ -129,8 +134,18 @@ export function renderLine1(ctx, c) {
         if (seg)
             left.push(seg);
     }
-    if (left.length === 0 && right.length === 0)
+    if (left.length === 0 && right.length === 0 && !versionSeg)
         return '';
-    return fitSegments(left, right, SEP, cols);
+    // packed: pack every non-version segment tightly to the left with a single
+    // separator (no forced middle gap), leaving ONLY the version string pinned to
+    // the true right edge — the same idiom line2 uses for its small right-anchored
+    // cluster. fitSegments already leaves a gap before a short right array, and
+    // drops it whole when it can't fit (version vanishes rather than truncating on
+    // a narrow terminal — an accepted all-or-nothing tradeoff, see README).
+    if (line1Align === 'packed') {
+        return fitSegments(left.concat(right), versionSeg ? [versionSeg] : [], SEP, cols);
+    }
+    // justified: version rejoins the tail of the right cluster, pinned to the edge.
+    return fitSegments(left, versionSeg ? [...right, versionSeg] : right, SEP, cols);
 }
 //# sourceMappingURL=line1.js.map

package/dist/render/powerline-line1.js

@@ -69,27 +69,28 @@ function buildSegments(ctx, palette, c) {
             priority: 80,
         });
     }
-    if (display.directory && input.cwd) {
-        const dirName = basename(input.cwd) || input.cwd;
+    if (display.repo && input.repo) {
+        const { owner, name, url } = input.repo;
+        // Priority 61 — above directory@60. Repo is git identity (owner/name of the
+        // remote), grouped with branch, so it survives narrow-terminal pressure a
+        // step longer than the local directory. Rendered before directory to keep
+        // the git-identity segments adjacent. Same dir-family background.
         segments.push({
-            text: hyperlink(pathToFileURL(input.cwd).href, truncField(dirName, 30)),
-            icon: icons.folder,
+            text: hyperlink(url, truncField(`${owner}/${name}`, 36)),
+            icon: icons.repo,
             bg: palette.dirBg,
             fg: palette.fg,
-            priority: 60,
+            priority: 61,
         });
     }
-    if (display.repo && input.repo) {
-        const { owner, name, url } = input.repo;
-        // Priority 58 — below directory@60 and the addedDirs badge@59. Repo is the
-        // canonical remote identity (annotates the local dir), so it cedes first
-        // under narrow-terminal pressure. Same dir-family background as directory.
+    if (display.directory && input.cwd) {
+        const dirName = basename(input.cwd) || input.cwd;
         segments.push({
-            text: hyperlink(url, truncField(`${owner}/${name}`, 36)),
-            icon: icons.repo,
+            text: hyperlink(pathToFileURL(input.cwd).href, truncField(dirName, 30)),
+            icon: icons.folder,
             bg: palette.dirBg,
             fg: palette.fg,
-            priority: 58,
+            priority: 60,
         });
     }
     if (display.addedDirs && input.addedDirsCount != null && input.addedDirsCount > 0) {

package/dist/render/text.js

@@ -15,7 +15,11 @@ export function displayWidth(str) {
             w += 1;
             continue;
         }
-        if (cp >= 0x1F000 || (cp >= 0x2300 && cp <= 0x257F) || (cp >= 0x25A0 && cp <= 0x25FF) ||
+        // 0x2300–0x24FF covers wide Misc-Technical / Enclosed-Alphanumeric symbols
+        // but STOPS before the Box Drawing block (U+2500–U+257F), whose glyphs —
+        // including │ (U+2502), lumira's default SEP separator — are single-cell.
+        // Counting them as 2 over-reserved width on every separated line.
+        if (cp >= 0x1F000 || (cp >= 0x2300 && cp <= 0x24FF) || (cp >= 0x25A0 && cp <= 0x25FF) ||
             (cp >= 0x2600 && cp <= 0x27BF) || (cp >= 0x2B00 && cp <= 0x2BFF) ||
             (cp >= 0x4E00 && cp <= 0x9FFF) || (cp >= 0x3000 && cp <= 0x303F) || (cp >= 0xFF00 && cp <= 0xFFEF)) {
             w += 2;
@@ -53,13 +57,21 @@ export function truncatePath(str, maxLen = 20) {
         return filename.slice(0, maxLen - 3) + '...';
     return '.../' + filename;
 }
+// The usable width for a status line: total cols minus a 4-cell right margin.
+// The margin absorbs terminals that reserve a trailing cell and prevents the
+// off-by-one wraps that motivated it. Kept as the single source of this
+// constant so callers computing leftover/fill width can't drift out of sync
+// with fitSegments' own bound.
+export function safeCols(cols) {
+    return Math.max(1, cols - 4);
+}
 export function fitSegments(left, right, sep, cols) {
-    const safeCols = Math.max(1, cols - 4);
+    const safe = safeCols(cols);
     for (let l = left.length; l >= 1; l--) {
         const lSlice = left.slice(0, l);
         const leftStr = lSlice.join(sep);
         const leftW = displayWidth(leftStr);
-        if (leftW > safeCols)
+        if (leftW > safe)
             continue;
         for (let r = right.length; r >= 0; r--) {
             const rSlice = right.slice(0, r);
@@ -67,8 +79,8 @@ export function fitSegments(left, right, sep, cols) {
                 return leftStr;
             const rightStr = rSlice.join(sep);
             const rightW = displayWidth(rightStr);
-            if (leftW + 1 + rightW <= safeCols) {
-                const gap = Math.max(1, safeCols - leftW - rightW);
+            if (leftW + 1 + rightW <= safe) {
+                const gap = Math.max(1, safe - leftW - rightW);
                 return leftStr + ' '.repeat(gap) + rightStr;
             }
         }
@@ -77,7 +89,7 @@ export function fitSegments(left, right, sep, cols) {
     // Safe because left[0] is the model name (~20 chars) — callers must ensure
     // the first segment is short enough to truncate gracefully.
     // Strip ANSI before hard-truncating to avoid cutting mid-escape-sequence.
-    return truncField(stripAnsi(left[0] ?? ''), safeCols);
+    return truncField(stripAnsi(left[0] ?? ''), safe);
 }
 export function padLine(left, right, cols) {
     const leftW = displayWidth(left);

package/dist/types.js

@@ -123,6 +123,7 @@ export const DEFAULT_DISPLAY = {
 };
 export const DEFAULT_CONFIG = {
     layout: 'auto',
+    line1Align: 'justified',
     // 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.

package/dist/utils/terminal.js

@@ -46,12 +46,17 @@ export function getTermCols() {
     return 120;
 }
 // When stdout isn't a TTY (the statusline case — Claude Code pipes our output)
-// we still trust the resolved rawCols since proc-tree / COLUMNS / tput give the
-// real terminal width. The small 0.9 factor leaves 10% headroom for any chrome
-// the host renderer adds (separators, gutters) without aggressively starving
-// segments. Was 0.7 historically — too conservative for CC, where the
-// statusline uses the full terminal width.
-export function getLayoutCols(rawCols, isTTY, factor = 0.9) {
+// we trust the resolved rawCols since proc-tree / COLUMNS / tput give the real
+// terminal width, and use the full width (factor 1.0). Earlier versions reserved
+// headroom (0.7, then 0.9) on the theory that CC appends chrome (separators,
+// gutters) to the statusline's own row. Inspecting a real render showed that is
+// not the case: CC's own hints ("bypass permissions …", "PR #…", "← for agents")
+// render on a SEPARATE line below the statusline, never appended to its row — so
+// the reservation was speculative and only ever showed up as empty space at the
+// far-right edge. Every renderer that treats `cols` as a width budget already
+// protects itself: line1/line2 via fitSegments and the powerline lines via
+// renderPowerline both subtract a proven 4-column margin (see text.ts / powerline.ts).
+export function getLayoutCols(rawCols, isTTY, factor = 1.0) {
     if (isTTY)
         return rawCols;
     const clamped = Math.min(Math.max(factor, 0.3), 1.0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lumira",
-  "version": "1.14.0",
+  "version": "1.15.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",