agent-fuel 0.1.0 → 0.3.0

package/README.md

@@ -4,82 +4,125 @@ A sleek, unified CLI dashboard to monitor your AI coding assistant quotas, credi
 
 ---
 
-## 🚀 Quick Start
+## 🚀 Installation & Running
 
-Get **Agent Fuel** installed, globally linked, and running on your system with a single one-liner command:
+Install **Agent Fuel** globally:
 
 ```bash
-npm install && npm run build && npm link && agent-fuel
+npm install -g agent-fuel
 ```
 
-Once globally linked, you can run the dashboard at any time from **any directory** on your machine by simply typing:
+Then run from any directory:
 
 ```bash
 agent-fuel
 ```
 
+### Development Setup
+
+```bash
+git clone https://github.com/jperod/agent-fuel.git
+cd agent-fuel
+npm install
+npm run build
+npm link
+```
+
 ---
 
 ## 💡 The Motivation
 
-AI coding assistants are now integral to developer workflows. Tools like **Claude Code**, **Codex CLI**, and **AGY (Google Antigravity CLI)** supercharge productivity but operate under tight, separate quota bounds. Whether it is a daily dollar limit, token ceilings, or monthly credits, developers are forced to jump through interactive prompts or scrape configuration screens just to answer a simple question:
+AI coding assistants are now integral to developer workflows. Tools like **Claude Code**, **Codex CLI**, and **AGY (Google Antigravity CLI)** supercharge productivity but operate under tight, separate quota bounds. Developers are forced to jump through interactive prompts or scrape configuration screens just to answer:
 
 > **"How much agent fuel do I have left before starting this massive refactor?"**
 
-Because each CLI exposes quota information differently (some via strict JSON, others through human-readable prompts, and some in local state files), there is no centralized way to monitor your resource consumption. 
-
-**Agent Fuel** solves this by acting as a lightweight, adapter-based abstraction layer that normalizes all coding agent quotas into a single metric: **Percent Remaining**.
+**Agent Fuel** solves this by acting as a lightweight, adapter-based abstraction layer that normalises all coding agent quotas into a single metric: **Percent Remaining**.
 
 ---
 
-## 🎯 The Idea
+## 🎯 How It Works
 
-`agent-fuel` is a tiny, modern local CLI built with TypeScript that:
-1. **Dispatches Adapters**: Queries each configured AI coding tool (Claude Code, Codex, AGY) using native CLI calls, helper utilities (like `ccusage`), or local config parsing.
-2. **Normalizes Quota Models**: Standardizes diverse limits into a uniform percentage score (`0` to `100%`).
-3. **Renders an Elegant CLI Dashboard**: Displays a high-fidelity 3-bar ASCII progress dashboard directly in your terminal.
+`agent-fuel` is a tiny modern CLI built with TypeScript that:
 
-### Proposed Architecture
+1. **Dispatches Adapters concurrently** — all adapters run in parallel and each row is printed the moment its adapter resolves; you never wait for the slowest tool.
+2. **Normalises Quota Models** — standardises diverse limits into a uniform `0–100%` score.
+3. **Scrapes TUI output directly** — Codex and AGY quotas are read by spawning the real CLIs via `expect` and parsing terminal output, so the numbers match what the tools themselves show.
+4. **Caches AGY results** — AGY quota is cached for 5 minutes so repeated runs are instant (~1s).
+5. **Renders a clean dashboard** — colour-coded bars with reset times directly in your terminal.
+
+### Project Architecture
 
 ```text
 agent-fuel/
   ├── src/
-  │   ├── index.ts          # CLI entry point
-  │   ├── render.ts         # Beautiful 3-bar dashboard renderer
+  │   ├── index.ts            # CLI entry point — runs all adapters concurrently
+  │   ├── render.ts           # Colour-coded bar dashboard renderer
   │   └── adapters/
-  │       ├── claude.ts     # Adapter for Claude Code (ccusage/native)
-  │       ├── codex.ts      # Adapter for Codex (local session/status)
-  │       ├── agy.ts        # Adapter for AGY (Antigravity config parser)
-  │       └── ccusage.ts    # Shared JSON parser helper
+  │       ├── index.ts        # Shared UsageSnapshot type & QuotaAdapter interface
+  │       ├── claude.ts       # Claude Code (via ccusage blocks)
+  │       ├── codex.ts        # Codex CLI (expect TUI scrape; ccusage as fallback estimate)
+  │       └── agy.ts          # AGY — split into Gemini + Other buckets
   ├── package.json
   └── README.md
 ```
 
-### High-Fidelity API Type Shape
+### Type Shape
 
 ```typescript
 type UsageSnapshot = {
-  tool: 'codex' | 'claude-code' | 'agy';
-  remainingPercent: number | null; // Unified 0-100 scale
+  tool: 'codex' | 'claude-code' | 'agy-gemini' | 'agy-other';
+  remainingPercent: number | null;   // Unified 0–100 scale
   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;
 };
 ```
 
 ---
 
-## 📊 Terminal Dashboard Preview
-
-Running `agent-fuel` will immediately output a clean, colored visual summary of your current agent capacity:
+## 📊 Terminal Dashboard
 
-```text
+```
 ⚡️ Agent Fuel - CLI Quota Monitor
 
-Codex        [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] unknown
-Claude Code  [██████████████████████████░░░░]  86% remaining (resets 01:00 PM)
-AGY          [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] unknown
+Claude Code   [███████████████████░░░░░░░░░░░]  64% remaining (resets 01:00 PM)
+Codex         [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░]   0% remaining (resets in 4h 33m)
+AGY Gemini    [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░]   0% remaining (resets in 3h 16m) [Gemini 3.5 Flash (Medium)]
+AGY Other     [██████████████████░░░░░░░░░░░░]  60% remaining (resets in 4h 47m) [Claude Sonnet 4.6 (Thinking)]
+
+agent-fuel v0.3.0
 ```
 
+Rows appear as each adapter resolves — Claude Code (instant) prints first, Codex and AGY follow as their TUI scrapes complete.
+
+**AGY Gemini** shows the worst-case remaining across all `Gemini *` model tiers.  
+**AGY Other** shows the worst-case across Claude and other non-Gemini models.  
+**Codex** row tagged `[~est]` when quota has not been reached and the percentage is estimated from local session cost data (see fallback note below).
+
+---
+
+## ⚙️ Environment Overrides
+
+| Variable | Default | Description |
+|---|---|---|
+| `AGENT_FUEL_CLAUDE_BUDGET` | `20.0` | Claude Code rolling budget in USD |
+| `AGENT_FUEL_CODEX_BUDGET` | `20.0` | **Fallback estimate only** — Codex rolling budget in USD |
+
+> **Note on `AGENT_FUEL_CODEX_BUDGET`:** Codex quota is read directly from the Codex TUI via `expect` scraping. This variable is only used as a rough fallback estimate (shown as `[~est]`) when the TUI reports no quota warning and a percentage cannot be determined. It is a guess based on local session cost data — not an official Codex quota signal. The TUI scrape is always preferred.
+
+---
+
+## 📦 Changelog
+
+### v0.3.0
+- **Codex TUI scrape**: replaced inaccurate `ccusage` cost estimate with an `expect` wrapper that reads the real Codex quota warning (`"Individual quota reached. Resets in Xh Ym"`) — same pattern as AGY. `ccusage` kept as a labelled `[~est]` fallback when quota has not yet been exhausted.
+- **Streaming render with fixed order**: placeholder rows print immediately; each bar overwrites in-place as its adapter resolves. Row order is always `Claude Code → Codex → AGY Gemini → AGY Other`.
+- **AGY split view**: Gemini and non-Gemini (Claude, etc.) quota buckets shown as separate rows
+- **5-minute disk cache** for AGY quota — repeated runs complete in ~1s instead of ~20s
+- Output size cap, typed `any` removal, env validation hardening
 
+### v0.2.x
+- AGY quota now scraped live from `agy /usage` panel via `expect` wrapper (zero token cost)
+- Claude Code budget corrected to $20 rolling limit
+- Replaced token-consuming `claude -p` calls with offline `ccusage` scraping

package/dist/adapters/agy.d.ts

@@ -1,6 +1,4 @@
 import { QuotaAdapter, UsageSnapshot } from './index.js';
 export declare class AgyQuotaAdapter implements QuotaAdapter {
-    private configDir;
-    constructor();
-    fetchSnapshot(): Promise<UsageSnapshot>;
+    fetchSnapshots(): Promise<UsageSnapshot[]>;
 }

package/dist/adapters/agy.js

@@ -1,108 +1,199 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
-export class AgyQuotaAdapter {
-    configDir;
-    constructor() {
-        // Default to the standard AGY CLI config directory
-        this.configDir = path.join(os.homedir(), '.gemini/antigravity-cli');
-    }
-    async fetchSnapshot() {
-        try {
-            const settingsPath = path.join(this.configDir, 'settings.json');
-            const historyPath = path.join(this.configDir, 'history.jsonl');
-            let activeModel = 'Gemini 3.5 Flash';
-            // 1. Read active model from settings.json if it exists
-            try {
-                const settingsContent = await fs.readFile(settingsPath, 'utf-8');
-                const settings = JSON.parse(settingsContent);
-                if (settings && settings.model) {
-                    activeModel = settings.model;
-                }
-            }
-            catch {
-                // Fallback to default model name if reading or parsing settings failed
+import { spawn } from 'node:child_process';
+const CACHE_PATH = path.join(os.homedir(), '.gemini/antigravity-cli/.agent-fuel-quota-cache.json');
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+// ── ANSI / terminal helpers ────────────────────────────────────────────────
+function stripAnsi(str) {
+    // eslint-disable-next-line no-control-regex
+    return str.replace(/\x1B\[[0-9;]*[A-Za-z]|\x1B[^[]/g, '').replace(/[\x00-\x08\x0b-\x1f\x7f]/g, '');
+}
+// ── Scraping ───────────────────────────────────────────────────────────────
+/**
+ * Spawns `agy` via `expect`, opens the `/usage` panel, waits for the
+ * Model Quota list to render, then exits.
+ */
+function runAgyUsage() {
+    return new Promise((resolve) => {
+        const expectScript = [
+            'set timeout 20',
+            'spawn agy',
+            'expect -re "for shortcuts"',
+            'send "/usage\\r"',
+            'expect -re "Model Quota"',
+            'after 800',
+            'send "\\x03"',
+            'expect eof',
+        ].join('\n');
+        // Cap output to avoid unbounded memory growth if agy misbehaves
+        const MAX_OUTPUT_BYTES = 64 * 1024; // 64 KB — far more than the quota panel needs
+        let output = '';
+        // Spread process.env so `expect` can locate `agy` via PATH and the
+        // keyring daemon can be reached via the existing session environment.
+        const child = spawn('expect', ['-c', expectScript], {
+            env: { ...process.env },
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const append = (chunk) => {
+            if (output.length < MAX_OUTPUT_BYTES) {
+                output += chunk.toString();
             }
-            // 2. Read history.jsonl to detect active prompts today
-            let todayPromptsCount = 0;
-            let latestPromptTimestamp = null;
-            // Construct local todayPrefix in YYYY-MM-DD format (timezone aware)
-            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}`;
-            try {
-                const historyContent = await fs.readFile(historyPath, 'utf-8');
-                const historyLines = historyContent.trim().split('\n');
-                for (const line of historyLines) {
-                    if (!line.trim())
-                        continue;
-                    const entry = JSON.parse(line);
-                    if (entry && entry.timestamp) {
-                        // Get local date YYYY-MM-DD for the entry's timestamp
-                        const entryDateObj = new Date(entry.timestamp);
-                        const eYear = entryDateObj.getFullYear();
-                        const eMonth = String(entryDateObj.getMonth() + 1).padStart(2, '0');
-                        const eDay = String(entryDateObj.getDate()).padStart(2, '0');
-                        const entryDate = `${eYear}-${eMonth}-${eDay}`;
-                        if (entryDate === todayPrefix) {
-                            todayPromptsCount++;
-                            if (!latestPromptTimestamp || entry.timestamp > latestPromptTimestamp) {
-                                latestPromptTimestamp = entry.timestamp;
-                            }
-                        }
-                    }
+        };
+        child.stdout.on('data', append);
+        child.stderr.on('data', append);
+        const timer = setTimeout(() => { child.kill('SIGKILL'); resolve(output); }, 25_000);
+        child.on('close', () => { clearTimeout(timer); resolve(output); });
+    });
+}
+// ── Parsing ────────────────────────────────────────────────────────────────
+/**
+ * Parse the Model Quota panel into an array of entries.
+ *
+ * Panel format (after ANSI strip):
+ *
+ *   └ Model Quota
+ *
+ *     Gemini 3.5 Flash (High)
+ *     ░░░░░░░░░░░ ... 20%
+ *     Refreshes in 3h 28m           ← or "80% remaining · Refreshes in …"
+ *
+ *     Claude Sonnet 4.6 (Thinking)
+ *     ███████████ ... 100%
+ *     Quota available
+ */
+function parseQuotaPanel(raw) {
+    const clean = stripAnsi(raw);
+    const lines = clean.split(/\r?\n/);
+    const results = [];
+    const headerIdx = lines.findIndex(l => l.includes('Model Quota'));
+    if (headerIdx === -1)
+        return results;
+    const panelLines = lines.slice(headerIdx + 1);
+    let i = 0;
+    while (i < panelLines.length) {
+        const line = panelLines[i].trim();
+        const isModelName = line.length > 0 &&
+            !line.startsWith('░') && !line.startsWith('█') &&
+            !line.startsWith('↑') && !line.startsWith('(') &&
+            !line.startsWith('┘') && !line.startsWith('└') &&
+            !line.startsWith('?') && !line.startsWith('esc') &&
+            !/^\d+%/.test(line) &&
+            !line.includes('Refreshes') && !line.includes('Quota available') &&
+            !line.includes('──');
+        if (isModelName) {
+            let barLine = null;
+            let refreshLine = null;
+            let j = i + 1;
+            while (j < panelLines.length) {
+                const candidate = panelLines[j].trim();
+                if (candidate.length === 0) {
+                    j++;
+                    continue;
                 }
-            }
-            catch {
-                // Fallback if reading or parsing history failed (e.g. file doesn't exist)
-            }
-            // 3. Calculate remaining percent based on active usage and model tier
-            // Support dynamic overrides using AGENT_FUEL_AGY_PERCENT environment variable
-            let remainingPercent = 100;
-            const isProModel = activeModel.toLowerCase().includes('pro');
-            const limit = isProModel ? 3 : 5; // Pro models have a tighter limit of 3, Flash has 5
-            const costPerPrompt = 100 / limit;
-            const calculatedPercent = Math.max(0, Math.round(100 - (todayPromptsCount * costPerPrompt)));
-            if (process.env.AGENT_FUEL_AGY_PERCENT) {
-                const envVal = Number(process.env.AGENT_FUEL_AGY_PERCENT);
-                remainingPercent = !isNaN(envVal) ? Math.max(0, Math.min(100, envVal)) : calculatedPercent;
-            }
-            else {
-                remainingPercent = calculatedPercent;
-            }
-            // 4. Calculate rolling reset time (5 hours rolling or resets in 4h 37m from latest prompt, giving ~01:30 PM resets)
-            let resetAt = null;
-            if (latestPromptTimestamp) {
-                try {
-                    const lastActivityDate = new Date(latestPromptTimestamp);
-                    // Roll forward 5 hours (refreshes in ~4h 37m from active run)
-                    const resetDate = new Date(lastActivityDate.getTime() + 5 * 60 * 60 * 1000);
-                    resetAt = resetDate.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+                // Progress bar line: has block chars OR starts with a digit%
+                if (barLine === null && (candidate.includes('░') || candidate.includes('█') || /^\d+%/.test(candidate))) {
+                    barLine = candidate;
+                    j++;
+                    continue;
                 }
-                catch {
-                    resetAt = null;
+                // Refresh / availability line
+                if (barLine !== null && (candidate.includes('Refreshes') || candidate.includes('Quota available'))) {
+                    // Strip any leading "NN% remaining · " prefix
+                    const m = candidate.match(/(Refreshes in [^\r\n]+|Quota available)/);
+                    refreshLine = m ? m[1] : candidate;
+                    j++;
                 }
+                break;
+            }
+            if (barLine !== null) {
+                // Percentage is always at the END of the bar line: "░░░ ... 20%" or "20% remaining · …"
+                const percentMatch = barLine.match(/(\d+)%/);
+                if (percentMatch) {
+                    results.push({ model: line, percent: parseInt(percentMatch[1], 10), refreshLine });
+                }
+            }
+            i = j;
+        }
+        else {
+            i++;
+        }
+    }
+    return results;
+}
+// ── Cache helpers ──────────────────────────────────────────────────────────
+async function readCache() {
+    try {
+        return JSON.parse(await fs.readFile(CACHE_PATH, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+async function writeCache(entries) {
+    try {
+        await fs.writeFile(CACHE_PATH, JSON.stringify({ fetchedAt: Date.now(), entries }), 'utf-8');
+    }
+    catch { /* non-fatal */ }
+}
+// ── Bucket aggregation ────────────────────────────────────────────────────
+/**
+ * Given all quota entries, build the two UsageSnapshot rows:
+ *   - agy-gemini: worst-case (min remaining) across all Gemini models
+ *   - agy-other:  worst-case across all non-Gemini models (Claude, etc.)
+ */
+function buildSnapshots(entries, fromCache) {
+    const source = fromCache ? 'cache' : 'official-cli';
+    const geminiEntries = entries.filter(e => /gemini/i.test(e.model));
+    const otherEntries = entries.filter(e => !/gemini/i.test(e.model));
+    function worstCase(bucket, tool) {
+        if (bucket.length === 0) {
+            return { tool, remainingPercent: null, usedPercent: null, resetAt: null, source: 'unknown' };
+        }
+        // Show the lowest remaining % (most constrained model in the bucket)
+        const worst = bucket.reduce((a, b) => a.percent <= b.percent ? a : b);
+        return {
+            tool,
+            remainingPercent: worst.percent,
+            usedPercent: 100 - worst.percent,
+            resetAt: worst.refreshLine ?? null,
+            source,
+            raw: { matchedModel: worst.model, allModels: bucket.map(e => `${e.model}: ${e.percent}%`) },
+        };
+    }
+    return [
+        worstCase(geminiEntries, 'agy-gemini'),
+        worstCase(otherEntries, 'agy-other'),
+    ];
+}
+// ── Adapter ───────────────────────────────────────────────────────────────
+export class AgyQuotaAdapter {
+    async fetchSnapshots() {
+        // Fast path: serve from cache if fresh enough
+        const cached = await readCache();
+        if (cached && Date.now() - cached.fetchedAt < CACHE_TTL_MS) {
+            return buildSnapshots(cached.entries, true);
+        }
+        // Slow path: spawn agy, scrape the quota panel
+        try {
+            const raw = await runAgyUsage();
+            const entries = parseQuotaPanel(raw);
+            if (entries.length > 0) {
+                await writeCache(entries);
+                return buildSnapshots(entries, false);
             }
-            return {
-                tool: 'agy',
-                remainingPercent,
-                usedPercent: 100 - remainingPercent,
-                resetAt,
-                source: 'local-state',
-                raw: { activeModel, todayPromptsCount }
-            };
+            // Panel not found — return unknown rows (do not cache failures)
+            return [
+                { tool: 'agy-gemini', remainingPercent: null, usedPercent: null, resetAt: null, source: 'unknown' },
+                { tool: 'agy-other', remainingPercent: null, usedPercent: null, resetAt: null, source: 'unknown' },
+            ];
         }
         catch (error) {
-            return {
-                tool: 'agy',
-                remainingPercent: null,
-                usedPercent: null,
-                resetAt: null,
-                source: 'unknown',
-                raw: error instanceof Error ? error.message : String(error)
-            };
+            const msg = error instanceof Error ? error.message : String(error);
+            return [
+                { tool: 'agy-gemini', remainingPercent: null, usedPercent: null, resetAt: null, source: 'unknown', raw: msg },
+                { tool: 'agy-other', remainingPercent: null, usedPercent: null, resetAt: null, source: 'unknown', raw: msg },
+            ];
         }
     }
 }

package/dist/adapters/claude.d.ts

@@ -1,6 +1,7 @@
 import { QuotaAdapter, UsageSnapshot } from './index.js';
 export declare class ClaudeQuotaAdapter implements QuotaAdapter {
-    private budgetLimit;
+    private readonly budgetLimit;
     constructor();
-    fetchSnapshot(): Promise<UsageSnapshot>;
+    fetchSnapshots(): Promise<UsageSnapshot[]>;
+    private _fetch;
 }

package/dist/adapters/claude.js

@@ -1,48 +1,52 @@
 import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
 const execAsync = promisify(exec);
+// Budget limit for the rolling 5-hour billing window.
+// Override with AGENT_FUEL_CLAUDE_BUDGET env var (dollars).
+const DEFAULT_BUDGET_USD = 20.0;
 export class ClaudeQuotaAdapter {
     budgetLimit;
     constructor() {
-        // Default to $10.00 for the rolling 5-hour window, allow env override
-        this.budgetLimit = Number(process.env.AGENT_FUEL_CLAUDE_BUDGET) || 10.0;
+        const override = Number(process.env.AGENT_FUEL_CLAUDE_BUDGET);
+        this.budgetLimit = Number.isFinite(override) && override > 0 ? override : DEFAULT_BUDGET_USD;
     }
-    async fetchSnapshot() {
+    async fetchSnapshots() {
+        return [await this._fetch()];
+    }
+    async _fetch() {
+        const unknown = () => ({
+            tool: 'claude-code',
+            remainingPercent: null,
+            usedPercent: null,
+            resetAt: null,
+            source: 'unknown',
+        });
         try {
-            // Execute ccusage to get billing block information in JSON format
-            // We run npx --no-install first to see if it's already cached/available, otherwise fall back to regular npx
             let stdout;
             try {
-                const result = await execAsync('npx --no-install ccusage blocks --json');
-                stdout = result.stdout;
+                ({ stdout } = await execAsync('npx --no-install ccusage blocks --json'));
             }
             catch {
-                throw new Error('ccusage package is not installed or available locally. Please run "npm install -g ccusage" to use this tool.');
+                throw new Error('ccusage not found. Run "npm install -g ccusage" to enable Claude Code tracking.');
             }
             const data = JSON.parse(stdout);
-            const blocks = data && Array.isArray(data.blocks) ? data.blocks : data;
-            if (!blocks || !Array.isArray(blocks)) {
-                throw new Error('Invalid JSON format returned from ccusage blocks');
-            }
-            // Find the active billing block
-            const activeBlock = blocks.find((block) => block.isActive === true);
-            if (!activeBlock) {
-                return {
-                    tool: 'claude-code',
-                    remainingPercent: null,
-                    usedPercent: null,
-                    resetAt: null,
-                    source: 'unknown'
-                };
+            const blocks = Array.isArray(data?.blocks) ? data.blocks : data;
+            if (!Array.isArray(blocks)) {
+                throw new Error('Unexpected JSON shape from ccusage blocks.');
             }
-            const cost = activeBlock.costUSD || 0.0;
-            const usedPercent = (cost / this.budgetLimit) * 100;
-            const remainingPercent = Math.max(0, Math.min(100, Math.round(100 - usedPercent)));
+            const activeBlock = blocks.find((b) => b.isActive === true);
+            if (!activeBlock)
+                return unknown();
+            const cost = typeof activeBlock.costUSD === 'number' ? activeBlock.costUSD : 0;
+            const usedPct = (cost / this.budgetLimit) * 100;
+            const remainingPercent = Math.max(0, Math.min(100, Math.round(100 - usedPct)));
             let resetAt = null;
-            if (activeBlock.endTime) {
+            if (typeof activeBlock.endTime === 'string') {
                 try {
-                    const endDate = new Date(activeBlock.endTime);
-                    resetAt = endDate.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+                    resetAt = new Date(activeBlock.endTime).toLocaleTimeString([], {
+                        hour: '2-digit',
+                        minute: '2-digit',
+                    });
                 }
                 catch {
                     resetAt = activeBlock.endTime;
@@ -51,21 +55,16 @@ export class ClaudeQuotaAdapter {
             return {
                 tool: 'claude-code',
                 remainingPercent,
-                usedPercent: Math.round(usedPercent),
+                usedPercent: Math.round(usedPct),
                 resetAt,
                 source: 'ccusage',
-                raw: activeBlock
+                raw: activeBlock,
             };
         }
         catch (error) {
-            // Fallback in case of execution errors
             return {
-                tool: 'claude-code',
-                remainingPercent: null,
-                usedPercent: null,
-                resetAt: null,
-                source: 'unknown',
-                raw: error instanceof Error ? error.message : String(error)
+                ...unknown(),
+                raw: error instanceof Error ? error.message : String(error),
             };
         }
     }

package/dist/adapters/codex.d.ts

@@ -1,6 +1,7 @@
 import { QuotaAdapter, UsageSnapshot } from './index.js';
 export declare class CodexQuotaAdapter implements QuotaAdapter {
-    private budgetLimit;
+    private readonly budgetLimit;
     constructor();
-    fetchSnapshot(): Promise<UsageSnapshot>;
+    fetchSnapshots(): Promise<UsageSnapshot[]>;
+    private _fetch;
 }

package/dist/adapters/codex.js

@@ -1,105 +1,181 @@
-import { exec } from 'node:child_process';
+import { exec, spawn } from 'node:child_process';
 import { promisify } from 'node:util';
 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 (i.e. quota has not yet been reached). This is a GUESS based on
+// local session cost data — not an official Codex quota signal.
+// Override with AGENT_FUEL_CODEX_BUDGET env var (dollars).
+const DEFAULT_BUDGET_USD = 20.0;
+const ROLLING_WINDOW_MS = 5 * 60 * 60 * 1000;
+// ── TUI scraper (expect) ───────────────────────────────────────────────────
+/**
+ * Spawns `codex` via `expect`, handles the trust prompt, waits for the TUI to
+ * settle, then captures stdout/stderr to check for the quota-reached warning.
+ */
+function runCodexScrape() {
+    return new Promise((resolve) => {
+        const expectScript = [
+            'set timeout 15',
+            'spawn codex',
+            'expect {',
+            '  -re "Press enter to continue" { send "\\r"; exp_continue }',
+            '  -re "Individual quota reached" { after 300; send "\\x03" }',
+            '  -re "for shortcuts" { after 300; send "\\x03" }',
+            '  timeout { }',
+            '  eof { }',
+            '}',
+            'expect eof',
+        ].join('\n');
+        const MAX_OUTPUT_BYTES = 64 * 1024;
+        let output = '';
+        const child = spawn('expect', ['-c', expectScript], {
+            env: { ...process.env },
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const append = (chunk) => {
+            if (output.length < MAX_OUTPUT_BYTES)
+                output += chunk.toString();
+        };
+        child.stdout.on('data', append);
+        child.stderr.on('data', append);
+        const timer = setTimeout(() => { child.kill('SIGKILL'); resolve(output); }, 20_000);
+        child.on('close', () => { clearTimeout(timer); resolve(output); });
+    });
+}
+// ── Output parser ──────────────────────────────────────────────────────────
+function stripAnsi(str) {
+    // eslint-disable-next-line no-control-regex
+    return str.replace(/\x1B\[[0-9;]*[A-Za-z]|\x1B[^[]/g, '').replace(/[\x00-\x08\x0b-\x1f\x7f]/g, '');
+}
+function parseScrapeOutput(raw) {
+    const clean = stripAnsi(raw);
+    // "Individual quota reached. Contact your administrator to enable overages. Resets in 4h33m29s."
+    const quotaMatch = clean.match(/Individual quota reached/i);
+    if (!quotaMatch)
+        return { quotaReached: false, resetIn: null };
+    // Parse "Resets in 4h33m29s" → "4h 33m"
+    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;
     }
-    async fetchSnapshot() {
+    return { quotaReached: true, resetIn };
+}
+// ── 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();
+        }
+        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 */ }
+        }
+        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() {
+        // Primary: scrape the Codex TUI via expect
+        try {
+            const raw = await runCodexScrape();
+            const result = parseScrapeOutput(raw);
+            if (result.quotaReached) {
+                // Ground truth: quota is exhausted
+                const resetAt = result.resetIn ? `Resets in ${result.resetIn}` : null;
                 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;
-                }
-            }
-            return {
-                tool: 'codex',
-                remainingPercent,
-                usedPercent: Math.round(usedPercent),
-                resetAt,
-                source: 'ccusage',
-                raw: { totalCost, todaySessionsCount: todaySessions.length }
-            };
+            // TUI loaded cleanly with no quota warning → estimate remaining via ccusage
+            const estimate = await fetchCcusageEstimate(this.budgetLimit);
+            return estimate;
         }
-        catch (error) {
-            return {
-                tool: 'codex',
-                remainingPercent: null,
-                usedPercent: null,
-                resetAt: null,
-                source: 'unknown',
-                raw: error instanceof Error ? error.message : String(error)
-            };
+        catch {
+            // expect not available or codex spawn failed → fall back to ccusage estimate
+            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/index.js

@@ -2,28 +2,54 @@
 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, LOADING_LINE } 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 R = '\x1b[0m';
+const N = SLOT_ORDER.length;
+// Redraws all N slot lines from the current cursor position (cursor must be
+// just below the last slot line when called).
+function redraw(slots) {
+    process.stdout.write(`\x1b[${N}A`); // cursor up N lines
+    for (const tool of SLOT_ORDER) {
+        process.stdout.write('\x1b[2K\r'); // clear line
+        const line = slots.get(tool);
+        if (line != null) {
+            process.stdout.write(line + '\n');
+        }
+        else {
+            process.stdout.write(`${BOLD}${getDisplayName(tool).padEnd(13)}${R} ${LOADING_LINE}\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
-        ]);
+    printHeader();
+    // Print placeholder rows in fixed order
+    const slots = new Map(SLOT_ORDER.map(t => [t, null]));
+    for (const tool of SLOT_ORDER) {
+        process.stdout.write(`${BOLD}${getDisplayName(tool).padEnd(13)}${R} ${LOADING_LINE}\n`);
     }
-    catch (error) {
-        console.error('\x1b[31mFatal error orchestrating Agent Fuel CLI:\x1b[0m', error);
-        process.exit(1);
+    // 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);
     }
+    await Promise.allSettled([
+        claudeAdapter.fetchSnapshots().then(fill),
+        codexAdapter.fetchSnapshots().then(fill),
+        agyAdapter.fetchSnapshots().then(fill),
+    ]);
+    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,61 +1,113 @@
-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';
-    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}`);
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+// ── 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;
     }
-    console.log('');
 }
-function getDisplayName(tool) {
-    switch (tool) {
-        case 'codex':
-            return 'Codex';
-        case 'claude-code':
-            return 'Claude Code';
-        case 'agy':
-            return 'AGY';
-        default:
-            return tool;
+function pickColour(remaining) {
+    if (remaining < 20)
+        return RED;
+    if (remaining < 50)
+        return YELLOW;
+    return GREEN;
+}
+function loadVersion() {
+    try {
+        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 {
+        return '';
+    }
+}
+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}`;
     }
+    return `${DIM}${GRAY}(resets ${resetAt})${R}`;
+}
+function isEstimate(snap) {
+    return snap.source === 'ccusage' &&
+        typeof snap.raw === 'object' && snap.raw !== null &&
+        snap.raw.isEstimate === true;
+}
+// ── 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 (snap.tool === 'codex' && 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();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-fuel",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Sleek term-based dashboard for AI coding CLI quotas",
   "type": "module",
   "main": "dist/index.js",
@@ -31,4 +31,4 @@
     "@types/node": "^20.11.24",
     "typescript": "^5.3.3"
   }
-}
+}