agent-fuel 0.2.0 → 0.4.0

package/dist/adapters/codex.js

@@ -1,105 +1,235 @@
-import { exec } from 'node:child_process';
+import { exec, execFileSync } from 'node:child_process';
 import { promisify } from 'node:util';
+import { readFileSync, unlinkSync } from 'node:fs';
+import { TuiScraper } from '../tmux.js';
+import { debug } from '../debug.js';
 const execAsync = promisify(exec);
-export class CodexQuotaAdapter {
-    budgetLimit;
-    constructor() {
-        // Default budget limit of $20.00 for the rolling 5h window (Standard Team/Plus limit)
-        // Allows dynamic override using environment variable AGENT_FUEL_CODEX_BUDGET
-        this.budgetLimit = Number(process.env.AGENT_FUEL_CODEX_BUDGET) || 20.0;
+// Used ONLY as a rough fallback estimate when the TUI scrape cannot determine
+// a percentage. This is a GUESS based on local session cost data — not an
+// official Codex quota signal. Override with AGENT_FUEL_CODEX_BUDGET env var.
+const DEFAULT_BUDGET_USD = 20.0;
+const ROLLING_WINDOW_MS = 5 * 60 * 60 * 1000;
+// ── TUI scraper (tmux) ─────────────────────────────────────────────────────
+async function sleep(ms) {
+    return new Promise(res => setTimeout(res, ms));
+}
+/**
+ * Launches `codex` in a tmux session, pipes all terminal bytes to a temp
+ * file, sends /status twice, then reads the file and returns the raw bytes.
+ *
+ * Why pipe-pane instead of capture-pane:
+ * The /status overlay is full-screen and transient — it renders in-place for
+ * one frame and re-renders away without entering the tmux scrollback buffer.
+ * capture-pane (even with -S history) can never catch it. pipe-pane streams
+ * every raw byte to a file so even a 10ms overlay is permanently recorded.
+ */
+async function runCodexScrape() {
+    const tui = new TuiScraper('codex');
+    const pipePath = `/tmp/af-codex-${Date.now()}.log`;
+    try {
+        tui.start();
+        // Stream all pane output to a file from the start
+        execFileSync('tmux', ['pipe-pane', '-t', tui.sessionId, `cat >> '${pipePath}'`]);
+        debug('codex:scrape', `pipe-pane logging to ${pipePath}`);
+        // Wait for TUI ready: current screen (historyLines=0) shows Tip, meaning MCP boot done
+        await tui.waitFor(/Tip:/i, 20_000, 0);
+        // First /status: panel says "Limits: refresh requested; run /status again shortly"
+        tui.send('/status');
+        await sleep(2_000);
+        // Second /status: has actual 5h/weekly quota data
+        tui.send('/status');
+        await sleep(4_000);
+        const raw = readFileSync(pipePath, 'utf-8');
+        debug('codex:scrape', `pipe log size: ${raw.length} bytes`);
+        return raw;
+    }
+    finally {
+        tui.kill();
+        try {
+            unlinkSync(pipePath);
+        }
+        catch { /* ok */ }
+    }
+}
+function stripAnsi(str) {
+    // eslint-disable-next-line no-control-regex
+    return str
+        .replace(/\x1B\[[\x20-\x3f]*[\x40-\x7e]/g, '')
+        .replace(/\x1B[^[]/g, '')
+        .replace(/[\x00-\x08\x0b-\x1f\x7f]/g, '');
+}
+function parseScrapeOutput(raw) {
+    // pipe-pane output contains raw ANSI bytes — strip before pattern matching
+    const clean = stripAnsi(raw);
+    debug('codex:parse', `raw length: ${raw.length}, cleaned length: ${clean.length}`);
+    debug('codex:parse', 'cleaned output', clean);
+    debug('codex:parse', 'checking patterns', {
+        hasIndividualQuota: /Individual quota reached/i.test(clean),
+        hasHeadsUp: /less than \d+%\s+of your 5h limit left/i.test(clean),
+        has5hLimit: /5h limit:/i.test(clean),
+        hasWeeklyLimit: /Weekly limit:/i.test(clean),
+        hasLimits: /Limits:/i.test(clean),
+    });
+    // "Individual quota reached. Contact your administrator to enable overages. Resets in 4h33m29s."
+    if (/Individual quota reached/i.test(clean)) {
+        const resetMatch = clean.match(/Resets in\s*((?:\d+h)?(?:\d+m)?(?:\d+s)?)/i);
+        let resetIn = null;
+        if (resetMatch) {
+            const parts = [];
+            const hm = resetMatch[1].match(/^(\d+h)?(\d+m)?/);
+            if (hm) {
+                if (hm[1])
+                    parts.push(hm[1]);
+                if (hm[2])
+                    parts.push(hm[2]);
+            }
+            resetIn = parts.length > 0 ? parts.join(' ') : null;
+        }
+        debug('codex:parse', 'result', { quotaReached: true, resetIn });
+        return { quotaReached: true, resetIn, fiveHourRemainingPct: null, fiveHourResetAt: null };
     }
-    async fetchSnapshot() {
+    // "⚠ Heads up, you have less than X% of your 5h limit left."
+    const headsUpMatch = clean.match(/less than (\d+)%\s+of your 5h limit left/i);
+    if (headsUpMatch) {
+        const ceiling = parseInt(headsUpMatch[1], 10);
+        const fiveHourRemainingPct = Math.max(0, ceiling - 1);
+        debug('codex:parse', 'result', { source: 'headsUp', ceiling, fiveHourRemainingPct });
+        return { quotaReached: false, resetIn: null, fiveHourRemainingPct, fiveHourResetAt: null };
+    }
+    // Parse "/status" panel: "5h limit: [...] X% left (resets HH:MM)"
+    // Use the LAST match — /status is sent twice and the second response is fresh.
+    const allFiveHMatches = [...clean.matchAll(/5h limit:\s*\[.*?\]\s*(\d+)%\s*left\s*\(resets\s+([^)]+)\)/gi)];
+    const fiveHMatch = allFiveHMatches.at(-1) ?? null;
+    const fiveHourRemainingPct = fiveHMatch ? parseInt(fiveHMatch[1], 10) : null;
+    const fiveHourResetAt = fiveHMatch ? fiveHMatch[2].trim() : null;
+    debug('codex:parse', 'result', { quotaReached: false, fiveHourRemainingPct, fiveHourResetAt, fiveHMatchRaw: fiveHMatch?.[0] ?? null });
+    return { quotaReached: false, resetIn: null, fiveHourRemainingPct, fiveHourResetAt };
+}
+// ── ccusage fallback estimate ──────────────────────────────────────────────
+async function fetchCcusageEstimate(budgetLimit) {
+    const unknown = () => ({
+        tool: 'codex',
+        remainingPercent: null,
+        usedPercent: null,
+        resetAt: null,
+        source: 'unknown',
+    });
+    try {
+        let stdout;
         try {
-            // Execute ccusage to get Codex session data
-            let stdout;
+            ({ stdout } = await execAsync('npx --no-install ccusage codex session --json'));
+        }
+        catch {
+            return unknown();
+        }
+        debug('codex:ccusage', 'raw stdout', stdout);
+        const data = JSON.parse(stdout);
+        const sessions = Array.isArray(data?.sessions) ? data.sessions :
+            Array.isArray(data?.session) ? data.session :
+                Array.isArray(data) ? data : [];
+        if (sessions.length === 0) {
+            return { tool: 'codex', remainingPercent: 100, usedPercent: 0, resetAt: null, source: 'ccusage' };
+        }
+        const todayStr = localDateString(new Date());
+        const todaySessions = sessions.filter((s) => {
+            if (typeof s.lastActivity !== 'string')
+                return false;
             try {
-                const result = await execAsync('npx --no-install ccusage codex session --json');
-                stdout = result.stdout;
+                return localDateString(new Date(s.lastActivity)) === todayStr;
             }
             catch {
-                throw new Error('ccusage package is not installed or available locally. Please run "npm install -g ccusage" to use this tool.');
+                return false;
             }
-            const data = JSON.parse(stdout);
-            const sessions = data && Array.isArray(data.sessions) ? data.sessions : (data && Array.isArray(data.session) ? data.session : data);
-            if (!sessions || !Array.isArray(sessions)) {
-                throw new Error('Invalid JSON format returned from ccusage codex session');
+        });
+        if (todaySessions.length === 0) {
+            return { tool: 'codex', remainingPercent: 100, usedPercent: 0, resetAt: null, source: 'ccusage' };
+        }
+        const totalCost = todaySessions.reduce((acc, s) => acc + (typeof s.costUSD === 'number' ? s.costUSD : 0), 0);
+        const usedPct = (totalCost / budgetLimit) * 100;
+        const rawRemaining = 100 - usedPct;
+        const remainingPercent = usedPct > 0 && rawRemaining > 99 ? 99
+            : Math.max(0, Math.min(100, Math.round(rawRemaining)));
+        const latestActivity = todaySessions
+            .map((s) => new Date(s.lastActivity).getTime())
+            .reduce((a, b) => (b > a ? b : a), 0);
+        let resetAt = null;
+        if (latestActivity > 0) {
+            try {
+                resetAt = new Date(latestActivity + ROLLING_WINDOW_MS).toLocaleTimeString([], {
+                    hour: '2-digit', minute: '2-digit',
+                });
             }
-            // Filter sessions for today's date in local time
-            const now = new Date();
-            const year = now.getFullYear();
-            const month = String(now.getMonth() + 1).padStart(2, '0');
-            const day = String(now.getDate()).padStart(2, '0');
-            const todayPrefix = `${year}-${month}-${day}`;
-            const todaySessions = sessions.filter((s) => {
-                if (!s.lastActivity)
-                    return false;
-                try {
-                    const dateObj = new Date(s.lastActivity);
-                    const sYear = dateObj.getFullYear();
-                    const sMonth = String(dateObj.getMonth() + 1).padStart(2, '0');
-                    const sDay = String(dateObj.getDate()).padStart(2, '0');
-                    const sLocalDate = `${sYear}-${sMonth}-${sDay}`;
-                    return sLocalDate === todayPrefix;
-                }
-                catch {
-                    return false;
-                }
-            });
-            if (todaySessions.length === 0) {
-                // No activity today, so 100% fuel remaining
+            catch { /* leave null */ }
+        }
+        debug('codex:ccusage', 'computed', {
+            totalCost,
+            todaySessionsCount: todaySessions.length,
+            budgetLimit,
+            usedPct,
+            remainingPercent,
+            resetAt,
+        });
+        return {
+            tool: 'codex',
+            remainingPercent,
+            usedPercent: Math.round(usedPct),
+            resetAt,
+            source: 'ccusage',
+            raw: { totalCost, todaySessionsCount: todaySessions.length, isEstimate: true },
+        };
+    }
+    catch {
+        return unknown();
+    }
+}
+// ── Adapter ────────────────────────────────────────────────────────────────
+export class CodexQuotaAdapter {
+    budgetLimit;
+    constructor() {
+        const override = Number(process.env.AGENT_FUEL_CODEX_BUDGET);
+        this.budgetLimit = Number.isFinite(override) && override > 0 ? override : DEFAULT_BUDGET_USD;
+    }
+    async fetchSnapshots() {
+        return [await this._fetch()];
+    }
+    async _fetch() {
+        debug('codex:fetch', 'starting TUI scrape via tmux');
+        try {
+            const raw = await runCodexScrape();
+            const result = parseScrapeOutput(raw);
+            if (result.quotaReached) {
+                const resetAt = result.resetIn ? `Resets in ${result.resetIn}` : null;
+                debug('codex:fetch', 'quota reached → returning 0%');
                 return {
                     tool: 'codex',
-                    remainingPercent: 100,
-                    usedPercent: 0,
-                    resetAt: null,
-                    source: 'ccusage'
+                    remainingPercent: 0,
+                    usedPercent: 100,
+                    resetAt,
+                    source: 'official-cli',
                 };
             }
-            // Sum today's cost
-            const totalCost = todaySessions.reduce((acc, s) => acc + (s.costUSD || 0.0), 0.0);
-            const usedPercent = (totalCost / this.budgetLimit) * 100;
-            // Calculate remaining percentage
-            let remainingPercent = 100 - usedPercent;
-            if (usedPercent > 0 && remainingPercent > 99) {
-                // Micro-interaction: if they burned any credits, show 99% instead of rounding to 100%
-                remainingPercent = 99;
-            }
-            else {
-                remainingPercent = Math.max(0, Math.min(100, Math.round(remainingPercent)));
-            }
-            // Calculate rolling 5-hour reset time based on the most recent session's activity
-            let resetAt = null;
-            const sortedSessions = [...todaySessions].sort((a, b) => new Date(b.lastActivity).getTime() - new Date(a.lastActivity).getTime());
-            const latestSession = sortedSessions[0];
-            if (latestSession && latestSession.lastActivity) {
-                try {
-                    const lastActivityDate = new Date(latestSession.lastActivity);
-                    // Roll forward 5 hours for the rolling limit window
-                    const resetDate = new Date(lastActivityDate.getTime() + 5 * 60 * 60 * 1000);
-                    resetAt = resetDate.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
-                }
-                catch {
-                    resetAt = null;
-                }
+            if (result.fiveHourRemainingPct !== null) {
+                debug('codex:fetch', `parsed /status → ${result.fiveHourRemainingPct}% remaining`);
+                return {
+                    tool: 'codex',
+                    remainingPercent: result.fiveHourRemainingPct,
+                    usedPercent: 100 - result.fiveHourRemainingPct,
+                    resetAt: result.fiveHourResetAt,
+                    source: 'official-cli',
+                };
             }
-            return {
-                tool: 'codex',
-                remainingPercent,
-                usedPercent: Math.round(usedPercent),
-                resetAt,
-                source: 'ccusage',
-                raw: { totalCost, todaySessionsCount: todaySessions.length }
-            };
+            debug('codex:fetch', '/status parse failed → falling back to ccusage estimate');
+            return fetchCcusageEstimate(this.budgetLimit);
         }
-        catch (error) {
-            return {
-                tool: 'codex',
-                remainingPercent: null,
-                usedPercent: null,
-                resetAt: null,
-                source: 'unknown',
-                raw: error instanceof Error ? error.message : String(error)
-            };
+        catch (err) {
+            debug('codex:fetch', 'caught error, falling back to ccusage', String(err));
+            return fetchCcusageEstimate(this.budgetLimit);
         }
     }
 }
+function localDateString(date) {
+    const y = date.getFullYear();
+    const m = String(date.getMonth() + 1).padStart(2, '0');
+    const d = String(date.getDate()).padStart(2, '0');
+    return `${y}-${m}-${d}`;
+}

package/dist/adapters/index.d.ts

@@ -1,11 +1,12 @@
 export interface UsageSnapshot {
-    tool: 'codex' | 'claude-code' | 'agy';
+    tool: 'codex' | 'claude-code' | 'agy-gemini' | 'agy-other';
     remainingPercent: number | null;
     usedPercent?: number | null;
     resetAt?: string | null;
-    source: 'official-cli' | 'ccusage' | 'local-state' | 'provider-api' | 'unknown';
+    source: 'official-cli' | 'ccusage' | 'local-state' | 'provider-api' | 'cache' | 'unknown';
     raw?: unknown;
 }
 export interface QuotaAdapter {
-    fetchSnapshot(): Promise<UsageSnapshot>;
+    /** Returns one or more snapshots (adapters that produce multiple rows return an array). */
+    fetchSnapshots(): Promise<UsageSnapshot[]>;
 }

package/dist/debug.d.ts

@@ -0,0 +1,4 @@
+declare const enabled: boolean;
+declare const logFile: string | null;
+export declare function debug(tag: string, message: string, data?: unknown): void;
+export { enabled as debugEnabled, logFile as debugLogFile };

package/dist/debug.js

@@ -0,0 +1,18 @@
+import { appendFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+const enabled = process.argv.includes('--debug');
+const logFile = enabled
+    ? (() => {
+        const dir = join(process.cwd(), '.logs');
+        mkdirSync(dir, { recursive: true });
+        const ts = new Date().toISOString().replace(/[:.]/g, '-');
+        return join(dir, `debug-${ts}.log`);
+    })()
+    : null;
+export function debug(tag, message, data) {
+    if (!logFile)
+        return;
+    const line = `[${new Date().toISOString()}] [${tag}] ${message}${data !== undefined ? '\n' + JSON.stringify(data, null, 2) : ''}\n`;
+    appendFileSync(logFile, line);
+}
+export { enabled as debugEnabled, logFile as debugLogFile };

package/dist/index.js

@@ -1,29 +1,81 @@
 #!/usr/bin/env node
+import { debugEnabled, debugLogFile } from './debug.js';
 import { ClaudeQuotaAdapter } from './adapters/claude.js';
 import { CodexQuotaAdapter } from './adapters/codex.js';
 import { AgyQuotaAdapter } from './adapters/agy.js';
-import { renderDashboard } from './render.js';
+import { printHeader, printFooter, formatRow, getDisplayName } from './render.js';
+// Fixed display order — never changes regardless of which adapter resolves first
+const SLOT_ORDER = ['claude-code', 'codex', 'agy-gemini', 'agy-other'];
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const R = '\x1b[0m';
+const GRAY = '\x1b[90m';
+const isTTY = Boolean(process.stdout.isTTY);
+const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+let spinnerTick = 0;
+function spinnerLine(tool) {
+    const frame = SPINNER[spinnerTick % SPINNER.length];
+    return `${BOLD}${getDisplayName(tool).padEnd(13)}${R} ${DIM}${GRAY}${frame} loading...${R}\x1b[K`;
+}
+// In TTY mode: restore cursor to saved position and repaint all slots.
+// In pipe mode: emit each newly-resolved line exactly once (tracked via emitted set).
+function redraw(slots, emitted) {
+    if (!isTTY) {
+        for (const tool of SLOT_ORDER) {
+            const line = slots.get(tool);
+            if (line != null && !emitted.has(tool)) {
+                process.stdout.write(line + '\n');
+                emitted.add(tool);
+            }
+        }
+        return;
+    }
+    process.stdout.write('\x1b8'); // DEC restore-cursor — teleports back to saved position
+    for (const tool of SLOT_ORDER) {
+        process.stdout.write('\x1b[2K\r');
+        const line = slots.get(tool);
+        process.stdout.write((line != null ? line + '\x1b[K' : spinnerLine(tool)) + '\n');
+    }
+}
 async function main() {
     const claudeAdapter = new ClaudeQuotaAdapter();
     const codexAdapter = new CodexQuotaAdapter();
     const agyAdapter = new AgyQuotaAdapter();
-    try {
-        // Run all adapters concurrently to minimize startup latency
-        const [claudeSnap, codexSnap, agySnap] = await Promise.all([
-            claudeAdapter.fetchSnapshot(),
-            codexAdapter.fetchSnapshot(),
-            agyAdapter.fetchSnapshot()
-        ]);
-        // Render the beautiful 3-bar ASCII progress dashboard
-        renderDashboard([
-            codexSnap,
-            claudeSnap,
-            agySnap
-        ]);
+    if (debugEnabled)
+        process.stderr.write(`\x1b[2m[debug] logging to ${debugLogFile}\x1b[0m\n`);
+    printHeader();
+    // Save cursor before the placeholder rows so redraw() can teleport back and overwrite them
+    const slots = new Map(SLOT_ORDER.map(t => [t, null]));
+    const emitted = new Set(); // pipe-mode: tracks which lines have been printed
+    if (isTTY)
+        process.stdout.write('\x1b7'); // DEC save-cursor
+    for (const tool of SLOT_ORDER) {
+        process.stdout.write(spinnerLine(tool) + '\n');
     }
-    catch (error) {
-        console.error('\x1b[31mFatal error orchestrating Agent Fuel CLI:\x1b[0m', error);
-        process.exit(1);
+    // Animate spinner at 80ms while any slot is still loading
+    const spinnerTimer = isTTY
+        ? setInterval(() => { spinnerTick++; redraw(slots, emitted); }, 80)
+        : null;
+    // Each adapter fills its slot(s) and triggers a redraw; order is always fixed
+    function fill(snaps) {
+        for (const snap of snaps) {
+            if (SLOT_ORDER.includes(snap.tool)) {
+                slots.set(snap.tool, formatRow(snap));
+            }
+        }
+        redraw(slots, emitted);
     }
+    await Promise.allSettled([
+        claudeAdapter.fetchSnapshots().then(fill),
+        codexAdapter.fetchSnapshots().then(fill),
+        agyAdapter.fetchSnapshots().then(fill),
+    ]);
+    if (spinnerTimer)
+        clearInterval(spinnerTimer);
+    redraw(slots, emitted); // final clean repaint with all data
+    printFooter();
 }
-main();
+main().catch((error) => {
+    console.error('\x1b[31mFatal error orchestrating Agent Fuel CLI:\x1b[0m', error);
+    process.exit(1);
+});

package/dist/render.d.ts

@@ -1,2 +1,9 @@
 import { UsageSnapshot } from './adapters/index.js';
+export declare function getDisplayName(tool: string): string;
+export declare function formatRow(snap: UsageSnapshot): string;
+export declare function printHeader(): void;
+export declare function printRow(snap: UsageSnapshot): void;
+export declare function printFooter(): void;
+export declare const LOADING_LINE = "\u001B[2m\u001B[90mloading...\u001B[0m";
+/** Convenience wrapper — renders a full static dashboard in one call. */
 export declare function renderDashboard(snapshots: UsageSnapshot[]): void;

package/dist/render.js

@@ -1,74 +1,111 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-export function renderDashboard(snapshots) {
-    const reset = '\x1b[0m';
-    const bold = '\x1b[1m';
-    const dim = '\x1b[2m';
-    const cyan = '\x1b[36m';
-    const green = '\x1b[32m';
-    const yellow = '\x1b[33m';
-    const red = '\x1b[31m';
-    const gray = '\x1b[90m';
-    // Load version from package.json dynamically
-    let versionStr = '';
+// ── Constants ──────────────────────────────────────────────────────────────
+const BLOCK_CHAR = '█';
+const SHADE_CHAR = '░';
+const BAR_WIDTH = 30;
+// ── ANSI colour helpers ────────────────────────────────────────────────────
+const R = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const CYAN = '\x1b[36m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+const GRAY = '\x1b[90m';
+// ── Helpers ────────────────────────────────────────────────────────────────
+export function getDisplayName(tool) {
+    switch (tool) {
+        case 'codex': return 'Codex';
+        case 'claude-code': return 'Claude Code';
+        case 'agy-gemini': return 'AGY Gemini';
+        case 'agy-other': return 'AGY Other';
+        default: return tool;
+    }
+}
+function pickColour(remaining) {
+    if (remaining < 20)
+        return RED;
+    if (remaining < 50)
+        return YELLOW;
+    return GREEN;
+}
+function loadVersion() {
     try {
-        const __dirname = path.dirname(fileURLToPath(import.meta.url));
-        const packageJson = JSON.parse(fs.readFileSync(path.join(__dirname, '../package.json'), 'utf8'));
-        versionStr = ` v${packageJson.version}`;
+        const dir = path.dirname(fileURLToPath(import.meta.url));
+        const pkg = JSON.parse(fs.readFileSync(path.join(dir, '../package.json'), 'utf8'));
+        return ` v${pkg.version}`;
     }
     catch {
-        // Fallback if reading package.json fails
+        return '';
     }
-    console.log(`\n${bold}${cyan}⚡️ Agent Fuel - CLI Quota Monitor${reset}\n`);
-    for (const snap of snapshots) {
-        const displayName = getDisplayName(snap.tool);
-        const remaining = snap.remainingPercent;
-        const width = 30;
-        let barStr = '';
-        let percentStr = '';
-        if (remaining === null || remaining === undefined) {
-            // Unknown/Unconfigured quota
-            barStr = `${gray}${'░'.repeat(width)}${reset}`;
-            percentStr = `${gray}unknown${reset}`;
-        }
-        else {
-            const filled = Math.max(0, Math.min(width, Math.round((remaining * width) / 100)));
-            const empty = width - filled;
-            // Color scheme based on remaining percentage
-            let color = green;
-            if (remaining < 20) {
-                color = red;
-            }
-            else if (remaining < 50) {
-                color = yellow;
-            }
-            const blockChar = '█';
-            const shadeChar = '░';
-            barStr = `${color}${blockChar.repeat(filled)}${reset}${gray}${shadeChar.repeat(empty)}${reset}`;
-            percentStr = `${bold}${color}${remaining.toString().padStart(3)}% remaining${reset}`;
-        }
-        // Add metadata/reset times if available
-        let detailStr = '';
-        if (snap.resetAt) {
-            detailStr = ` ${dim}${gray}(resets ${snap.resetAt})${reset}`;
-        }
-        if (snap.tool === 'agy' && snap.raw && typeof snap.raw === 'object' && 'activeModel' in snap.raw) {
-            detailStr += ` ${dim}${gray}[${snap.raw.activeModel}]${reset}`;
-        }
-        console.log(`${bold}${displayName.padEnd(12)}${reset} [${barStr}] ${percentStr}${detailStr}`);
+}
+function formatResetAt(resetAt) {
+    if (resetAt.toLowerCase().includes('available')) {
+        return `${DIM}${GREEN}✓ quota available${R}`;
+    }
+    const codexMatch = resetAt.match(/^Resets in\s*(.+)/i);
+    if (codexMatch) {
+        return `${DIM}${GRAY}(resets in ${codexMatch[1]})${R}`;
+    }
+    const agyMatch = resetAt.match(/^Refreshes in\s*(.+)/i);
+    if (agyMatch) {
+        return `${DIM}${GRAY}(resets in ${agyMatch[1]})${R}`;
     }
-    console.log(`\n${dim}${gray}agent-fuel${versionStr}${reset}\n`);
+    return `${DIM}${GRAY}(resets ${resetAt})${R}`;
 }
-function getDisplayName(tool) {
-    switch (tool) {
-        case 'codex':
-            return 'Codex';
-        case 'claude-code':
-            return 'Claude Code';
-        case 'agy':
-            return 'AGY';
-        default:
-            return tool;
+function isEstimate(snap) {
+    return snap.source === 'ccusage';
+}
+// ── Core format (returns string, no newline) ───────────────────────────────
+export function formatRow(snap) {
+    const displayName = getDisplayName(snap.tool);
+    const remaining = snap.remainingPercent;
+    let barStr;
+    let percentStr;
+    if (remaining === null) {
+        barStr = `${GRAY}${SHADE_CHAR.repeat(BAR_WIDTH)}${R}`;
+        percentStr = `${GRAY}unknown${R}`;
+    }
+    else {
+        const colour = pickColour(remaining);
+        const filled = Math.max(0, Math.min(BAR_WIDTH, Math.round((remaining * BAR_WIDTH) / 100)));
+        const empty = BAR_WIDTH - filled;
+        barStr = `${colour}${BLOCK_CHAR.repeat(filled)}${R}${GRAY}${SHADE_CHAR.repeat(empty)}${R}`;
+        percentStr = `${BOLD}${colour}${remaining.toString().padStart(3)}% remaining${R}`;
+    }
+    const parts = [];
+    if (snap.resetAt)
+        parts.push(formatResetAt(snap.resetAt));
+    if ((snap.tool === 'agy-gemini' || snap.tool === 'agy-other') &&
+        snap.raw && typeof snap.raw === 'object') {
+        const label = snap.raw.matchedModel;
+        if (typeof label === 'string' && label) {
+            parts.push(`${DIM}${GRAY}[${label}]${R}`);
+        }
+    }
+    if (isEstimate(snap)) {
+        parts.push(`${DIM}${GRAY}[~est]${R}`);
     }
+    const detailStr = parts.length > 0 ? ` ${parts.join(' ')}` : '';
+    return `${BOLD}${displayName.padEnd(13)}${R} [${barStr}] ${percentStr}${detailStr}`;
+}
+// ── Public render functions ────────────────────────────────────────────────
+export function printHeader() {
+    console.log(`\n${BOLD}${CYAN}⚡️ Agent Fuel - CLI Quota Monitor${R}\n`);
+}
+export function printRow(snap) {
+    process.stdout.write(formatRow(snap) + '\n');
+}
+export function printFooter() {
+    console.log(`\n${DIM}${GRAY}agent-fuel${loadVersion()}${R}\n`);
+}
+export const LOADING_LINE = `${DIM}${GRAY}loading...${R}`;
+/** Convenience wrapper — renders a full static dashboard in one call. */
+export function renderDashboard(snapshots) {
+    printHeader();
+    for (const snap of snapshots)
+        printRow(snap);
+    printFooter();
 }