mergestorm 0.2.0 → 0.3.0

package/dist/ui/ansi.js

@@ -1,20 +1,27 @@
 import { stdout } from "node:process";
-const enabled = process.env.FORCE_COLOR !== undefined && process.env.FORCE_COLOR !== "0"
-    ? true
-    : Boolean(stdout.isTTY) &&
-        !process.env.NO_COLOR &&
-        process.env.TERM !== "dumb";
+function computeEnabled() {
+    return process.env.FORCE_COLOR !== undefined && process.env.FORCE_COLOR !== "0"
+        ? true
+        : Boolean(stdout.isTTY) &&
+            !process.env.NO_COLOR &&
+            process.env.TERM !== "dumb";
+}
 function wrap(code, text) {
-    if (!enabled)
+    if (!computeEnabled())
         return text;
-    return `\u001b[${code}m${text}\u001b[0m`;
+    return `[${code}m${text}`;
 }
 export const ansi = {
-    enabled,
+    get enabled() {
+        return computeEnabled();
+    },
     green: (t) => wrap("32", t),
     bold: (t) => wrap("1", t),
     dim: (t) => wrap("2", t),
     red: (t) => wrap("31", t),
     yellow: (t) => wrap("33", t),
-    boldGreen: (t) => (enabled ? `\u001b[1;32m${t}\u001b[0m` : t),
+    gray: (t) => wrap("90", t),
+    brightGreen: (t) => wrap("92", t),
+    invert: (t) => wrap("7", t),
+    boldGreen: (t) => (computeEnabled() ? `${t}` : t),
 };

package/dist/ui/banner.d.ts

@@ -1,3 +1,4 @@
+/** Used by the non-interactive `usage()` path in cli.ts — the boxed banner is shell-only. */
 export declare function printWordmark(): void;
 export declare function printBannerHeader(): Promise<void>;
 export declare function shellPrompt(loggedIn: boolean): string;

package/dist/ui/banner.js

@@ -2,46 +2,97 @@ import { getMe } from "../api.js";
 import { keyDisplay, loadConfig, resolveApiKey } from "../config.js";
 import { cliVersion } from "../version.js";
 import { ansi } from "./ansi.js";
+import { roundedBox, visibleWidth } from "./box.js";
+import { TORNADO_LOGO } from "./logo.js";
+import { usageBar } from "./usage.js";
 const WORDMARK = `
  __  __ ___ ___  ___ ___ ___ _____ ___  ___ __  __
 |  \\/  | __| _ \\/ __| __/ __|_   _/ _ \\| _ \\  \\/  |
 | |\\/| | _||   / (_ | _|\\__ \\ | || (_) |   / |\\/| |
 |_|  |_|___|_|_\\\\___|___|___/ |_| \\___/|_|_\\_|  |_|
 `.trimEnd();
+/** Used by the non-interactive `usage()` path in cli.ts — the boxed banner is shell-only. */
 export function printWordmark() {
     console.log(ansi.boldGreen(WORDMARK));
     console.log(ansi.dim(`  review local diffs fast · mergestorm.ai · v${cliVersion()}`));
     console.log("");
 }
-function formatStatusLine(me, key) {
+// Keyed by CLI version so the banner surfaces exactly what shipped in that release.
+const WHATS_NEW = {
+    "0.2.0": [
+        "Boxed welcome banner with a fresh look",
+        "Live `/` slash-command autocomplete in the shell",
+    ],
+    "0.3.0": [
+        "Claude-style usage meter (N% used) + credit reset time",
+        "`branches` / `chain` — explore branch review timelines",
+    ],
+};
+function formatStatusLines(me, key) {
     if (!key) {
-        return (`  ${ansi.dim("○")} not logged in — type ${ansi.green("login")} to sign in via browser,\n` +
-            `    or ${ansi.green("login --key")} to paste an API key`);
+        return [
+            `${ansi.dim("○")} not logged in — type ${ansi.green("login")} to sign in via browser,`,
+            `  or ${ansi.green("login --key")} to paste an API key`,
+        ];
     }
     const display = me?.key.prefix ?? keyDisplay(key) ?? "msk_live_…";
     if (!me) {
-        return `  ${ansi.green("●")} logged in (${ansi.bold(display)})`;
+        return [`${ansi.green("●")} logged in (${ansi.bold(display)})`];
     }
     const plan = me.plan_label_key ?? me.plan_key;
-    const left = me.usage.standard.remaining;
-    const limit = me.usage.standard.limit;
-    return (`  ${ansi.green("●")} ${ansi.bold(display)}  ·  ${plan}  ·  ` +
-        `standard credits: ${left} of ${limit} left`);
+    const s = me.usage.standard;
+    // Compact Claude meter in the welcome panel (shorter than the credits view).
+    return [
+        `${ansi.green("●")} ${ansi.bold(display)}  ·  ${plan}`,
+        `  ${usageBar(s.used, s.limit, { width: 32 })}`,
+    ];
+}
+function tipsLines() {
+    return [
+        ansi.dim("Tips for getting started:"),
+        `  ${ansi.green("review")}      review the diff for main...HEAD`,
+        `  ${ansi.green("branches")}    pick a recently reviewed branch`,
+        `  ${ansi.green("/help")}       list all commands`,
+    ];
+}
+function whatsNewLines(version) {
+    const entries = WHATS_NEW[version];
+    if (!entries || !entries.length)
+        return [];
+    return [
+        ansi.dim(`What's new in v${version}:`),
+        ...entries.map((entry) => `  ${ansi.green("•")} ${entry}`),
+    ];
+}
+function centerLine(line, width) {
+    const room = Math.max(0, width - visibleWidth(line));
+    const left = Math.floor(room / 2);
+    return `${" ".repeat(left)}${line}${" ".repeat(room - left)}`;
 }
 export async function printBannerHeader() {
-    printWordmark();
     const cfg = await loadConfig();
     const key = resolveApiKey(cfg);
     let me = null;
     if (key) {
         me = await getMe(cfg);
     }
-    console.log(formatStatusLine(me, key));
-    console.log("");
-    console.log(ansi.dim("  type `help` for commands · `review` to review main...HEAD"));
+    const version = cliVersion();
+    const textLines = [
+        ...formatStatusLines(me, key),
+        "",
+        ...tipsLines(),
+        ...whatsNewLines(version),
+    ];
+    const contentWidth = Math.max(0, ...textLines.map(visibleWidth), ...TORNADO_LOGO.map(visibleWidth));
+    const logoLines = TORNADO_LOGO.map((line) => centerLine(ansi.brightGreen(line), contentWidth));
+    const panel = roundedBox([...logoLines, "", ...textLines], {
+        title: `mergestorm v${version}`,
+    });
+    for (const line of panel) {
+        console.log(line);
+    }
     console.log("");
 }
 export function shellPrompt(loggedIn) {
-    const name = loggedIn ? ansi.boldGreen("mergestorm") : ansi.dim("mergestorm");
-    return `${name}> `;
+    return loggedIn ? ansi.boldGreen("mergestorm") : ansi.dim("mergestorm");
 }

package/dist/ui/box.d.ts

@@ -0,0 +1,11 @@
+export declare function visibleWidth(str: string): number;
+export interface RoundedBoxOptions {
+    title?: string;
+    padding?: number;
+}
+/**
+ * Frames `lines` in a box sized to the widest visible line (ANSI-aware).
+ * Falls back to ASCII `+ - |` when color is disabled or TERM=dumb, since
+ * box-drawing glyphs can render incorrectly on such terminals.
+ */
+export declare function roundedBox(lines: string[], opts?: RoundedBoxOptions): string[];

package/dist/ui/box.js

@@ -0,0 +1,36 @@
+import { ansi } from "./ansi.js";
+const ANSI_PATTERN = /\[[0-9;]*m/g;
+export function visibleWidth(str) {
+    return str.replace(ANSI_PATTERN, "").length;
+}
+const ROUNDED = { tl: "╭", tr: "╮", bl: "╰", br: "╯", h: "─", v: "│" };
+const ASCII = { tl: "+", tr: "+", bl: "+", br: "+", h: "-", v: "|" };
+function boxChars() {
+    return !ansi.enabled || process.env.TERM === "dumb" ? ASCII : ROUNDED;
+}
+function centerLabel(label, width, fill) {
+    const room = Math.max(0, width - visibleWidth(label));
+    const left = Math.floor(room / 2);
+    const right = room - left;
+    return `${fill.repeat(left)}${label}${fill.repeat(right)}`;
+}
+/**
+ * Frames `lines` in a box sized to the widest visible line (ANSI-aware).
+ * Falls back to ASCII `+ - |` when color is disabled or TERM=dumb, since
+ * box-drawing glyphs can render incorrectly on such terminals.
+ */
+export function roundedBox(lines, opts = {}) {
+    const padding = Math.max(0, opts.padding ?? 1);
+    const chars = boxChars();
+    const title = opts.title ? ` ${opts.title} ` : "";
+    const innerWidth = Math.max(0, ...lines.map(visibleWidth), visibleWidth(title)) + padding * 2;
+    const top = ansi.gray(title
+        ? `${chars.tl}${centerLabel(title, innerWidth, chars.h)}${chars.tr}`
+        : `${chars.tl}${chars.h.repeat(innerWidth)}${chars.tr}`);
+    const bottom = ansi.gray(`${chars.bl}${chars.h.repeat(innerWidth)}${chars.br}`);
+    const body = lines.map((line) => {
+        const gap = Math.max(0, innerWidth - padding - visibleWidth(line));
+        return `${ansi.gray(chars.v)}${" ".repeat(padding)}${line}${" ".repeat(gap)}${ansi.gray(chars.v)}`;
+    });
+    return [top, ...body, bottom];
+}

package/dist/ui/logo.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Pixelated funnel logo, colored by the caller (see banner.ts).
+ * Kept as plain glyphs here so consumers can measure/center it with visibleWidth.
+ */
+export declare const TORNADO_LOGO: string[];

package/dist/ui/logo.js

@@ -0,0 +1,12 @@
+/**
+ * Pixelated funnel logo, colored by the caller (see banner.ts).
+ * Kept as plain glyphs here so consumers can measure/center it with visibleWidth.
+ */
+export const TORNADO_LOGO = [
+    "▟██████████▛",
+    " ▜████████▛",
+    "  ▝▜████▛▘",
+    "    ▜██▛",
+    "     ██",
+    "     ▝▘",
+];

package/dist/ui/prompt.d.ts

@@ -0,0 +1,18 @@
+export interface CommandSpec {
+    name: string;
+    summary: string;
+}
+export interface AskLineOptions {
+    prompt?: string;
+    history?: string[];
+    commands?: CommandSpec[];
+}
+/** Thrown when the user asks to close the prompt (Ctrl+D on an empty line). */
+export declare class PromptClosedError extends Error {
+    constructor();
+}
+/**
+ * Hand-rolled raw-mode line editor: bordered input box, history, and a live
+ * slash-command dropdown. Falls back to plain readline on a non-TTY stream.
+ */
+export declare function askLine(opts: AskLineOptions): Promise<string>;

package/dist/ui/prompt.js

@@ -0,0 +1,220 @@
+import * as readline from "node:readline";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { ansi } from "./ansi.js";
+import { roundedBox, visibleWidth } from "./box.js";
+/** Thrown when the user asks to close the prompt (Ctrl+D on an empty line). */
+export class PromptClosedError extends Error {
+    constructor() {
+        super("prompt closed");
+        this.name = "PromptClosedError";
+    }
+}
+const up = (n) => `[${n}A`;
+const down = (n) => `[${n}B`;
+const col = (n) => `[${n}G`;
+const clearDown = "";
+async function fallbackAskLine(promptLabel) {
+    const rl = createInterface({ input, output, terminal: false });
+    try {
+        return await rl.question(promptLabel ? `${promptLabel}> ` : "> ");
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * Hand-rolled raw-mode line editor: bordered input box, history, and a live
+ * slash-command dropdown. Falls back to plain readline on a non-TTY stream.
+ */
+export async function askLine(opts) {
+    const commands = opts.commands ?? [];
+    const history = opts.history ?? [];
+    if (!input.isTTY || !output.isTTY) {
+        return fallbackAskLine(opts.prompt);
+    }
+    return new Promise((resolve, reject) => {
+        let buffer = "";
+        let cursor = 0;
+        let historyIndex = history.length;
+        let dropdownIndex = 0;
+        let linesDrawn = 0;
+        let finished = false;
+        const wasRaw = Boolean(input.isRaw);
+        readline.emitKeypressEvents(input);
+        input.setRawMode(true);
+        input.resume();
+        // Row (0-based) of the "› buffer" content line among the rows we draw each frame.
+        const inputRow = (opts.prompt ? 1 : 0) + 1;
+        function currentDropdown() {
+            if (!buffer.startsWith("/"))
+                return [];
+            const term = buffer.slice(1).toLowerCase();
+            return commands.filter((c) => c.name.toLowerCase().startsWith(term));
+        }
+        function render() {
+            if (linesDrawn > 0) {
+                output.write(`${up(inputRow)}${clearDown}`);
+            }
+            const rows = [];
+            if (opts.prompt)
+                rows.push(ansi.dim(opts.prompt));
+            rows.push(...roundedBox([`${ansi.green("›")} ${buffer}`], { padding: 1 }));
+            const dropdown = currentDropdown();
+            if (dropdown.length) {
+                if (dropdownIndex >= dropdown.length)
+                    dropdownIndex = dropdown.length - 1;
+                dropdown.forEach((c, i) => {
+                    const label = `  ⁄${c.name.padEnd(12)}${c.summary}`;
+                    rows.push(i === dropdownIndex ? ansi.invert(label) : ansi.gray(label));
+                });
+            }
+            else {
+                dropdownIndex = 0;
+            }
+            output.write(rows.join("\r\n") + "\r\n");
+            linesDrawn = rows.length;
+            const prefixWidth = visibleWidth(`${ansi.green("›")} `);
+            const targetCol = 1 + 1 + prefixWidth + cursor + 1;
+            output.write(`${up(linesDrawn - inputRow)}${col(targetCol)}`);
+        }
+        function cleanup() {
+            input.removeListener("keypress", onKeypress);
+            input.setRawMode(wasRaw);
+            // emitKeypressEvents leaves stdin flowing; pause it so an idle shell
+            // (no command running) doesn't keep the process alive after exit/EOF.
+            input.pause();
+        }
+        function finish(value, err) {
+            if (finished)
+                return;
+            finished = true;
+            cleanup();
+            const rowsBelow = Math.max(0, linesDrawn - inputRow - 1);
+            if (rowsBelow > 0)
+                output.write(down(rowsBelow));
+            output.write("\n");
+            if (err)
+                reject(err);
+            else
+                resolve(value ?? "");
+        }
+        function acceptDropdown(dropdown) {
+            buffer = `/${dropdown[dropdownIndex].name} `;
+            cursor = buffer.length;
+            dropdownIndex = 0;
+        }
+        function onKeypress(str, key) {
+            try {
+                if (finished || !key)
+                    return;
+                const dropdown = currentDropdown();
+                if (key.ctrl && key.name === "c") {
+                    buffer = "";
+                    cursor = 0;
+                    historyIndex = history.length;
+                    render();
+                    return;
+                }
+                if (key.ctrl && key.name === "d") {
+                    if (!buffer)
+                        finish(null, new PromptClosedError());
+                    return;
+                }
+                if (key.name === "return") {
+                    if (dropdown.length)
+                        buffer = `/${dropdown[dropdownIndex].name}`;
+                    finish(buffer);
+                    return;
+                }
+                if (key.name === "tab") {
+                    if (dropdown.length)
+                        acceptDropdown(dropdown);
+                    render();
+                    return;
+                }
+                if (key.name === "right") {
+                    if (dropdown.length)
+                        acceptDropdown(dropdown);
+                    else
+                        cursor = Math.min(buffer.length, cursor + 1);
+                    render();
+                    return;
+                }
+                if (key.name === "left") {
+                    cursor = Math.max(0, cursor - 1);
+                    render();
+                    return;
+                }
+                if (key.name === "up") {
+                    if (dropdown.length) {
+                        dropdownIndex = (dropdownIndex - 1 + dropdown.length) % dropdown.length;
+                    }
+                    else if (history.length) {
+                        historyIndex = Math.max(0, historyIndex - 1);
+                        buffer = history[historyIndex] ?? "";
+                        cursor = buffer.length;
+                    }
+                    render();
+                    return;
+                }
+                if (key.name === "down") {
+                    if (dropdown.length) {
+                        dropdownIndex = (dropdownIndex + 1) % dropdown.length;
+                    }
+                    else if (history.length) {
+                        historyIndex = Math.min(history.length, historyIndex + 1);
+                        buffer = historyIndex >= history.length ? "" : history[historyIndex] ?? "";
+                        cursor = buffer.length;
+                    }
+                    render();
+                    return;
+                }
+                if (key.name === "home" || (key.ctrl && key.name === "a")) {
+                    cursor = 0;
+                    render();
+                    return;
+                }
+                if (key.name === "end" || (key.ctrl && key.name === "e")) {
+                    cursor = buffer.length;
+                    render();
+                    return;
+                }
+                if (key.ctrl && key.name === "u") {
+                    buffer = buffer.slice(cursor);
+                    cursor = 0;
+                    render();
+                    return;
+                }
+                if (key.ctrl && key.name === "k") {
+                    buffer = buffer.slice(0, cursor);
+                    render();
+                    return;
+                }
+                if (key.name === "backspace") {
+                    if (cursor > 0) {
+                        buffer = buffer.slice(0, cursor - 1) + buffer.slice(cursor);
+                        cursor -= 1;
+                    }
+                    render();
+                    return;
+                }
+                if (key.name === "delete") {
+                    buffer = buffer.slice(0, cursor) + buffer.slice(cursor + 1);
+                    render();
+                    return;
+                }
+                if (str && !key.ctrl && !key.meta) {
+                    buffer = buffer.slice(0, cursor) + str + buffer.slice(cursor);
+                    cursor += str.length;
+                    render();
+                }
+            }
+            catch (err) {
+                finish(null, err);
+            }
+        }
+        input.on("keypress", onKeypress);
+        render();
+    });
+}

package/dist/ui/select.d.ts

@@ -0,0 +1,13 @@
+export type SelectOptions<T> = {
+    title?: string;
+    items: T[];
+    render: (item: T, index: number) => string;
+    /** Hint printed under the list (default: arrow/enter/esc keys). */
+    hint?: string;
+};
+/**
+ * Raw-mode arrow-key list selector (Claude-style). Returns the chosen item, or
+ * `null` if cancelled / empty. Non-TTY: prints a numbered list and returns null
+ * (caller should fall back to a table / prompt).
+ */
+export declare function selectFromList<T>(opts: SelectOptions<T>): Promise<T | null>;

package/dist/ui/select.js

@@ -0,0 +1,103 @@
+import * as readline from "node:readline";
+import { stdin as input, stdout as output } from "node:process";
+import { ansi } from "./ansi.js";
+const up = (n) => `\u001b[${n}A`;
+const clearDown = "\u001b[0J";
+/**
+ * Raw-mode arrow-key list selector (Claude-style). Returns the chosen item, or
+ * `null` if cancelled / empty. Non-TTY: prints a numbered list and returns null
+ * (caller should fall back to a table / prompt).
+ */
+export async function selectFromList(opts) {
+    const items = opts.items;
+    if (items.length === 0)
+        return null;
+    if (!input.isTTY || !output.isTTY) {
+        if (opts.title)
+            console.log(ansi.bold(`  ${opts.title}`));
+        items.forEach((item, i) => {
+            console.log(`  ${String(i + 1).padStart(2)}. ${opts.render(item, i)}`);
+        });
+        console.log(ansi.dim(opts.hint ?? "  (non-interactive — use `chain <slug>` or re-run on a TTY to select)"));
+        return null;
+    }
+    return new Promise((resolve) => {
+        let index = 0;
+        let linesDrawn = 0;
+        let finished = false;
+        const wasRaw = Boolean(input.isRaw);
+        readline.emitKeypressEvents(input);
+        input.setRawMode(true);
+        input.resume();
+        function render() {
+            if (linesDrawn > 0) {
+                output.write(`${up(linesDrawn)}${clearDown}`);
+            }
+            const rows = [];
+            if (opts.title)
+                rows.push(ansi.bold(opts.title));
+            items.forEach((item, i) => {
+                const body = opts.render(item, i);
+                const marker = i === index ? ansi.green("›") : " ";
+                const line = ` ${marker} ${body}`;
+                rows.push(i === index ? ansi.invert(line) : line);
+            });
+            rows.push(ansi.dim(opts.hint ?? "↑↓ navigate · enter select · esc cancel"));
+            output.write(rows.join("\r\n") + "\r\n");
+            linesDrawn = rows.length;
+        }
+        function cleanup() {
+            input.removeListener("keypress", onKeypress);
+            input.setRawMode(wasRaw);
+            input.pause();
+        }
+        function finish(value) {
+            if (finished)
+                return;
+            finished = true;
+            cleanup();
+            output.write("\n");
+            resolve(value);
+        }
+        function onKeypress(_str, key) {
+            if (finished || !key)
+                return;
+            if (key.name === "up") {
+                index = (index - 1 + items.length) % items.length;
+                try {
+                    render();
+                }
+                catch {
+                    finish(null);
+                }
+                return;
+            }
+            if (key.name === "down") {
+                index = (index + 1) % items.length;
+                try {
+                    render();
+                }
+                catch {
+                    finish(null);
+                }
+                return;
+            }
+            if (key.name === "return") {
+                finish(items[index]);
+                return;
+            }
+            if (key.name === "escape" ||
+                key.name === "q" ||
+                (key.ctrl && key.name === "c")) {
+                finish(null);
+            }
+        }
+        input.on("keypress", onKeypress);
+        try {
+            render();
+        }
+        catch {
+            finish(null);
+        }
+    });
+}

package/dist/ui/usage.d.ts

@@ -0,0 +1,24 @@
+export type UsageBarOpts = {
+    /** Bar width in cells (default 56 — Claude-length). */
+    width?: number;
+    /** When false, return plain text with no ANSI (default: respect ansi.enabled). */
+    color?: boolean;
+};
+/**
+ * Claude-style usage meter — long thin bar + percent only:
+ *   `[████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 7% used`
+ *
+ * No used/limit clutter. Edge cases:
+ * - `limit === 0` → dim "not included" (premium on non-Maelstrom)
+ * - `limit == null` → "unlimited" (dev-bypass)
+ */
+export declare function usageBar(used: number, limit: number | null | undefined, opts?: UsageBarOpts): string;
+/** Start of the next UTC calendar month (matches API `resets_at`). */
+export declare function nextUtcMonthStart(now?: Date): string;
+/**
+ * Claude-style reset footer: `Resets Aug 1, 12:00am (UTC)`.
+ * Falls back to next UTC month start when `iso` is missing/invalid.
+ */
+export declare function formatResetLabel(iso: string | null | undefined, now?: Date): string;
+/** Alias kept for callers that still import `formatResetDate`. */
+export declare function formatResetDate(iso: string | null | undefined): string;

package/dist/ui/usage.js

@@ -0,0 +1,67 @@
+import { ansi } from "./ansi.js";
+/**
+ * Claude-style usage meter — long thin bar + percent only:
+ *   `[████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 7% used`
+ *
+ * No used/limit clutter. Edge cases:
+ * - `limit === 0` → dim "not included" (premium on non-Maelstrom)
+ * - `limit == null` → "unlimited" (dev-bypass)
+ */
+export function usageBar(used, limit, opts = {}) {
+    const width = Math.max(8, opts.width ?? 56);
+    const color = opts.color ?? ansi.enabled;
+    if (limit == null) {
+        return color ? ansi.dim("unlimited") : "unlimited";
+    }
+    if (limit === 0) {
+        return color ? ansi.dim("not included") : "not included";
+    }
+    const safeUsed = Math.max(0, Number.isFinite(used) ? used : 0);
+    const ratio = Math.min(1, safeUsed / limit);
+    const filled = Math.round(ratio * width);
+    const empty = Math.max(0, width - filled);
+    const pct = Math.min(100, Math.round((safeUsed / limit) * 100));
+    // Filled segment colored; empty + label stay dim — matches Claude's quiet meter.
+    const filledSeg = "█".repeat(filled);
+    const emptySeg = "░".repeat(empty);
+    const suffix = ` ${pct}% used`;
+    if (!color) {
+        return `[${filledSeg}${emptySeg}]${suffix}`;
+    }
+    let fillColor = ansi.green;
+    if (ratio >= 0.9)
+        fillColor = ansi.red;
+    else if (ratio >= 0.75)
+        fillColor = ansi.yellow;
+    return (`[${fillColor(filledSeg)}${ansi.dim(emptySeg)}]` + ansi.dim(suffix));
+}
+/** Start of the next UTC calendar month (matches API `resets_at`). */
+export function nextUtcMonthStart(now = new Date()) {
+    return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth() + 1, 1)).toISOString();
+}
+/**
+ * Claude-style reset footer: `Resets Aug 1, 12:00am (UTC)`.
+ * Falls back to next UTC month start when `iso` is missing/invalid.
+ */
+export function formatResetLabel(iso, now = new Date()) {
+    const d = iso ? new Date(iso) : new Date(nextUtcMonthStart(now));
+    const when = Number.isNaN(d.getTime()) ? new Date(nextUtcMonthStart(now)) : d;
+    const months = [
+        "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+        "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
+    ];
+    const month = months[when.getUTCMonth()];
+    const day = when.getUTCDate();
+    let h = when.getUTCHours();
+    const m = when.getUTCMinutes();
+    const ampm = h >= 12 ? "pm" : "am";
+    h = h % 12;
+    if (h === 0)
+        h = 12;
+    const mm = String(m).padStart(2, "0");
+    return `Resets ${month} ${day}, ${h}:${mm}${ampm} (UTC)`;
+}
+/** Alias kept for callers that still import `formatResetDate`. */
+export function formatResetDate(iso) {
+    return formatResetLabel(iso);
+}