claude-doom-statusbar 0.7.1 → 0.8.1

package/README.md

@@ -19,7 +19,7 @@ The HUD is a row of boxes centred on the mugshot. Each box is configurable; the
 - **ACTIVITY** — a tool-activity "geiger" sparkline (duty-cycle over the last 30 s), running-agent count, task progress, error count.
 - **AGENTS** — a live list of running subagents (type/description + ticking runtime), always visible. Long lists scroll within the box height, with ↑/↓ markers counting the rows hidden off-screen.
 - **TASKS** — the session's todo list: settled items (✅ done, ❌ removed) on top, open items (⏩ in-progress, 🎯 pending) below. Scrolls like AGENTS, anchored on the open/settled boundary.
-- **SYS** — CPU, disk, session length, wall clock.
+- **SYS** — CPU, a per-core CPU equalizer (one threshold-coloured column per core), disk, session length, wall clock.
 
 Anything the session can't supply is hidden automatically, so the same config degrades cleanly.
 
@@ -71,7 +71,13 @@ $env:FORCE_HYPERLINK = "1"; claude
 - **`standard`** — balanced HUD.
 - **`full`** — every box, the look in the screenshot above.
 
-A preset is TOML: a `[bar]` style block, a `[mugshot]` block, and a list of `[[segment]]` boxes. Each box lists metrics with a render type — `bar`, `number`, `text`, `spark`, `ammo`, `list`, `scroll`, or a `group`. Copy one and rearrange the boxes, swap icons, or change which metrics show.
+A preset is TOML: a `[bar]` style block, a `[mugshot]` block, and a list of `[[segment]]` boxes. Each box lists metrics with a render type — `bar`, `number`, `text`, `spark`, `equalizer`, `ammo`, `list`, `scroll`, or a `group`. (`equalizer` draws an array of `0..1` values as a one-row VU-meter: one block column per channel, each coloured by its own value — e.g. `sys.cores` for per-core CPU.) Copy one and rearrange the boxes, swap icons, or change which metrics show.
+
+A value-carrying metric (`bar`, `ammo`, `equalizer`, `number`, `text`) can set `color`:
+
+- `color = "threshold"` — the default heat gradient: green at 0, yellow at 50, red at 100, smoothly interpolated.
+- `color = "#rrggbb"` — a solid colour.
+- `color = [[0, "#60c868"], [50, "#e0b840"], [100, "#e05440"]]` — custom gradient stops as `[value, "#hex"]` pairs, interpolated between stops. A single pair is a solid colour; adjacent stops (e.g. `[50, "#..."], [51, "#..."]`) make a hard step instead of a smooth blend.
 
 ### Responsive width
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-doom-statusbar",
-  "version": "0.7.1",
+  "version": "0.8.1",
   "description": "DOOM-inspired status bar for the Claude Code CLI — a mugshot that tracks session health, plus usage, model, project, system, and a live subagent list.",
   "type": "module",
   "bin": {
@@ -15,7 +15,7 @@
   "scripts": {
     "statusline": "node src/statusline.js",
     "hook": "node src/hook.js",
-    "test": "node test/installer.test.mjs && node test/smoke.test.mjs && node test/hook-tasks.test.mjs && node test/statusline-tasks.test.mjs && node test/render-scroll.test.mjs && node test/statusline-savings.test.mjs && node test/e2e-tasks.test.mjs && node test/marquee.test.mjs && node test/layout.test.mjs && node test/resolve-preset.test.mjs && node test/preset-bands.test.mjs && node test/journal.test.mjs && node test/git-event.test.mjs",
+    "test": "node test/installer.test.mjs && node test/smoke.test.mjs && node test/hook-tasks.test.mjs && node test/statusline-tasks.test.mjs && node test/render-scroll.test.mjs && node test/render-equalizer.test.mjs && node test/statusline-savings.test.mjs && node test/statusline-cores.test.mjs && node test/e2e-tasks.test.mjs && node test/marquee.test.mjs && node test/layout.test.mjs && node test/resolve-preset.test.mjs && node test/preset-bands.test.mjs && node test/journal.test.mjs && node test/git-event.test.mjs",
     "preversion": "npm test",
     "postversion": "git push --follow-tags",
     "prepublishOnly": "npm test"

package/presets/full.toml

@@ -87,7 +87,8 @@ metric = [
 type  = "box"
 title = "SYS"
 metric = [
-  { id = "sys.cpu",     render = "number", icon = "🔥" },
+  { id = "sys.cpu",     render = "number",    icon = "🔥" },
+  { id = "sys.cores",   render = "equalizer", icon = "📊", color = "threshold" },
   { id = "sys.disk",    render = "bar",    icon = "💿", color = "threshold" },
   { id = "sys.session", render = "text",   icon = "🕙" },
   { id = "sys.clock",   render = "text",   icon = "🕓" },

package/src/render.js

@@ -47,6 +47,8 @@ export const SAMPLE = {
   "act.geiger": [0, .25, .5, 1, .75, 1, .5, .6, .3, .1, .4, 1, .8, .4],
   "act.tasks": "2/5", "act.errors": "0", "sys.ram": 47, "sys.cpu": "12%",
   "sys.disk": 63, "sys.clock": "14:23",
+  "sys.cores": [0.12, 0.30, 0.08, 0.95, 0.45, 0.18, 0.62, 0.22],
+
   "save.leanctx": "8.3k 63%", "save.lingua": "1.2k 1.3x",
 };
 
@@ -88,8 +90,42 @@ function headCols(text, width) {
   return out;
 }
 
-function threshold(pct) {
-  return pct < 60 ? OK : pct < 85 ? WARN : CRIT;
+// Default heat gradient: green (0) -> yellow (50) -> red (100). Higher = hotter,
+// the orientation every caller wants (context usage, rate limits, CPU, disk, RAM).
+const DEFAULT_STOPS = [[0, OK], [50, WARN], [100, CRIT]];
+
+const lerp1 = (a, b, t) => Math.round(a + (b - a) * t);
+
+// Interpolate an RGB colour at `pct` (0..100) across sorted [value, rgb] stops.
+// Below the first stop / above the last it clamps to that stop. A single stop is a
+// solid colour; adjacent stops (e.g. 50 then 51) make a near-hard transition.
+function interpStops(stops, pct) {
+  if (pct <= stops[0][0]) return stops[0][1];
+  const last = stops[stops.length - 1];
+  if (pct >= last[0]) return last[1];
+  for (let i = 1; i < stops.length; i++) {
+    const [v0, c0] = stops[i - 1], [v1, c1] = stops[i];
+    if (pct <= v1) {
+      const t = v1 === v0 ? 0 : (pct - v0) / (v1 - v0);
+      return [0, 1, 2].map((j) => lerp1(c0[j], c1[j], t));
+    }
+  }
+  return last[1];
+}
+
+// Resolve a metric's `color` spec to an RGB at `pct` (0..100):
+//   "threshold"        -> the default green->yellow->red gradient
+//   [[v, "#hex"], ...] -> a custom gradient (a single pair = a solid colour)
+//   "#rrggbb"          -> a solid colour
+//   unset / unknown    -> null, so the caller can pick its own default
+function colorFor(spec, pct) {
+  if (spec === "threshold") return interpStops(DEFAULT_STOPS, pct);
+  if (Array.isArray(spec) && spec.length) {
+    const stops = spec.map(([v, c]) => [v, rgbOf(c)]).sort((a, b) => a[0] - b[0]);
+    return interpStops(stops, pct);
+  }
+  if (typeof spec === "string" && spec.startsWith("#")) return rgbOf(spec);
+  return null;
 }
 
 function rgbOf(spec) {
@@ -118,7 +154,7 @@ function rBar(pct, cells, boxRgb, colorSpec, showPct = true) {
   const eighths = pyround((pct / 100) * cells * 8);
   const full = Math.min(cells, Math.floor(eighths / 8));
   const rem = full < cells ? eighths % 8 : 0;
-  const c = colorSpec === "threshold" ? threshold(pct) : colorSpec ? rgbOf(colorSpec) : TEXT;
+  const c = colorFor(colorSpec, pct) ?? TEXT;
   let s = sgrBg(empty) + f(c) + "█".repeat(full);
   if (rem) s += EIGHTHS[rem];
   s += " ".repeat(Math.max(0, cells - full - (rem ? 1 : 0)));
@@ -128,7 +164,7 @@ function rBar(pct, cells, boxRgb, colorSpec, showPct = true) {
 }
 
 function rAmmo(pct, colorSpec, segs = 5) {
-  const c = colorSpec === "threshold" ? threshold(pct) : WARN;
+  const c = colorFor(colorSpec, pct) ?? WARN;
   const filled = pyround((pct / 100) * segs);
   return f(c) + "▮".repeat(filled) + f([90, 95, 120]) + "▯".repeat(segs - filled) +
     f(c) + " " + String(pct).padStart(3) + "%";
@@ -147,6 +183,12 @@ const SPARK_BRAILLE = [
   "⠀⢀⢠⢰⢸", "⡀⣀⣠⣰⣸", "⡄⣄⣤⣴⣼", "⡆⣆⣦⣶⣾", "⡇⣇⣧⣷⣿",
 ].map((r) => [...r]);
 const BLOCK_RAMP = [..."▁▂▃▄▅▆▇"];
+// The equalizer's OWN 9-level height ramp (empty 0/8 .. full 8/8), so an idle
+// channel reads as empty and a maxed one as a full block -- deliberately wider at
+// both ends than spark's BLOCK_RAMP, which never shows empty or full. Index via
+// pyround(clamp(v,0,1) * 8).
+const EQ_RAMP = [..." ▁▂▃▄▅▆▇█"];
+const EQ_MAX = 16; // column cap: more channels than this densify by averaging
 
 function rSpark(values, style = "block", boxRgb = TERM_RGB, vmax = null) {
   const empty = [0, 1, 2].map((i) => Math.floor((boxRgb[i] + TERM_RGB[i]) / 2));
@@ -178,6 +220,36 @@ function rSpark(values, style = "block", boxRgb = TERM_RGB, vmax = null) {
   return bg + f(SPARK) + body + bgsgrBox(boxRgb);
 }
 
+// Densify N channel values into exactly K = min(N, EQ_MAX) columns by averaging
+// each column's contiguous slice. K columns by construction, so the rendered width
+// always equals metricFixedWidth's min(N, EQ_MAX) -- the box-layout invariant.
+function eqColumns(values) {
+  const n = values.length;
+  const k = Math.min(n, EQ_MAX);
+  const cols = [];
+  for (let i = 0; i < k; i++) {
+    const lo = Math.floor((i * n) / k), hi = Math.floor(((i + 1) * n) / k);
+    let sum = 0;
+    for (let j = lo; j < hi; j++) sum += values[j];
+    cols.push(sum / (hi - lo));
+  }
+  return cols;
+}
+
+// One-row VU-meter: one block column per channel (densified past EQ_MAX), each
+// column coloured by its OWN value via the metric's colour spec (default gradient).
+// Absolute 0..1 scale (no span-normalize), 9-level EQ_RAMP. Fixed-width: no `cells`.
+function rEqualizer(values, boxRgb, colorSpec) {
+  if (!values || values.length === 0) return f(SPARK);
+  const empty = [0, 1, 2].map((i) => Math.floor((boxRgb[i] + TERM_RGB[i]) / 2));
+  let body = sgrBg(empty);
+  for (const raw of eqColumns(values)) {
+    const v = Math.max(0, Math.min(1, raw));
+    body += f(colorFor(colorSpec, v * 100) ?? OK) + EQ_RAMP[pyround(v * 8)];
+  }
+  return body + bgsgrBox(boxRgb);
+}
+
 export function renderValue(entry, cells, boxRgb) {
   const icon = entry.icon || "";
   const label = icon ? icon + " " : "";
@@ -198,17 +270,13 @@ export function renderValue(entry, cells, boxRgb) {
   }
   if (render === "ammo") return label + rAmmo(val, color || "threshold");
   if (render === "spark") return label + rSpark(val, entry.spark_style || "block", boxRgb, entry.spark_max);
+  if (render === "equalizer") return label + rEqualizer(val, boxRgb, color || "threshold");
   if (render === "list") {
     const items = VALUES[entry.id] || [];
     return label + f(TEXT) + items.map((x) => (Array.isArray(x) ? `${x[0]} ${x[1]}` : String(x))).join("  ");
   }
   // number / text
-  let col;
-  if (color === "threshold") {
-    col = threshold(parseInt(String(val).replace(/\D/g, "") || "0", 10));
-  } else {
-    col = color ? rgbOf(color) : TEXT;
-  }
+  const col = colorFor(color, parseInt(String(val).replace(/\D/g, "") || "0", 10)) ?? TEXT;
   return label + f(col) + String(val);
 }
 
@@ -253,6 +321,7 @@ export function metricFixedWidth(entry, textCap = TEXTCAP_MAX) {
     return lw + capLen(entry.group.filter((i) => i in VALUES).map((i) => String(VALUES[i])).join(sep), textCap) + rextra;
   }
   if (r === "spark") return lw + Math.floor(((VALUES[entry.id] || []).length + 1) / 2);
+  if (r === "equalizer") return lw + Math.min((VALUES[entry.id] || []).length, EQ_MAX);
   if (r === "ammo") return lw + 5 + vlen(" " + (entry.id in VALUES ? VALUES[entry.id] : 0) + "%");
   if (r === "list") {
     const items = VALUES[entry.id] || [];
@@ -557,9 +626,7 @@ export function buildBar(cfg, target, spriteFor, tick = 0, overflow) {
         const budget = w - vlen(lbl) - vlen(rhs);
         const sliceable = !ESC_RE.test(raw) || OSC8_RE.test(raw); // plain or hyperlink
         if (sliceable && budget > 0 && vlen(raw) > budget) {
-          let col;
-          if (m.color === "threshold") col = threshold(parseInt(raw.replace(/\D/g, "") || "0", 10));
-          else col = m.color ? rgbOf(m.color) : TEXT;
+          const col = colorFor(m.color, parseInt(raw.replace(/\D/g, "") || "0", 10)) ?? TEXT;
           body = lbl + f(col) + marquee(raw, budget, tick, ovf);
         }
       }

package/src/statusline.js

@@ -239,26 +239,69 @@ function ramPercent() {
   try { return pyround((1 - os.freemem() / os.totalmem()) * 100); } catch { return null; }
 }
 
-function cpuPercent() {
-  let total = 0, idle = 0;
+// Minimum interval between CPU snapshots; below this, per-core deltas are tick-quantised noise.
+const CPU_MIN_MS = 1000;
+
+// Pure: should cpuMetrics recompute, or hold the cached result? Recompute on cold start,
+// a legacy snapshot without `ts`, a missing cached result, or once CPU_MIN_MS has elapsed.
+// Holding in between keeps a burst of fast refreshes from sampling a sub-tick interval.
+export function shouldSampleCpu(prev, now) {
+  return !(prev && typeof prev.ts === "number" && now - prev.ts < CPU_MIN_MS && prev.result);
+}
+
+// Per-core idle fraction over a cumulative-time delta; null when no time elapsed.
+const cpuUtil = (dt, di) => (dt > 0 ? Math.max(0, Math.min(1, 1 - di / dt)) : null);
+
+// Pure: turn two cumulative CPU snapshots into the aggregate percent (sys.cpu, 0..100)
+// and the per-core utilisation array (sys.cores, 0..1 each). Cold start (no prev) or a
+// core-count mismatch (e.g. an old cache without `cores`) yields null for that field, so
+// the metric simply doesn't render that refresh. A core with no elapsed time reads 0.
+export function cpuDeltas(prev, cur) {
+  if (!prev) return { cpu: null, cores: null };
+  const cpu = cpuUtil(cur.total - prev.total, cur.idle - prev.idle);
+  let cores = null;
+  if (Array.isArray(prev.cores) && Array.isArray(cur.cores) && prev.cores.length === cur.cores.length) {
+    cores = cur.cores.map((c, i) => {
+      const u = cpuUtil(c.total - prev.cores[i].total, c.idle - prev.cores[i].idle);
+      return u === null ? 0 : u;
+    });
+  }
+  return { cpu: cpu === null ? null : pyround(cpu * 100), cores };
+}
+
+function cpuMetrics() {
+  let cores;
   try {
-    for (const c of os.cpus()) { for (const k in c.times) total += c.times[k]; idle += c.times.idle; }
-  } catch { return null; }
+    cores = os.cpus().map((c) => {
+      let total = 0; for (const k in c.times) total += c.times[k];
+      return { total, idle: c.times.idle };
+    });
+  } catch { return { cpu: null, cores: null }; }
+  const agg = cores.reduce((a, c) => ({ total: a.total + c.total, idle: a.idle + c.idle }), { total: 0, idle: 0 });
+  const now = Date.now();
+  const cur = { ts: now, total: agg.total, idle: agg.idle, cores };
   const cache = path.join(TMP, "mugshot_cpu.json");
   let prev = null;
   try { prev = JSON.parse(readFileSync(cache, "utf8")); } catch { /* none */ }
-  try { writeFileSync(cache, JSON.stringify({ total, idle })); } catch { /* ignore */ }
-  if (!prev) return null;
-  const dt = total - prev.total, di = idle - prev.idle;
-  return dt > 0 ? pyround(Math.max(0, Math.min(100, 100 * (1 - di / dt)))) : null;
+  // Windows updates os.cpus() times only on the ~15.6ms scheduler tick, so a per-core
+  // delta over a sub-second interval is dominated by tick quantisation and explodes
+  // into 0/100 noise. The status bar refreshes on every action, often milliseconds
+  // apart -- so only recompute when >= CPU_MIN_MS has elapsed, holding the last result
+  // (and the old snapshot) in between. The interval keeps growing until it's wide
+  // enough to be stable, even under a burst of fast refreshes.
+  if (!shouldSampleCpu(prev, now)) return prev.result;
+  const result = cpuDeltas(prev, cur);
+  try { writeFileSync(cache, JSON.stringify({ ...cur, result })); } catch { /* ignore */ }
+  return result;
 }
 
 function sysValues(cwd) {
   const v = {};
   const ram = ramPercent();
   if (ram !== null) v["sys.ram"] = ram;
-  const cpu = cpuPercent();
+  const { cpu, cores } = cpuMetrics();
   if (cpu !== null) v["sys.cpu"] = `${cpu}%`;
+  if (cores) v["sys.cores"] = cores;
   try {
     const stat = statfsSync(cwd || process.cwd());
     v["sys.disk"] = pyround(((stat.blocks - stat.bfree) / stat.blocks) * 100);