ccusage 0.1.7__tar.gz → 0.1.9__tar.gz

{ccusage-0.1.7 → ccusage-0.1.9}/.github/workflows/publish.yml

@@ -1,8 +1,10 @@
 name: Publish to PyPI
 
 on:
-  release:
-    types: [published]
+  workflow_dispatch:
+  push:
+    tags:
+      - "v*"
 
 permissions:
   id-token: write

{ccusage-0.1.7 → ccusage-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ccusage
-Version: 0.1.7
+Version: 0.1.9
 Summary: Claude Code usage monitor — fetches rate limits from Anthropic's API
 Project-URL: Homepage, https://github.com/wakamex/ccusage
 Project-URL: Source, https://github.com/wakamex/ccusage
@@ -17,7 +17,7 @@ Claude Code usage monitor. Fetches your real rate limit data from Anthropic's AP
 
 ```
 Plan: max_5x
-  Session (5h)         39%  resets 1h26m
+  Session              39%  resets 1h26m
   Week (all)           15%  resets 143h26m
   Week (Sonnet)        39%  resets 65h26m
   Extra usage          $0.00 / $1000.00
@@ -26,7 +26,7 @@ Plan: max_5x
 Claude Code statusline (self-caching — refreshes from API when stale, no daemon needed):
 
 ```
-~/projects/myapp [Opus 4.6] 5h:39% 7d:15% son:39% | $1.37 | max_5x | reset:1h26m
+~/projects/myapp [Opus 4.6] sess:39% 7d:15% son:39% | $1.37 | max_5x | reset:1h26m
 ```
 
 ## Install
@@ -94,6 +94,18 @@ Claude Code gets rate limit data from two places:
 | `seven_day_opus` | `seven_day_opus` | Rolling 7-day Opus-specific window |
 | `overage` | `extra_usage` | Extra/overage usage (if enabled) |
 
+The flat `seven_day_*` keys above are all `null` now — the live quota data
+lives in a structured `limits` array, which ccusage reads. Each entry is
+self-describing: `kind` (`session` / `weekly_all` / `weekly_scoped`),
+`percent`, `resets_at`, and for scoped limits a `scope.model.display_name`.
+Because the structured response does not include a session duration, ccusage
+labels that limit `Session` and caches it under `session` rather than assuming
+it is always five hours. Existing `5h` cache files remain readable.
+Model-scoped weekly windows (Opus, Sonnet, and a newly added **Fable**) are
+keyed by their model name, so any new one is auto-detected and displayed with
+no code change (e.g. `scope.model.display_name: "Fable"` → "Week (Fable)",
+statusline `fab:`).
+
 ### API response format
 
 ```

{ccusage-0.1.7 → ccusage-0.1.9}/README.md

@@ -8,7 +8,7 @@ Claude Code usage monitor. Fetches your real rate limit data from Anthropic's AP
 
 ```
 Plan: max_5x
-  Session (5h)         39%  resets 1h26m
+  Session              39%  resets 1h26m
   Week (all)           15%  resets 143h26m
   Week (Sonnet)        39%  resets 65h26m
   Extra usage          $0.00 / $1000.00
@@ -17,7 +17,7 @@ Plan: max_5x
 Claude Code statusline (self-caching — refreshes from API when stale, no daemon needed):
 
 ```
-~/projects/myapp [Opus 4.6] 5h:39% 7d:15% son:39% | $1.37 | max_5x | reset:1h26m
+~/projects/myapp [Opus 4.6] sess:39% 7d:15% son:39% | $1.37 | max_5x | reset:1h26m
 ```
 
 ## Install
@@ -85,6 +85,18 @@ Claude Code gets rate limit data from two places:
 | `seven_day_opus` | `seven_day_opus` | Rolling 7-day Opus-specific window |
 | `overage` | `extra_usage` | Extra/overage usage (if enabled) |
 
+The flat `seven_day_*` keys above are all `null` now — the live quota data
+lives in a structured `limits` array, which ccusage reads. Each entry is
+self-describing: `kind` (`session` / `weekly_all` / `weekly_scoped`),
+`percent`, `resets_at`, and for scoped limits a `scope.model.display_name`.
+Because the structured response does not include a session duration, ccusage
+labels that limit `Session` and caches it under `session` rather than assuming
+it is always five hours. Existing `5h` cache files remain readable.
+Model-scoped weekly windows (Opus, Sonnet, and a newly added **Fable**) are
+keyed by their model name, so any new one is auto-detected and displayed with
+no code change (e.g. `scope.model.display_name: "Fable"` → "Week (Fable)",
+statusline `fab:`).
+
 ### API response format
 
 ```

{ccusage-0.1.7 → ccusage-0.1.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ccusage"
-version = "0.1.7"
+version = "0.1.9"
 description = "Claude Code usage monitor — fetches rate limits from Anthropic's API"
 readme = "README.md"
 requires-python = ">=3.12"

{ccusage-0.1.7 → ccusage-0.1.9}/src/ccusage/__init__.py

@@ -19,6 +19,7 @@ import os
 import signal
 import subprocess
 import sys
+import tempfile
 import time
 import urllib.error
 import urllib.request
@@ -94,6 +95,48 @@ def get_plan(creds: dict | None = None) -> str:
     return tier.removeprefix("default_claude_")
 
 
+def _credential_identity(creds: dict | None) -> tuple[object, object]:
+    oauth = (creds or {}).get("claudeAiOauth", {})
+    return oauth.get("accessToken"), oauth.get("refreshToken")
+
+
+def _persist_credentials(updated: dict, expected_identity: tuple[object, object]) -> dict:
+    latest = get_credentials()
+    if latest and _credential_identity(latest) != expected_identity:
+        return latest
+    if latest:
+        latest_oauth = latest.get("claudeAiOauth", {})
+        updated_oauth = updated.get("claudeAiOauth", {})
+        updated = {
+            **latest,
+            **updated,
+            "claudeAiOauth": {**latest_oauth, **updated_oauth},
+        }
+
+    tmp: Path | None = None
+    try:
+        CREDENTIALS_FILE.parent.mkdir(parents=True, exist_ok=True)
+        fd, tmp_name = tempfile.mkstemp(
+            prefix=f".{CREDENTIALS_FILE.name}.", dir=CREDENTIALS_FILE.parent
+        )
+        tmp = Path(tmp_name)
+        os.fchmod(fd, 0o600)
+        with os.fdopen(fd, "w") as file:
+            file.write(json.dumps(updated))
+        os.replace(tmp, CREDENTIALS_FILE)
+    except OSError as exc:
+        if tmp:
+            try:
+                tmp.unlink()
+            except OSError:
+                pass
+        print(
+            f"Warning: refreshed token but could not write {CREDENTIALS_FILE}: {exc}",
+            file=sys.stderr,
+        )
+    return updated
+
+
 def refresh_credentials(creds: dict) -> dict:
     """Refresh the OAuth access token and persist updated credentials.
 
@@ -101,6 +144,11 @@ def refresh_credentials(creds: dict) -> dict:
     back to .credentials.json or Claude Code's stored one goes stale and the
     user gets logged out.
     """
+    expected_identity = _credential_identity(creds)
+    latest = get_credentials()
+    if latest and _credential_identity(latest) != expected_identity:
+        return latest
+
     oauth = creds.get("claudeAiOauth", {})
     refresh_token = oauth.get("refreshToken")
     if not refresh_token:
@@ -120,6 +168,10 @@ def refresh_credentials(creds: dict) -> dict:
         with urllib.request.urlopen(req, timeout=10) as resp:
             result = json.loads(resp.read())
     except urllib.error.HTTPError as e:
+        latest = get_credentials()
+        if e.code in (400, 401) and latest:
+            if _credential_identity(latest) != expected_identity:
+                return latest
         raise RuntimeError(f"Token refresh failed ({e.code}) — open Claude Code to refresh it") from e
 
     oauth = dict(oauth)
@@ -130,16 +182,7 @@ def refresh_credentials(creds: dict) -> dict:
     updated = dict(creds)
     updated["claudeAiOauth"] = oauth
 
-    try:
-        tmp = CREDENTIALS_FILE.parent / (CREDENTIALS_FILE.name + ".tmp")
-        fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
-        with os.fdopen(fd, "w") as f:
-            f.write(json.dumps(updated))
-        os.replace(tmp, CREDENTIALS_FILE)
-    except OSError as e:
-        print(f"Warning: refreshed token but could not write {CREDENTIALS_FILE}: {e}", file=sys.stderr)
-
-    return updated
+    return _persist_credentials(updated, expected_identity)
 
 
 def fetch_usage() -> dict:
@@ -168,13 +211,13 @@ def fetch_usage() -> dict:
     if not token:
         raise RuntimeError("No OAuth access token in credentials")
 
-    # Refresh proactively if expired (or about to), then retry once on 401/403
-    # in case the token was revoked early.
+    # Refresh proactively if expired (or about to).
     if time.time() * 1000 > oauth.get("expiresAt", 0) - 60_000:
         creds = refresh_credentials(creds)
         token = creds["claudeAiOauth"]["accessToken"]
 
-    for attempt in range(2):
+    refreshed_after_rejection = False
+    for attempt in range(3):
         req = urllib.request.Request(
             "https://api.anthropic.com/api/oauth/usage",
             headers={
@@ -188,34 +231,111 @@ def fetch_usage() -> dict:
             with urllib.request.urlopen(req, timeout=10) as resp:
                 return json.loads(resp.read())
         except urllib.error.HTTPError as e:
-            if e.code in (401, 403) and attempt == 0:
-                creds = refresh_credentials(creds)
-                token = creds["claudeAiOauth"]["accessToken"]
-            else:
+            if e.code not in (401, 403):
                 raise
 
+            latest = get_credentials()
+            latest_token = (latest or {}).get("claudeAiOauth", {}).get("accessToken")
+            if latest_token and latest_token != token:
+                creds, token = latest, latest_token
+                continue
+            if not refreshed_after_rejection:
+                creds = refresh_credentials(latest or creds)
+                token = creds["claudeAiOauth"]["accessToken"]
+                refreshed_after_rejection = True
+                continue
+            raise
+
     raise RuntimeError("Failed to fetch usage after token refresh")
 
 
+# Top-level keys in the cached usage dict that are NOT rate-limit buckets.
+_META_KEYS = {"plan", "source", "updated_at", "extra_usage"}
+
+
+def _bucket_display(short_key: str) -> tuple[str, str]:
+    """Return (full label, statusline abbrev) for a short bucket key.
+
+    Derived from the key so unknown/newly-added buckets get a reasonable
+    label automatically, e.g. "7d_fable" -> ("Week (Fable)", "fab").
+    """
+    known = {
+        "session": ("Session", "sess"),
+        "5h": ("Session (5h)", "5h"),
+        "7d": ("Week (all)", "7d"),
+        "7d_opus": ("Week (Opus)", "opus"),
+        "7d_sonnet": ("Week (Sonnet)", "son"),
+    }
+    if short_key in known:
+        return known[short_key]
+    if short_key.startswith("7d_"):
+        model = short_key[3:]
+        return f"Week ({model.replace('_', ' ').title()})", model[:3]
+    return short_key.replace("_", " ").title(), short_key[:4]
+
+
+def _quota_buckets(data: dict):
+    """Yield (short_key, bucket) for each rate-limit bucket in a usage dict.
+
+    Relies on insertion order (build_usage_json inserts them sorted), so
+    callers get a stable, sensible display sequence.
+    """
+    for key, val in data.items():
+        if key in _META_KEYS:
+            continue
+        if isinstance(val, dict) and "pct" in val:
+            yield key, val
+
+
+def _buckets_from_limits(limits) -> list:
+    """Parse the API's structured `limits` array into (order, short_key, bucket).
+
+    This is the current API shape. Each entry is self-describing:
+        {"kind": "session"|"weekly_all"|"weekly_scoped", "percent": 58,
+         "resets_at": "...", "scope": {"model": {"display_name": "Fable"}}}
+    Model-scoped weekly limits (Opus, Sonnet, Fable, ...) are keyed by their
+    model name, so a newly added one appears automatically.
+    """
+    out = []
+    for entry in limits:
+        if not isinstance(entry, dict):
+            continue
+        pct = entry.get("percent")
+        if pct is None:
+            continue
+        kind = entry.get("kind")
+        if kind == "session":
+            short_key, order = "session", 0
+        elif kind == "weekly_all":
+            short_key, order = "7d", 1
+        elif kind == "weekly_scoped":
+            model = (entry.get("scope") or {}).get("model") or {}
+            name = (model.get("display_name") or model.get("id") or "scoped").strip()
+            short_key = "7d_" + name.lower().replace(" ", "_")
+            order = {"7d_opus": 2, "7d_sonnet": 3}.get(short_key, 4)
+        else:
+            short_key, order = kind or "unknown", 5
+        out.append((order, short_key, {"pct": pct, "resets_at": entry.get("resets_at")}))
+    return out
+
+
 def build_usage_json(api_data: dict, plan: str) -> dict:
-    """Transform API response into our cached format."""
+    """Transform API response into our cached format.
+
+    Reads the API's structured `limits` array — every quota it reports (session,
+    weekly-all, and per-model weekly windows like Opus/Sonnet/Fable) is included
+    and mapped to a short key, so a newly added one appears automatically
+    instead of being dropped.
+    """
     result = {
         "plan": plan,
         "source": "api",
         "updated_at": datetime.now(timezone.utc).isoformat(),
     }
-    for key, api_key in [
-        ("5h", "five_hour"),
-        ("7d", "seven_day"),
-        ("7d_sonnet", "seven_day_sonnet"),
-        ("7d_opus", "seven_day_opus"),
-    ]:
-        bucket = api_data.get(api_key)
-        if bucket:
-            result[key] = {
-                "pct": bucket["utilization"],
-                "resets_at": bucket.get("resets_at"),
-            }
+    limits = api_data.get("limits")
+    buckets = _buckets_from_limits(limits) if isinstance(limits, list) else []
+    for _, short_key, bucket in sorted(buckets, key=lambda b: b[0]):
+        result[short_key] = bucket
     extra = api_data.get("extra_usage")
     if extra:
         result["extra_usage"] = extra
@@ -227,13 +347,51 @@ def write_usage_file(data: dict):
     USAGE_FILE.write_text(json.dumps(data, indent=2) + "\n")
 
 
+def _read_cache() -> dict | None:
+    """Read the cached usage file, or None if missing/unreadable."""
+    try:
+        return json.loads(USAGE_FILE.read_text())
+    except Exception:
+        return None
+
+
+def _is_429(err: Exception) -> bool:
+    """True if the exception is (or wraps) an HTTP 429 rate-limit error."""
+    if isinstance(err, urllib.error.HTTPError) and err.code == 429:
+        return True
+    return "429" in str(err)
+
+
+def _cache_age_str(data: dict) -> str:
+    """Return e.g. ' 3m ago' from a usage dict's updated_at, or '' if unknown."""
+    try:
+        updated = datetime.fromisoformat(data["updated_at"])
+        secs = int((datetime.now(timezone.utc) - updated).total_seconds())
+        m = secs // 60
+        return f" {m // 60}h{m % 60}m ago" if m >= 60 else f" {m}m ago"
+    except Exception:
+        return ""
+
+
 # -- CLI commands --
 
 def cmd_status(raw_json=False):
-    """Fetch and display current usage."""
-    api_data = fetch_usage()
-    plan = get_plan()
-    data = build_usage_json(api_data, plan)
+    """Fetch and display current usage.
+
+    Fetches fresh from the API, but on failure (rate limit, offline, expired
+    token) falls back to the last cached usage rather than crashing.
+    """
+    stale = False
+    try:
+        api_data = fetch_usage()
+        data = build_usage_json(api_data, get_plan())
+    except Exception as e:
+        cached = _read_cache()
+        if cached is None:
+            reason = "rate limited (HTTP 429) — try again shortly" if _is_429(e) else str(e)
+            print(f"Could not fetch usage: {reason}", file=sys.stderr)
+            sys.exit(1)
+        data, stale = cached, True
 
     if raw_json:
         print(json.dumps(data, indent=2))
@@ -266,18 +424,12 @@ def cmd_status(raw_json=False):
         except Exception:
             return ""
 
-    print(f"Plan: {plan}")
-    for label, key in [
-        ("Session (5h)", "5h"),
-        ("Week (all)", "7d"),
-        ("Week (Sonnet)", "7d_sonnet"),
-        ("Week (Opus)", "7d_opus"),
-    ]:
-        bucket = data.get(key)
-        if bucket:
-            pct = bucket["pct"]
-            reset = fmt_reset(bucket.get("resets_at"))
-            print(f"  {label:20s} {color_pct(pct)}{D}{reset}{RST}")
+    print(f"Plan: {data.get('plan', '?')}")
+    for key, bucket in _quota_buckets(data):
+        label = _bucket_display(key)[0]
+        pct = bucket["pct"]
+        reset = fmt_reset(bucket.get("resets_at"))
+        print(f"  {label:20s} {color_pct(pct)}{D}{reset}{RST}")
 
     extra = data.get("extra_usage")
     if extra and extra.get("is_enabled"):
@@ -285,6 +437,30 @@ def cmd_status(raw_json=False):
         limit = extra.get("monthly_limit", 0) / 100
         print(f"  {'Extra usage':20s} ${used:.2f} / ${limit:.2f}")
 
+    if stale:
+        age = _cache_age_str(data)
+        print(f"{D}  (cached{age} — live fetch failed){RST}", file=sys.stderr)
+
+
+def cmd_refresh():
+    """Fetch fresh usage from the API and write the cache file once, then exit.
+
+    A one-shot equivalent of a single daemon tick — use it to force
+    ~/.claude/usage-limits.json up to date without running the daemon.
+    """
+    try:
+        api_data = fetch_usage()
+    except Exception as e:
+        reason = "rate limited (HTTP 429) — try again shortly" if _is_429(e) else str(e)
+        print(f"Could not refresh usage: {reason}", file=sys.stderr)
+        sys.exit(1)
+    data = build_usage_json(api_data, get_plan())
+    write_usage_file(data)
+    pcts = " ".join(f"{key}:{int(b['pct'])}%" for key, b in _quota_buckets(data))
+    print(f"Updated {USAGE_FILE}")
+    if pcts:
+        print(f"  {pcts}")
+
 
 def cmd_daemon(interval: int = DAEMON_INTERVAL):
     """Run in foreground, refresh every `interval` seconds."""
@@ -303,11 +479,7 @@ def cmd_daemon(interval: int = DAEMON_INTERVAL):
             data = build_usage_json(api_data, plan)
             write_usage_file(data)
             backoff = 0
-            pcts = []
-            for key in ("5h", "7d", "7d_sonnet"):
-                b = data.get(key)
-                if b:
-                    pcts.append(f"{key}:{int(b['pct'])}%")
+            pcts = [f"{key}:{int(b['pct'])}%" for key, b in _quota_buckets(data)]
             print(f"[{datetime.now().strftime('%H:%M:%S')}] {' '.join(pcts)}")
         except urllib.error.HTTPError as e:
             if e.code == 429:
@@ -392,22 +564,19 @@ def cmd_statusline():
     usage = _get_cached_usage()
 
     plan = usage.get("plan", "?")
-    five_h = usage.get("5h", {})
-    seven_d = usage.get("7d", {})
-    sonnet = usage.get("7d_sonnet", {})
-
     parts = [f"{D}{pwd}{RST}", f"[{C}{model}{RST}]"]
 
-    if five_h:
-        parts.append(f"5h:{color_pct(int(five_h.get('pct', 0)))}")
-    if seven_d:
-        parts.append(f"7d:{color_pct(int(seven_d.get('pct', 0)))}")
-    if sonnet:
-        parts.append(f"son:{color_pct(int(sonnet.get('pct', 0)))}")
+    # Auto-include every quota bucket present (a newly added one just appears).
+    session_bucket = {}
+    for key, bucket in _quota_buckets(usage):
+        abbrev = _bucket_display(key)[1]
+        parts.append(f"{abbrev}:{color_pct(int(bucket.get('pct', 0)))}")
+        if key in {"session", "5h"}:
+            session_bucket = bucket
 
     parts.append(f"| {cost_fmt} | {D}{plan}{RST}")
 
-    reset = fmt_reset(five_h.get("resets_at"))
+    reset = fmt_reset(session_bucket.get("resets_at"))
     if reset:
         parts.append(f"| {D}reset:{reset}{RST}")
 
@@ -431,7 +600,7 @@ def cmd_install():
    }
 
 3. The statusline reads ~/.claude/usage-limits.json (written by the daemon)
-   and shows: 5h session, 7d all-models, 7d Sonnet-specific limits.
+   and shows: session, weekly all-models, and weekly scoped limits.
 """)
 
 
@@ -440,6 +609,7 @@ def main():
     sub = parser.add_subparsers(dest="command")
     sub.add_parser("status", help="Show current usage (default)")
     sub.add_parser("json", help="Print raw JSON")
+    sub.add_parser("refresh", help="Fetch fresh usage and update the cache file once")
     daemon_parser = sub.add_parser("daemon", help="Run refresh daemon")
     daemon_parser.add_argument("-i", "--interval", type=int, default=DAEMON_INTERVAL,
                                help=f"Refresh interval in seconds (default: {DAEMON_INTERVAL})")
@@ -452,6 +622,8 @@ def main():
         cmd_status()
     elif cmd == "json":
         cmd_status(raw_json=True)
+    elif cmd == "refresh":
+        cmd_refresh()
     elif cmd == "daemon":
         cmd_daemon(interval=args.interval)
     elif cmd == "statusline":

{ccusage-0.1.7 → ccusage-0.1.9}/tests/test_ccusage.py

@@ -107,6 +107,7 @@ class FetchUsageTests(unittest.TestCase):
         self.assertEqual(oauth["subscriptionType"], "max")
         self.assertEqual(on_disk["otherTopLevel"], "keep-me")
         self.assertEqual(self.credfile.stat().st_mode & 0o777, 0o600)
+        self.assertEqual(list(self.credfile.parent.glob("..credentials.json.*")), [])
 
     def test_rejected_token_retries_once_after_refresh(self):
         self._write_creds(int(time.time() * 1000) + 3_600_000)
@@ -139,6 +140,52 @@ class FetchUsageTests(unittest.TestCase):
             with self.assertRaises(urllib.error.HTTPError):
                 ccusage.fetch_usage()
 
+    def test_rejected_token_reloads_concurrently_updated_credentials(self):
+        self._write_creds(int(time.time() * 1000) + 3_600_000)
+        replacement = _creds(int(time.time() * 1000) + 3_600_000)
+        replacement["claudeAiOauth"]["accessToken"] = "replacement-token"
+        replacement["claudeAiOauth"]["refreshToken"] = "replacement-refresh"
+        calls = []
+
+        def fake_urlopen(req, timeout=None):
+            calls.append(req.full_url)
+            if len(calls) == 1:
+                self.credfile.write_text(json.dumps(replacement))
+                raise urllib.error.HTTPError(
+                    req.full_url, 401, "Unauthorized", {}, io.BytesIO(b"")
+                )
+            self.assertEqual(
+                req.headers["Authorization"], "Bearer replacement-token"
+            )
+            return _json_response({"ok": True})
+
+        with mock.patch.object(ccusage.urllib.request, "urlopen", fake_urlopen):
+            self.assertEqual(ccusage.fetch_usage(), {"ok": True})
+
+        self.assertEqual(calls, [USAGE_URL, USAGE_URL])
+
+    def test_refresh_does_not_overwrite_concurrently_rotated_credentials(self):
+        self._write_creds(0)
+        original = json.loads(self.credfile.read_text())
+        replacement = _creds(int(time.time() * 1000) + 3_600_000)
+        replacement["claudeAiOauth"]["accessToken"] = "replacement-token"
+        replacement["claudeAiOauth"]["refreshToken"] = "replacement-refresh"
+
+        class RotatingResponse(_FakeResponse):
+            def read(inner_self, *args):
+                self.credfile.write_text(json.dumps(replacement))
+                return super().read(*args)
+
+        with mock.patch.object(
+            ccusage.urllib.request,
+            "urlopen",
+            return_value=RotatingResponse(json.dumps(REFRESH_RESULT).encode()),
+        ):
+            result = ccusage.refresh_credentials(original)
+
+        self.assertEqual(result, replacement)
+        self.assertEqual(json.loads(self.credfile.read_text()), replacement)
+
     def test_expired_token_without_refresh_token_raises(self):
         creds = _creds(0)
         del creds["claudeAiOauth"]["refreshToken"]
@@ -159,20 +206,65 @@ class FetchUsageTests(unittest.TestCase):
 
 
 class BuildUsageJsonTests(unittest.TestCase):
-    def test_maps_buckets_and_extra_usage(self):
+    def test_reads_structured_limits_array(self):
+        # Current API shape: session/weekly totals and the model-scoped Fable
+        # quota all live in `limits`; the flat seven_day_* keys are ignored.
         api_data = {
-            "five_hour": {"utilization": 35.0, "resets_at": "2026-06-12T00:00:00+00:00"},
-            "seven_day": {"utilization": 14.0, "resets_at": None},
-            "seven_day_sonnet": None,
             "seven_day_opus": None,
+            "seven_day_sonnet": None,
+            "iguana_necktie": None,
+            "limits": [
+                {"kind": "session", "percent": 3, "resets_at": "2026-07-04T05:10:00+00:00"},
+                {"kind": "weekly_all", "percent": 33, "resets_at": "2026-07-07T13:00:00+00:00"},
+                {"kind": "weekly_scoped", "percent": 58,
+                 "resets_at": "2026-07-07T13:00:00+00:00",
+                 "scope": {"model": {"id": None, "display_name": "Fable"}}},
+            ],
             "extra_usage": {"is_enabled": True, "monthly_limit": 100000},
         }
         result = ccusage.build_usage_json(api_data, "max_20x")
         self.assertEqual(result["plan"], "max_20x")
-        self.assertEqual(result["5h"], {"pct": 35.0, "resets_at": "2026-06-12T00:00:00+00:00"})
-        self.assertEqual(result["7d"], {"pct": 14.0, "resets_at": None})
-        self.assertNotIn("7d_sonnet", result)
+        self.assertEqual(result["session"], {"pct": 3, "resets_at": "2026-07-04T05:10:00+00:00"})
+        self.assertNotIn("5h", result)
+        self.assertEqual(result["7d"], {"pct": 33, "resets_at": "2026-07-07T13:00:00+00:00"})
+        self.assertEqual(result["7d_fable"], {"pct": 58, "resets_at": "2026-07-07T13:00:00+00:00"})
         self.assertEqual(result["extra_usage"], {"is_enabled": True, "monthly_limit": 100000})
+        self.assertEqual(ccusage._bucket_display("7d_fable"), ("Week (Fable)", "fab"))
+        # Buckets appear in a stable, sensible order.
+        keys = [k for k, _ in ccusage._quota_buckets(result)]
+        self.assertEqual(keys, ["session", "7d", "7d_fable"])
+
+    def test_statusline_uses_semantic_session_bucket_for_reset(self):
+        usage = {
+            "plan": "max_20x",
+            "session": {
+                "pct": 3,
+                "resets_at": "2099-01-01T00:00:00+00:00",
+            },
+            "7d": {"pct": 13, "resets_at": None},
+        }
+        status_input = {
+            "model": {"display_name": "Test"},
+            "workspace": {"current_dir": "/code/test"},
+        }
+        with (
+            mock.patch.object(ccusage, "_get_cached_usage", return_value=usage),
+            mock.patch("sys.stdin", io.StringIO(json.dumps(status_input))),
+            mock.patch("sys.stdout", new_callable=io.StringIO) as stdout,
+        ):
+            ccusage.cmd_statusline()
+
+        output = stdout.getvalue()
+        self.assertIn("sess:3%", output)
+        self.assertIn("reset:", output)
+
+    def test_scoped_limit_without_percent_is_skipped(self):
+        api_data = {"limits": [
+            {"kind": "weekly_scoped", "percent": None,
+             "scope": {"model": {"display_name": "Opus"}}},
+        ]}
+        result = ccusage.build_usage_json(api_data, "max_20x")
+        self.assertEqual([k for k, _ in ccusage._quota_buckets(result)], [])
 
 
 if __name__ == "__main__":

{ccusage-0.1.7 → ccusage-0.1.9}/uv.lock

@@ -4,5 +4,5 @@ requires-python = ">=3.12"
 
 [[package]]
 name = "ccusage"
-version = "0.1.4"
+version = "0.1.9"
 source = { editable = "." }