pi-mega-compact 0.8.23 → 0.8.24

package/dist/extensions/mega-runtime/status.js

@@ -0,0 +1,11 @@
+/**
+ * status.ts — extracted `MegaRuntime.setStatus()`: the runtime status-key text
+ * mirrored to pi's status line and the dashboard. Same thin-delegate pattern
+ * as the other runtime.ts extractions.
+ */
+import { STATUS_KEY } from "./helpers.js";
+// ------------------------------------------------------------------ setStatus
+export function setStatusImpl(self, ctx, text) {
+    self.statusKey = text;
+    ctx.ui.setStatus(STATUS_KEY, text);
+}

package/dist/extensions/mega-runtime/widget-ansi.js

@@ -0,0 +1,207 @@
+/**
+ * widget-ansi.ts — the ANSI palette, theme resolution, panel layout helpers,
+ * and ambient border-effect helpers extracted from the original widget.ts.
+ *
+ * Pure rendering primitives with zero runtime-state dependencies. The render
+ * function (widget.ts) and the snapshot computation (snapshot.ts) import these;
+ * `C` is also re-exported via the widget barrel for mega-pipeline/mega-commands.
+ */
+// pi-tui's OWN width measurers — the same functions pi-tui uses to enforce its
+// render-width check ("visibleWidth(line) > width" → crash). Measuring with
+// these guarantees we never disagree on a grapheme's width (e.g. RGI emoji
+// like ⚡ which pi-tui counts as 2 but a naive regex counts as 1), and
+// truncateToWidth both pads AND hard-clips to exactly `width` cells, so no
+// off-by-one can trip the strict `> width` guard. (Fix for the
+// `Rendered line N exceeds terminal width (W > W-1)` crash.)
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { getTheme, DEFAULT_THEME } from "../../src/config/themes.js";
+// ── ANSI palette ───────────────────────────────────────────────────────────
+// The pi TUI's Text component preserves ANSI escape codes (see wrapTextWithAnsi),
+// so raw escapes render as colors. No chalk dependency needed — these are just
+// strings. Exported because mega-pipeline.ts and mega-commands.ts import `C`
+// from the mega-runtime barrel.
+export const C = {
+    reset: "\x1b[0m",
+    dim: "\x1b[2m",
+    bold: "\x1b[1m",
+    amber: "\x1b[38;5;214m", // tier / ready
+    green: "\x1b[38;5;120m", // saved
+    cyan: "\x1b[38;5;51m", // used / live activity
+    teal: "\x1b[38;5;37m", // processing (compress/dedup)
+    magenta: "\x1b[38;5;201m", // dedup rate
+    blue: "\x1b[38;5;75m", // repo totals
+    gray: "\x1b[38;5;245m", // labels
+    red: "\x1b[38;5;203m", // pressure / overflow
+};
+export const PULSE = ["◐", "◓", "◑", "◒"];
+// ── Full-width widget panel helpers ────────────────────────────────────────
+// pi's above-editor widget renderer (a Container of Text lines) does NOT pass
+// a terminal width to setWidget(), so lines render left-aligned by default. To
+// make the widget read as a full-width status panel we pad each line to the
+// real terminal width with a background fill. NOTE: C.reset is a FULL SGR
+// reset, so we re-apply the panel bg after every reset to keep the background
+// continuous under colored text (and under pi's own trailing reset).
+/** Default panel background (dark slate). Used when no theme is threaded or
+ *  the theme is transparent (no bg fill). Parametrized per-render via the
+ *  `panelTheme` arg so game-mode themes can restyle the panel background.
+ *  A transparent theme yields `""` so panelLine/panelBar still call
+ *  truncateToWidth (the width guard holds — empty prefix adds zero cells). */
+export const DEFAULT_PANEL_BG = "\x1b[48;5;236m"; // dark slate panel background
+/** Resolve the panel-background SGR prefix for a theme id. Transparent themes
+ *  (bg=null) and unknown themes yield `""` (no bg fill) — the width guard in
+ *  panelLine/panelBar still applies via truncateToWidth. */
+export function panelBgFor(theme) {
+    if (!theme || theme === DEFAULT_THEME)
+        return "";
+    const t = getTheme(theme);
+    const bg = t?.ansi.bg;
+    return bg ? `\x1b[${bg}m` : "";
+}
+/** Resolve a theme ANSI accent/mega/fg SGR prefix (`\x1b[<params>m`) for the
+ *  given role. Falls back to `""` (no SGR) for transparent/unknown themes so
+ *  game-mode text still renders in the default fg without color noise. */
+export function themeAnsi(theme, role) {
+    const t = theme ? getTheme(theme) : undefined;
+    const params = t?.ansi[role];
+    return params ? `\x1b[${params}m` : "";
+}
+/** Emit a full SGR reset, OR `""` if `sgr` is empty (transparent theme). Keeps
+ *  the panel bg continuous by NOT clobbering it with a bare reset when the
+ *  accent/mega prefix was a no-op. */
+export function sgrReset(sgr) {
+    return sgr ? "\x1b[0m" : "";
+}
+// (Visible-width measurement is delegated to pi-tui's `visibleWidth` — imported
+// above — so our width math can never diverge from pi-tui's render-width check.)
+/** Wrap a string (with ANSI codes) to fit within `maxWidth` visible chars.
+ *  Splits at │ separators or whitespace when possible. */
+export function wrapLine(text, maxWidth, panelBg) {
+    if (maxWidth <= 0)
+        return [text];
+    const panelRst = "\x1b[0m" + panelBg;
+    const result = [];
+    let current = "";
+    let currentW = 0;
+    // Split at │ boundaries first
+    const segments = text.split("│");
+    for (let i = 0; i < segments.length; i++) {
+        const seg = (i > 0 ? "│" : "") + segments[i];
+        const segW = visibleWidth(panelBg + seg.replace(/\x1b\[0m/g, panelRst));
+        if (currentW + segW <= maxWidth || currentW === 0) {
+            current += seg;
+            currentW += segW;
+        }
+        else {
+            result.push(current);
+            current = seg;
+            currentW = segW;
+        }
+    }
+    if (current)
+        result.push(current);
+    return result;
+}
+export function panelLine(content, width, panelBg = DEFAULT_PANEL_BG) {
+    if (width <= 0)
+        return "";
+    const panelRst = "\x1b[0m" + panelBg;
+    // Apply the panel background; swap every inner full-reset for a reset that
+    // re-applies the bg so the fill stays continuous under colored text.
+    const withBg = panelBg + content.replace(/\x1b\[0m/g, panelRst);
+    // truncateToWidth(line, width, "", true) returns EXACTLY `width` visible cells
+    // (by pi-tui's measure), ANSI-preserved, space-padded. It hard-clips overflow
+    // — so even a segment wider than `width` (or a width-rule mismatch) can never
+    // produce a line that trips pi-tui's strict `visibleWidth(line) > width` check.
+    return truncateToWidth(withBg, width, "", true) + "\x1b[0m";
+}
+/** A full-width hairline bar (top/bottom border of the panel). */
+export function panelBar(width, ch = "─", panelBg = DEFAULT_PANEL_BG) {
+    // `─` (U+2500) is narrow (1 cell) in both our measure and pi-tui's, so a
+    // `ch.repeat(width)` bar is exactly `width` cells and already passes the
+    // `> width` guard. truncateToWidth is belt-and-suspenders in case `ch` is
+    // ever swapped for a wide/fullwidth character.
+    return truncateToWidth(panelBg + ch.repeat(Math.max(0, width)), width, "", false) + "\x1b[0m";
+}
+// ── v0.8.3: ambient border-effect helpers ───────────────────────────────
+// The panel borders animate when an `activeEffect` is armed (level-up,
+// mega-cache overshoot, achievement unlock, compaction start). Two modes:
+//   • pulse — a sine ramp on a 256-color base (accent=51 / mega=214 / red=203):
+//     the base index is scaled by sin(π·t) so the border swells 0→peak→0 over
+//     the duration, then returns to '' (idle). 256-color indices are clamped
+//     to 0–255 defensively (the bases are all ≤214 so the clamp rarely bites).
+//   • flash — a 120ms hard on/off alternate using the base index at full.
+// Returns '' when idle, expired, or elapsed<0 (clock skew) so non-effect
+// renders are byte-identical to the pre-effect panel (S31 matrix stays green).
+export const EFFECT_BASE = {
+    accent: 51,
+    mega: 214,
+    red: 203,
+};
+/** Resolve the per-frame border-fg SGR for an active effect. '' when idle or
+ *  expired (the widget's real per-frame expiry enforcer — snapshot-level clear
+ *  is just bookkeeping since snapshot is event-driven). */
+export function effectBorderSgr(ae, now) {
+    if (!ae)
+        return "";
+    const elapsed = now - ae.startedAt;
+    if (elapsed < 0 || elapsed >= ae.durationMs)
+        return "";
+    const base = EFFECT_BASE[ae.role];
+    if (ae.type === "flash") {
+        // 120ms hard alternate: on (full base) / off (no SGR).
+        return Math.floor(elapsed / 120) % 2 === 0 ? `\x1b[38;5;${base}m` : "";
+    }
+    // pulse: sine ramp 0 → peak → 0 over the duration.
+    const t = elapsed / ae.durationMs;
+    const amp = Math.sin(Math.PI * t); // 0 at start/end, 1 at midpoint
+    const idx = Math.max(0, Math.min(255, Math.round(base * amp)));
+    return `\x1b[38;5;${idx}m`;
+}
+/** Prepend the effect border SGR to a panel bar line. The SGR is a pure-fg
+ *  escape (zero visible width), so it never perturbs truncateToWidth's width
+ *  math — the bar's own `\x1b[0m` tail resets both fg + bg. No-op when sgr=''. */
+export function effectBar(bar, sgr) {
+    return sgr ? sgr + bar : bar;
+}
+/** Token-count formatter: M at/above 1e6, k at/above 1e3, raw below.
+ *  5,472,700 → "5.5mil", 24,100 → "24.1k", 142 → "142". */
+export function fmtTokens(x) {
+    return x >= 1_000_000
+        ? `${(x / 1_000_000).toFixed(1)}mil`
+        : x >= 1000
+            ? `${(x / 1000).toFixed(1)}k`
+            : `${Math.round(x)}`;
+}
+/** Retro gradient bar — `w` cells shaded by fill position (green→amber→red).
+ *  Used for CONTEXT fill where low=green (room) and high=red (near the limit). */
+export function ramp(pct, w = 12) {
+    const cells = ["▏", "▎", "▍", "▌", "▋", "▊", "▉", "█"];
+    const scaled = Math.max(0, Math.min(w, pct * w));
+    const full = Math.floor(scaled);
+    const frac = scaled - full;
+    const fracCell = frac > 0 ? cells[Math.round(frac * (cells.length - 1))] : "";
+    let out = "";
+    for (let i = 0; i < full; i++)
+        out += (i / w < 0.6 ? C.green : i / w < 0.85 ? C.amber : C.red) + "█";
+    if (fracCell)
+        out +=
+            (full / w < 0.6 ? C.green : full / w < 0.85 ? C.amber : C.red) + fracCell;
+    out +=
+        C.dim + "░".repeat(Math.max(0, w - full - (fracCell ? 1 : 0))) + C.reset;
+    return out;
+}
+/** Human "time since" string from a millisecond delta (or null → "never"). */
+export function sinceCompactStr(ms) {
+    if (ms == null)
+        return "never";
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s ago`;
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return `${m}m ago`;
+    const h = Math.floor(m / 60);
+    if (h < 24)
+        return `${h}h ago`;
+    return `${Math.floor(h / 24)}d ago`;
+}

package/dist/extensions/mega-runtime/widget-types.js

@@ -0,0 +1,8 @@
+/**
+ * widget-types.ts — the `TickerEntry` and `WidgetData` interfaces extracted from
+ * the original widget.ts so the ANSI helpers (widget-ansi.ts) and the render
+ * function (widget.ts) can import them without a cycle.
+ *
+ * Pure type definitions — zero runtime code, zero imports.
+ */
+export {};

package/dist/extensions/mega-runtime/widget.js

@@ -1,211 +1,22 @@
 /**
- * widget.ts — above-editor widget rendering helpers (free functions, consts,
- * and interfaces) extracted from the original mega-runtime.ts monolith.
+ * widget.ts — above-editor widget rendering. Now a thin module that owns the
+ * `buildWidgetLines` render function and re-exports the ANSI helpers
+ * (widget-ansi.ts) + the interfaces (widget-types.ts) so every existing
+ * `import { C, TickerEntry, WidgetData, buildWidgetLines } from "./widget.js"`
+ * continues to resolve with no consumer changes.
  *
- * These are pure rendering primitives with zero runtime-state dependencies;
- * the `MegaRuntime` class (state.ts) imports them to paint the panel.
+ * Originally a single ~422-line file; split for the Phase 2 decomposition
+ * (see DECOMPOSITION.md). Pure rendering primitives — zero runtime-state
+ * dependencies; the `MegaRuntime` class (runtime.ts) imports them to paint the
+ * panel.
  */
-// pi-tui's OWN width measurers — the same functions pi-tui uses to enforce its
-// render-width check ("visibleWidth(line) > width" → crash). Measuring with
-// these guarantees we never disagree on a grapheme's width (e.g. RGI emoji
-// like ⚡ which pi-tui counts as 2 but a naive regex counts as 1), and
-// truncateToWidth both pads AND hard-clips to exactly `width` cells, so no
-// off-by-one can trip the strict `> width` guard. (Fix for the
-// `Rendered line N exceeds terminal width (W > W-1)` crash.)
-import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { getTheme, DEFAULT_THEME } from "../../src/config/themes.js";
-// ── ANSI palette ───────────────────────────────────────────────────────────
-// The pi TUI's Text component preserves ANSI escape codes (see wrapTextWithAnsi),
-// so raw escapes render as colors. No chalk dependency needed — these are just
-// strings. Exported because mega-pipeline.ts and mega-commands.ts import `C`
-// from the mega-runtime barrel.
-export const C = {
-    reset: "\x1b[0m",
-    dim: "\x1b[2m",
-    bold: "\x1b[1m",
-    amber: "\x1b[38;5;214m", // tier / ready
-    green: "\x1b[38;5;120m", // saved
-    cyan: "\x1b[38;5;51m", // used / live activity
-    teal: "\x1b[38;5;37m", // processing (compress/dedup)
-    magenta: "\x1b[38;5;201m", // dedup rate
-    blue: "\x1b[38;5;75m", // repo totals
-    gray: "\x1b[38;5;245m", // labels
-    red: "\x1b[38;5;203m", // pressure / overflow
-};
-const PULSE = ["◐", "◓", "◑", "◒"];
-// ── Full-width widget panel helpers ────────────────────────────────────────
-// pi's above-editor widget renderer (a Container of Text lines) does NOT pass
-// a terminal width to setWidget(), so lines render left-aligned by default. To
-// make the widget read as a full-width status panel we pad each line to the
-// real terminal width with a background fill. NOTE: C.reset is a FULL SGR
-// reset, so we re-apply the panel bg after every reset to keep the background
-// continuous under colored text (and under pi's own trailing reset).
-/** Default panel background (dark slate). Used when no theme is threaded or
- *  the theme is transparent (no bg fill). Parametrized per-render via the
- *  `panelTheme` arg so game-mode themes can restyle the panel background.
- *  A transparent theme yields `""` so panelLine/panelBar still call
- *  truncateToWidth (the width guard holds — empty prefix adds zero cells). */
-const DEFAULT_PANEL_BG = "\x1b[48;5;236m"; // dark slate panel background
-/** Resolve the panel-background SGR prefix for a theme id. Transparent themes
- *  (bg=null) and unknown themes yield `""` (no bg fill) — the width guard in
- *  panelLine/panelBar still applies via truncateToWidth. */
-function panelBgFor(theme) {
-    if (!theme || theme === DEFAULT_THEME)
-        return "";
-    const t = getTheme(theme);
-    const bg = t?.ansi.bg;
-    return bg ? `\x1b[${bg}m` : "";
-}
-/** Resolve a theme ANSI accent/mega/fg SGR prefix (`\x1b[<params>m`) for the
- *  given role. Falls back to `""` (no SGR) for transparent/unknown themes so
- *  game-mode text still renders in the default fg without color noise. */
-function themeAnsi(theme, role) {
-    const t = theme ? getTheme(theme) : undefined;
-    const params = t?.ansi[role];
-    return params ? `\x1b[${params}m` : "";
-}
-/** Emit a full SGR reset, OR `""` if `sgr` is empty (transparent theme). Keeps
- *  the panel bg continuous by NOT clobbering it with a bare reset when the
- *  accent/mega prefix was a no-op. */
-function sgrReset(sgr) {
-    return sgr ? "\x1b[0m" : "";
-}
-// (Visible-width measurement is delegated to pi-tui's `visibleWidth` — imported
-// above — so our width math can never diverge from pi-tui's render-width check.)
-/** Wrap a string (with ANSI codes) to fit within `maxWidth` visible chars.
- *  Splits at │ separators or whitespace when possible. */
-function wrapLine(text, maxWidth, panelBg) {
-    if (maxWidth <= 0)
-        return [text];
-    const panelRst = "\x1b[0m" + panelBg;
-    const result = [];
-    let current = "";
-    let currentW = 0;
-    // Split at │ boundaries first
-    const segments = text.split("│");
-    for (let i = 0; i < segments.length; i++) {
-        const seg = (i > 0 ? "│" : "") + segments[i];
-        const segW = visibleWidth(panelBg + seg.replace(/\x1b\[0m/g, panelRst));
-        if (currentW + segW <= maxWidth || currentW === 0) {
-            current += seg;
-            currentW += segW;
-        }
-        else {
-            result.push(current);
-            current = seg;
-            currentW = segW;
-        }
-    }
-    if (current)
-        result.push(current);
-    return result;
-}
-function panelLine(content, width, panelBg = DEFAULT_PANEL_BG) {
-    if (width <= 0)
-        return "";
-    const panelRst = "\x1b[0m" + panelBg;
-    // Apply the panel background; swap every inner full-reset for a reset that
-    // re-applies the bg so the fill stays continuous under colored text.
-    const withBg = panelBg + content.replace(/\x1b\[0m/g, panelRst);
-    // truncateToWidth(line, width, "", true) returns EXACTLY `width` visible cells
-    // (by pi-tui's measure), ANSI-preserved, space-padded. It hard-clips overflow
-    // — so even a segment wider than `width` (or a width-rule mismatch) can never
-    // produce a line that trips pi-tui's strict `visibleWidth(line) > width` check.
-    return truncateToWidth(withBg, width, "", true) + "\x1b[0m";
-}
-/** A full-width hairline bar (top/bottom border of the panel). */
-function panelBar(width, ch = "─", panelBg = DEFAULT_PANEL_BG) {
-    // `─` (U+2500) is narrow (1 cell) in both our measure and pi-tui's, so a
-    // `ch.repeat(width)` bar is exactly `width` cells and already passes the
-    // `> width` guard. truncateToWidth is belt-and-suspenders in case `ch` is
-    // ever swapped for a wide/fullwidth character.
-    return truncateToWidth(panelBg + ch.repeat(Math.max(0, width)), width, "", false) + "\x1b[0m";
-}
-// ── v0.8.3: ambient border-effect helpers ───────────────────────────────
-// The panel borders animate when an `activeEffect` is armed (level-up,
-// mega-cache overshoot, achievement unlock, compaction start). Two modes:
-//   • pulse — a sine ramp on a 256-color base (accent=51 / mega=214 / red=203):
-//     the base index is scaled by sin(π·t) so the border swells 0→peak→0 over
-//     the duration, then returns to '' (idle). 256-color indices are clamped
-//     to 0–255 defensively (the bases are all ≤214 so the clamp rarely bites).
-//   • flash — a 120ms hard on/off alternate using the base index at full.
-// Returns '' when idle, expired, or elapsed<0 (clock skew) so non-effect
-// renders are byte-identical to the pre-effect panel (S31 matrix stays green).
-const EFFECT_BASE = {
-    accent: 51,
-    mega: 214,
-    red: 203,
-};
-/** Resolve the per-frame border-fg SGR for an active effect. '' when idle or
- *  expired (the widget's real per-frame expiry enforcer — snapshot-level clear
- *  is just bookkeeping since snapshot is event-driven). */
-function effectBorderSgr(ae, now) {
-    if (!ae)
-        return "";
-    const elapsed = now - ae.startedAt;
-    if (elapsed < 0 || elapsed >= ae.durationMs)
-        return "";
-    const base = EFFECT_BASE[ae.role];
-    if (ae.type === "flash") {
-        // 120ms hard alternate: on (full base) / off (no SGR).
-        return Math.floor(elapsed / 120) % 2 === 0 ? `\x1b[38;5;${base}m` : "";
-    }
-    // pulse: sine ramp 0 → peak → 0 over the duration.
-    const t = elapsed / ae.durationMs;
-    const amp = Math.sin(Math.PI * t); // 0 at start/end, 1 at midpoint
-    const idx = Math.max(0, Math.min(255, Math.round(base * amp)));
-    return `\x1b[38;5;${idx}m`;
-}
-/** Prepend the effect border SGR to a panel bar line. The SGR is a pure-fg
- *  escape (zero visible width), so it never perturbs truncateToWidth's width
- *  math — the bar's own `\x1b[0m` tail resets both fg + bg. No-op when sgr=''. */
-function effectBar(bar, sgr) {
-    return sgr ? sgr + bar : bar;
-}
-/** Token-count formatter: M at/above 1e6, k at/above 1e3, raw below.
- *  5,472,700 → "5.5mil", 24,100 → "24.1k", 142 → "142". */
-function fmtTokens(x) {
-    return x >= 1_000_000
-        ? `${(x / 1_000_000).toFixed(1)}mil`
-        : x >= 1000
-            ? `${(x / 1000).toFixed(1)}k`
-            : `${Math.round(x)}`;
-}
-/** Retro gradient bar — `w` cells shaded by fill position (green→amber→red).
- *  Used for CONTEXT fill where low=green (room) and high=red (near the limit). */
-function ramp(pct, w = 12) {
-    const cells = ["▏", "▎", "▍", "▌", "▋", "▊", "▉", "█"];
-    const scaled = Math.max(0, Math.min(w, pct * w));
-    const full = Math.floor(scaled);
-    const frac = scaled - full;
-    const fracCell = frac > 0 ? cells[Math.round(frac * (cells.length - 1))] : "";
-    let out = "";
-    for (let i = 0; i < full; i++)
-        out += (i / w < 0.6 ? C.green : i / w < 0.85 ? C.amber : C.red) + "█";
-    if (fracCell)
-        out +=
-            (full / w < 0.6 ? C.green : full / w < 0.85 ? C.amber : C.red) + fracCell;
-    out +=
-        C.dim + "░".repeat(Math.max(0, w - full - (fracCell ? 1 : 0))) + C.reset;
-    return out;
-}
-/** Human "time since" string from a millisecond delta (or null → "never"). */
-function sinceCompactStr(ms) {
-    if (ms == null)
-        return "never";
-    const s = Math.floor(ms / 1000);
-    if (s < 60)
-        return `${s}s ago`;
-    const m = Math.floor(s / 60);
-    if (m < 60)
-        return `${m}m ago`;
-    const h = Math.floor(m / 60);
-    if (h < 24)
-        return `${h}h ago`;
-    return `${Math.floor(h / 24)}d ago`;
-}
+// Re-export the ANSI palette + layout/effect helpers and the interfaces so the
+// barrel (`extensions/mega-runtime.ts` does `export * from "./widget.js"`) and
+// every direct consumer keep resolving the same named exports.
+export { C, PULSE, DEFAULT_PANEL_BG, EFFECT_BASE, panelBgFor, themeAnsi, sgrReset, wrapLine, panelLine, panelBar, effectBorderSgr, effectBar, fmtTokens, ramp, sinceCompactStr, } from "./widget-ansi.js";
+import { C, PULSE, DEFAULT_PANEL_BG, panelBgFor, themeAnsi, sgrReset, wrapLine, panelLine, panelBar, effectBorderSgr, effectBar, fmtTokens, ramp, sinceCompactStr } from "./widget-ansi.js";
 // ── buildWidgetLines ───────────────────────────────────────────────────────
-// Kept as a free function (not a MegaRuntime method) so state.ts stays
+// Kept as a free function (not a MegaRuntime method) so runtime.ts stays
 // focused on state management. It reads the WidgetData snapshot + the live
 // activeAgents counter (passed in) and returns the panel lines.
 /** Build the full-width panel lines from the latest snapshot. Cheap: reads