claudometer 1.0.0__py3-none-any.whl

app.py

@@ -0,0 +1,54 @@
+"""Entry point.
+
+Usage (no arg default: macOS = menu bar, Windows = taskbar strip, Linux = tray):
+    py app.py            # default per platform (above)
+    py app.py bar        # Windows: floating readable numbers over the taskbar
+    py app.py tray       # Windows/Linux: tray icon only
+    py app.py both       # Windows: tray icon + floating taskbar readout
+"""
+
+import os
+import subprocess
+import sys
+
+
+def _run_tray():
+    from tray_windows import TrayApp
+    TrayApp().run()
+
+
+def _run_bar():
+    from widget_bar import BarWidget
+    BarWidget().run()
+
+
+def main() -> None:
+    mode = (sys.argv[1] if len(sys.argv) > 1 else "").lower()
+
+    if sys.platform == "darwin":
+        from menubar_mac import MenuApp
+        MenuApp().run()
+        return
+
+    if not mode:  # packaged/no-arg default: the flagship on Windows, tray on Linux
+        mode = "bar" if sys.platform == "win32" else "tray"
+    if mode in ("bar", "both") and sys.platform != "win32":
+        mode = "tray"  # bar/both are Windows-only (widget_bar needs ctypes.windll)
+
+    if mode == "bar":
+        _run_bar()
+    elif mode == "both":
+        # Run the tray in a separate process (its own message loop) and the
+        # floating bar here on the main thread.
+        if getattr(sys, "frozen", False):  # packaged .exe re-reads argv
+            subprocess.Popen([sys.executable, "tray"])
+        else:
+            here = os.path.join(os.path.dirname(os.path.abspath(__file__)), "app.py")
+            subprocess.Popen([sys.executable, here, "tray"])
+        _run_bar()
+    else:  # "", "tray", win32 / linux default
+        _run_tray()
+
+
+if __name__ == "__main__":
+    main()

claudometer-1.0.0.dist-info/METADATA

@@ -0,0 +1,345 @@
+Metadata-Version: 2.4
+Name: claudometer
+Version: 1.0.0
+Summary: Live Claude usage limits (session & weekly) on your taskbar / menu bar — so you never hit a limit by surprise.
+Author-email: Muhammad Ali <ali.dev178@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/ali-dev178/claudometer
+Project-URL: Repository, https://github.com/ali-dev178/claudometer
+Project-URL: Issues, https://github.com/ali-dev178/claudometer/issues
+Keywords: claude,claude-code,anthropic,usage,taskbar,menubar,widget,tray
+Classifier: Environment :: Win32 (MS Windows)
+Classifier: Environment :: MacOS X
+Classifier: Environment :: X11 Applications
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.31
+Requires-Dist: pystray>=0.19; sys_platform != "darwin"
+Requires-Dist: Pillow>=10.1; sys_platform != "darwin"
+Requires-Dist: rumps>=0.4; sys_platform == "darwin"
+Dynamic: license-file
+
+<p align="center"><img src="assets/icon.png" width="84" alt="Claudometer"></p>
+<h1 align="center">Claudometer</h1>
+
+<p align="center">
+  <b>Your Claude usage limits, always visible — right on your taskbar.</b><br>
+  A tiny, elegant desktop widget that shows your live session &amp; weekly usage so you never hit a limit by surprise.
+</p>
+
+<p align="center">
+  <img src="https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux-informational" alt="platform">
+  <img src="https://img.shields.io/badge/python-3.9%2B-blue" alt="python">
+  <img src="https://img.shields.io/badge/license-MIT-green" alt="license">
+  <img src="https://img.shields.io/badge/setup-zero%20config-success" alt="zero config">
+</p>
+
+<p align="center">
+  <img src="assets/hero-windows.png" alt="Claudometer on Windows" width="820">
+</p>
+
+> **Unofficial project — not affiliated with, or endorsed by, Anthropic.** See the [disclaimer](#-disclaimer).
+
+---
+
+## The problem
+
+Claude's plans (Pro / Max / Team) enforce **usage limits** — a rolling **5‑hour session** limit and **weekly** limits. If you use Claude heavily (Claude Code, long sessions), it's easy to burn through them without realizing… until you're suddenly rate‑limited in the middle of something important.
+
+Today, checking where you stand means **opening the `/usage` panel or the app and reading it** — a context switch you have to *remember* to do. There's no ambient, at‑a‑glance signal.
+
+## The solution
+
+**Claudometer keeps your usage on‑screen at all times**, as clean floating text on your taskbar:
+
+<p align="center"><img src="assets/strip.png" alt="Taskbar strip" width="300"></p>
+
+- **`Session 61%`** — how much of your current 5‑hour window is used, with a **live countdown** to reset (`1h 21m left`).
+- **`Weekly 18%`** — your 7‑day all‑models usage.
+- A **color‑coded status dot** (🟢 &lt;50% · 🟡 50–80% · 🔴 &gt;80%) so severity registers in a glance — turning to a clear **"limit reached"** when you're maxed out, plus a graceful *offline* state when there's no data:
+
+<p align="center"><img src="assets/strip-states.png" alt="Color-coded severity and offline states" width="500"></p>
+
+**Click it** for a polished breakdown with per‑meter reset times and per‑model (e.g. Fable) usage:
+
+<p align="center"><img src="assets/popover-themes.png" alt="Light and dark popover" width="820"></p>
+
+### Why you'll want it
+- 🎯 **Pace yourself** — see when you're approaching a limit *before* you hit it.
+- ⚡ **Zero context‑switch** — the number is already there; no panel to open.
+- 🔒 **Zero setup** — reuses your existing Claude login. Nothing to configure.
+- 🪶 **Featherweight** — ~0.03% CPU idle, ~50 MB RAM. You won't notice it.
+- 🖥️ **Stays out of the way** — optionally auto‑hides over fullscreen movies, games, and presentations (or set it to always show).
+- 🔔 **Warns you in time** — optional desktop alerts when you cross 80% / 90%.
+- ⏭️ **Picks up where you left off** — when your session limit resets, one click resumes the interrupted work (or auto‑resume, if you opt in).
+- 🎨 **Looks the part** — supersampled rendering, light/dark aware, adapts to your taskbar.
+- ⚙️ **Yours to tune** — a built‑in **settings panel** (no file editing) for interval, theme, meters, alerts, accent, cost view, fullscreen behavior and resume.
+
+---
+
+## Screenshots
+
+**Windows** — floating strip on the taskbar + click‑to‑open popover with usage meters:
+
+<p align="center"><img src="assets/hero-windows.png" alt="Windows" width="760"></p>
+
+**macOS** — native menu‑bar item with a dropdown breakdown:
+
+<p align="center"><img src="assets/macos-menubar.png" alt="macOS menu bar" width="760"></p>
+
+**Threshold alerts** — a desktop toast the moment you cross a limit you set (default 80% and 90%), for both session and weekly:
+
+<p align="center"><img src="assets/alerts.png" alt="Threshold alert toasts" width="760"></p>
+
+**Estimated cost** *(opt‑in)* — turn on `show_cost` for a today's‑tokens and rough‑dollar line in the popover (a local estimate from your session logs — not a bill):
+
+<p align="center"><img src="assets/popover-cost.png" alt="Estimated cost line in the popover" width="430"></p>
+
+**Always‑visible mode** — set `hide_on_fullscreen = false` and your stats stay readable even over a fullscreen movie, game, or presentation:
+
+<p align="center"><img src="assets/fullscreen.png" alt="Visible over a fullscreen movie" width="760"></p>
+
+---
+
+## Resume when your limit resets
+
+Hit the 5‑hour session limit mid‑task and everything grinds to a halt? Claudometer
+watches your usage recover, so it can help you pick right back up the moment it does.
+
+<p align="center"><img src="assets/resume.png" alt="Resume notifications" width="820"></p>
+
+- **Tier 1 — notify + one click** *(default, safe).* When your session resets, a
+  notification appears; click **Resume** and it opens a terminal in the interrupted
+  session's folder running `claude --resume <id>` for you to continue — supervised.
+- **Tier 2 — auto‑resume** *(opt‑in, off by default).* After a short *"resuming in
+  20s — click to cancel"* window, it resumes **unattended and headless** so work
+  continues while you're away.
+
+> ⚠️ **Tier 2 runs Claude Code with nobody watching.** It's gated behind
+> `resume_auto = true` and ships with guard rails: a turn cap (`--max-turns`) and
+> the safer `acceptEdits` permission mode by default (full
+> `--dangerously-skip-permissions` only if you *also* set
+> `resume_skip_permissions = true`). Enable it only for work you trust to run on
+> its own. Output is written to a log in `~/.claude/`.
+
+Configure both in the [config file](#configuration).
+
+---
+
+## Install
+
+You need a **Claude Pro / Max / Team** subscription and to have **signed into Claude Code** at least once (that's where the credentials live).
+
+> **Heads up:** the `pipx`, `scoop`, `brew`, and download methods below light up once the **first release is published** (a one‑time maintainer step — see [`packaging/`](packaging/README.md)). Until then, **[install from source](#from-source-python-39)** — that always works.
+
+### Easiest — one command (any OS) 🏆
+Installs in an isolated environment and puts `claudometer` on your PATH:
+```bash
+pipx install claudometer      # don't have pipx?  →  python -m pip install --user pipx
+claudometer                   # launch it
+```
+Update anytime with `pipx upgrade claudometer`.
+
+### Windows
+```powershell
+scoop install https://raw.githubusercontent.com/ali-dev178/claudometer/main/packaging/scoop/claudometer.json
+```
+…or grab the **installer** (`ClaudometerSetup.exe`, ticks "start on sign‑in" for you) or the portable **`Claudometer.exe`** from
+[**Releases**](https://github.com/ali-dev178/claudometer/releases) and double‑click.
+
+### macOS
+```bash
+brew install --cask ali-dev178/claudometer/claudometer
+```
+…or download **`Claudometer.dmg`** from [**Releases**](https://github.com/ali-dev178/claudometer/releases) and drag it to Applications.
+
+### From source (Python 3.9+)
+```bash
+git clone https://github.com/ali-dev178/claudometer.git && cd claudometer
+pip install -r requirements.txt
+pythonw.exe app.py bar    # Windows (no console)   ·   python3 app.py   # macOS
+```
+
+> **Unsigned builds:** the downloads aren't code‑signed yet, so on first launch Windows SmartScreen ("More info → Run anyway") or macOS Gatekeeper (right‑click → **Open**) may ask you to confirm. `pipx`, `scoop` and `brew` avoid this.
+>
+> **First‑run tip (Windows):** Windows 11 may tuck new taskbar items away — drag Claudometer where you want it; it remembers the spot.
+
+## Usage
+
+| Command | What you get |
+|---|---|
+| `app.py bar` | **Windows:** floating taskbar strip + popover *(recommended)* |
+| `app.py tray` | **Windows/Linux:** notification‑area tray icon |
+| `app.py both` | **Windows:** taskbar strip **and** tray icon |
+| `app.py` | Default — **macOS:** menu bar · **Windows:** taskbar strip · **Linux:** tray |
+
+**Interactions (taskbar strip):** left‑click = open/close popover · drag = move (remembered) · right‑click = Details / Refresh / Quit.
+
+## Auto‑start on login
+
+**Windows** — press `Win`+`R`, run `shell:startup`, and add a shortcut to:
+```
+pythonw.exe "C:\path\to\claudometer\app.py" bar
+```
+
+**macOS** — add a LaunchAgent at `~/Library/LaunchAgents/com.claudometer.plist`:
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+  <key>Label</key><string>com.claudometer</string>
+  <key>ProgramArguments</key>
+  <array><string>/usr/bin/python3</string><string>/absolute/path/to/claudometer/app.py</string></array>
+  <key>RunAtLoad</key><true/>
+</dict></plist>
+```
+then `launchctl load ~/Library/LaunchAgents/com.claudometer.plist`. (This plist is
+for the from-source install; if you use the standalone `Claudometer.app`, just add
+it to **System Settings → General → Login Items** instead.)
+
+## Configuration
+
+Two ways to set things up — use whichever you prefer:
+
+### ⚙ In‑app settings panel (recommended)
+
+Click **⚙ Settings** in the popover (or right‑click the strip → *Settings…*). Adjust
+theme, meters, accent, poll interval, alerts, the cost view, fullscreen behavior and
+resume — changes apply **immediately** (no restart) and are written to
+`~/.claudometer.toml` for you, so you never have to touch the file.
+
+<p align="center"><img src="assets/settings.png" alt="In-app settings panel (light & dark)" width="820"></p>
+
+> **macOS:** the menu‑bar app is a lighter adapter — its **Settings** submenu exposes
+> what it actually honors (which meters, poll interval) plus **Open config file…** for
+> the rest. Alerts, cost, resume, accent and theme currently apply to the **Windows**
+> strip only (see [Platform support](#platform-support)).
+
+### ✎ Or edit the file by hand
+
+Everything works with no config. To customise manually, copy
+[`claudometer.example.toml`](claudometer.example.toml) to `~/.claudometer.toml`:
+
+```toml
+poll = 90                        # seconds between polls (60–300)
+theme = "auto"                   # auto | light | dark
+metrics = ["session", "weekly"]  # which meters on the strip
+hide_on_fullscreen = true        # false = keep visible even over fullscreen apps
+alerts = true                    # desktop toast on threshold crossings
+alert_thresholds = [80, 90]
+show_cost = false                # estimated token/$ line in the popover
+# accent = "#d97757"             # override the accent color
+
+resume_notify = true             # one-click resume when the session limit resets
+resume_auto = false              # Tier 2: unattended auto-resume (opt-in, risky)
+resume_prompt = "Continue where you left off."
+resume_max_turns = 30            # Tier 2: cap agentic turns
+# resume_skip_permissions = false  # Tier 2: --dangerously-skip-permissions (else acceptEdits)
+```
+
+Environment overrides:
+
+| Env var | Purpose |
+|---|---|
+| `CLAUDOMETER_CONFIG` | Path to the config file (default `~/.claudometer.toml`). |
+| `CLAUDE_CONFIG_DIR` | Where to read Claude credentials/transcripts (default `~/.claude`). |
+| `CLAUDE_WIDGET_POLL` | Poll interval in seconds (60–300). The interval source for the Windows/Linux **tray** (the macOS menu bar polls at a fixed 90s). |
+| `CLAUDE_WIDGET_FAKE` | Testing: `"95,40,0"` = session,weekly,scoped % (skips the network). |
+
+Preview the red/alert state with no real load:
+```powershell
+$env:CLAUDE_WIDGET_FAKE="95,40,0"; py app.py bar
+```
+
+---
+
+## How it works
+
+Claudometer reads the OAuth token Claude Code already stores locally
+(`~/.claude/.credentials.json`, or the macOS Keychain) and polls Anthropic's
+**server‑reported** usage endpoint — the same source the `/usage` panel uses:
+
+```
+GET https://api.anthropic.com/api/oauth/usage
+```
+
+The response maps directly onto the UI: the 5‑hour window → **Session**, the
+7‑day all‑models window → **Weekly**, and any per‑model scoped limits → per‑model
+rows (e.g. **Fable**), shown only when your account actually has one. Tokens are
+refreshed automatically when they expire.
+
+> This is *true plan %* from Anthropic's backend — **not** a local token‑cost
+> estimate (unlike tools that add up `*.jsonl` transcript costs).
+
+### Privacy
+- Your token is read **locally**; the only network call is the authenticated
+  request to `api.anthropic.com`.
+- **No** third‑party servers, **no** telemetry, **no** analytics.
+
+### Behavior notes
+- **Fullscreen auto‑hide** (optional) — by default Claudometer hides itself
+  whenever a fullscreen app is active (movies, games, presentations), using
+  Windows' own `SHQueryUserNotificationState` plus a foreground‑covers‑the‑screen
+  check, then reappears when you exit. Set `hide_on_fullscreen = false` to keep it
+  visible even over fullscreen apps. On macOS the menu bar hides in fullscreen
+  natively.
+- **Performance** — ~0.03% of total CPU idle, ~0.2% while you have the popover
+  open, ~50 MB RAM. The strip only re‑renders when a value changes; the popover
+  only while it's open.
+
+## Platform support
+
+| Platform | UI | Status |
+|---|---|---|
+| **Windows 10/11** | Taskbar strip + click‑to‑open popover | ✅ Full |
+| **macOS** | Menu‑bar item + dropdown | ✅ Menu bar |
+| **Linux** | Notification‑area tray icon | 🧪 Experimental (`app.py tray`) |
+
+> **Feature scope:** the taskbar strip (Windows) has the full feature set —
+> click‑to‑open popover, alerts, estimated cost, resume‑on‑reset, themes, accent,
+> and the config file. The macOS menu bar and Linux tray currently show live
+> usage only. Unifying these is on the roadmap.
+
+## Roadmap
+
+**Shipped:** ✅ desktop alerts · ✅ config file · ✅ estimated cost view · ✅ standalone binaries + release CI.
+
+**Next up:**
+- 📈 A tiny **usage sparkline** over the session
+- 🍎 Unified floating popover on macOS (currently a native menu‑bar item)
+- 🧮 Per‑model cost breakdown & weekly totals
+- 📥 Published **winget** / **Homebrew** listings
+
+Contributions and ideas welcome — open an issue or PR.
+
+## Contributing
+
+```bash
+py -m pip install -r requirements.txt
+py app.py bar
+```
+`usage_core.py` holds the data/auth logic (no UI deps), `render.py` does all the
+Pillow drawing, `settings.py` / `cost.py` / `resume.py` add config, cost
+estimation, and session‑resume, and the platform adapters (`widget_bar.py`,
+`menubar_mac.py`, `tray_windows.py`) are thin. Regenerate the README images with
+`py assets/make_assets.py`.
+
+## ⚠️ Disclaimer
+
+Claudometer is an **independent, unofficial** tool. It is **not affiliated with,
+authorized, or endorsed by Anthropic**. It relies on an **undocumented** usage
+endpoint that may change or break at any time, and reads the local Claude Code
+credentials on your own machine. Use at your own risk, and in accordance with
+Anthropic's Terms of Service. "Claude" is a trademark of Anthropic, PBC.
+
+## License
+
+[MIT](LICENSE) © 2026 Muhammad Ali

claudometer-1.0.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+app.py,sha256=tElOL5h3rFAqlj1y9daAdBneohxyYLp0D6la_VTNDWY,1652
+config.py,sha256=qIGkwX5RQRwFXsA94sD3So3RxqQGp8xu31dlEed9_vI,1308
+cost.py,sha256=yfppGKOXaSALLk1sLK-9cn6hGaneXN-MuF0YwiwMPMs,5136
+menubar_mac.py,sha256=CIlyy33WGdU2H9-fwd56IusDurG8MzhdTOsXgROWRB4,5840
+render.py,sha256=t3k813bx7kWG1bGrf8ySUVRf3rgs_BM5xPG6cHhs9tI,23571
+resume.py,sha256=CW5Gav2If0YwB0SdgiHA3pGSDIdGzJuMBJncD2hOlQU,5813
+settings.py,sha256=acFCRKGE8kJq6K3k5tsnWzul1-SJ1n8_u8yBn08dmPw,10542
+tray_windows.py,sha256=I8-GJoIIiQxd9BhYgqK8tpddUhR8jJ3YE6YBBP4vIRM,5103
+usage_core.py,sha256=PvqU8KxU1G_9N-J8fqmwTfttQQeP4Tpa2F1H1bsG6Pw,22060
+widget_bar.py,sha256=g5aYelvFAtZl2b6Dfu_s_wtpvD_55nG_4Wk_HMTLWes,51666
+claudometer-1.0.0.dist-info/licenses/LICENSE,sha256=3G7a7s2gyvMvNmAgBZYlqTBRP70e2CkHhxRtAMpOY5M,1069
+claudometer-1.0.0.dist-info/METADATA,sha256=uFTNUrp201wOmWks30VUnl0vKePHJVyLVXmIncSGt48,16330
+claudometer-1.0.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+claudometer-1.0.0.dist-info/entry_points.txt,sha256=wBNAagEQT7imBzJYaQTX4naex-VeNA6ZGHBzSE8D1Ds,37
+claudometer-1.0.0.dist-info/top_level.txt,sha256=RdiM4_6nk1E63UlhhgmsiN89Cadz8JABDim1GLqlf8o,86
+claudometer-1.0.0.dist-info/RECORD,,

claudometer-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

claudometer-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[gui_scripts]
+claudometer = app:main

claudometer-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Muhammad Ali
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

claudometer-1.0.0.dist-info/top_level.txt

@@ -0,0 +1,10 @@
+app
+config
+cost
+menubar_mac
+render
+resume
+settings
+tray_windows
+usage_core
+widget_bar

config.py

@@ -0,0 +1,35 @@
+"""Static configuration for the Claude usage widget."""
+
+# This app.
+APP_VERSION = "1.0.0"
+REPO_URL = "https://github.com/ali-dev178/claudometer"
+
+# Server-reported plan-usage endpoint (same one Claude Code's /usage panel calls).
+USAGE_URL = "https://api.anthropic.com/api/oauth/usage"
+
+# OAuth token-refresh endpoints. Anthropic is mid-migration from console -> platform,
+# so we try console first and fall back to platform on connection error / 404.
+TOKEN_URLS = [
+    "https://console.anthropic.com/v1/oauth/token",
+    "https://platform.claude.com/v1/oauth/token",
+]
+
+# Well-known Claude Code OAuth client id (public).
+OAUTH_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e"
+
+# Required beta header for the OAuth usage endpoint.
+BETA_HEADER = "oauth-2025-04-20"
+
+# Network timeout (seconds) for both the usage call and token refresh.
+HTTP_TIMEOUT = 15
+
+# Default poll interval (seconds). Overridable via env CLAUDE_WIDGET_POLL,
+# clamped to [60, 300]. Community tools use 90-180s to stay under rate limits.
+DEFAULT_POLL = 90
+
+# Refresh the access token this many ms before it expires.
+REFRESH_SKEW_MS = 5 * 60 * 1000
+
+# Used in the mandatory "User-Agent: claude-code/<version>" header when the real
+# installed version can't be read. A generic UA gets persistent HTTP 429s.
+FALLBACK_VERSION = "2.1.173"

cost.py

@@ -0,0 +1,121 @@
+"""Estimate today's token usage and cost from local Claude Code transcripts.
+
+Reads ``~/.claude/projects/**/*.jsonl`` (the session logs Claude Code writes),
+sums per-message token counts, and applies Anthropic list prices. This is an
+ESTIMATE of what the same tokens would cost at API rates — it is not your actual
+plan billing (Pro/Max are flat-rate).
+
+Prices: USD per million tokens, verified from the official pricing page
+(platform.claude.com) on 2026-07-10. `cache_write` = 5-minute cache write
+(1.25x input); `cache_read` = cache hit (0.1x input). Prices are matched by model
+family (opus/sonnet/haiku/fable) and assume the current generation — a future
+model sharing a family name but priced differently would use these rates.
+"""
+
+import json
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+
+PRICING = {
+    "opus":   {"input": 5,  "output": 25, "cache_write": 6.25,  "cache_read": 0.50},
+    "sonnet": {"input": 3,  "output": 15, "cache_write": 3.75,  "cache_read": 0.30},
+    "haiku":  {"input": 1,  "output": 5,  "cache_write": 1.25,  "cache_read": 0.10},
+    "fable":  {"input": 10, "output": 50, "cache_write": 12.50, "cache_read": 1.00},
+}
+
+
+def _key_for(model: str):
+    m = str(model or "").lower()
+    if "fable" in m or "mythos" in m:  # Mythos 5 shares Fable 5 pricing
+        return "fable"
+    if "opus" in m:
+        return "opus"
+    if "haiku" in m:
+        return "haiku"
+    if "sonnet" in m:
+        return "sonnet"
+    return None
+
+
+def _n(usage: dict, k: str) -> float:
+    v = usage.get(k)
+    return v if isinstance(v, (int, float)) and not isinstance(v, bool) else 0
+
+
+def _tok(usage: dict) -> float:
+    return (_n(usage, "input_tokens") + _n(usage, "output_tokens")
+            + _n(usage, "cache_creation_input_tokens") + _n(usage, "cache_read_input_tokens"))
+
+
+def _line_cost(usage: dict, key: str) -> float:
+    p = PRICING[key]
+    return (_n(usage, "input_tokens") * p["input"]
+            + _n(usage, "output_tokens") * p["output"]
+            + _n(usage, "cache_creation_input_tokens") * p["cache_write"]
+            + _n(usage, "cache_read_input_tokens") * p["cache_read"]) / 1_000_000.0
+
+
+def compute_today(config_dir=None):
+    """Return {"tokens": int, "cost": float} for usage since local midnight,
+    or None if there's nothing to read."""
+    base = Path(config_dir or os.environ.get("CLAUDE_CONFIG_DIR") or (Path.home() / ".claude"))
+    proj = base / "projects"
+    if not proj.exists():
+        return None
+
+    start = datetime.now().astimezone().replace(hour=0, minute=0, second=0, microsecond=0)
+    cutoff = start.timestamp()
+    # Claude Code writes one line per content block for an assistant message,
+    # all sharing the message id. Input/cache tokens are identical across them
+    # but output_tokens GROW (streaming snapshots), so keep the LAST occurrence
+    # per id (the complete cumulative usage) rather than summing or keeping first.
+    by_id = {}                          # message id -> (usage, key), last wins
+    extra_tokens, extra_cost = 0, 0.0   # lines without an id (counted as-is)
+
+    for f in proj.rglob("*.jsonl"):
+        try:
+            if f.stat().st_mtime < cutoff:  # file untouched today -> skip fast
+                continue
+        except OSError:
+            continue
+        try:
+            with f.open("r", encoding="utf-8") as fh:
+                for line in fh:
+                    if '"usage"' not in line:
+                        continue
+                    try:  # one malformed line must not abort the whole scan
+                        obj = json.loads(line)
+                        if obj.get("type") != "assistant":
+                            continue
+                        ts = obj.get("timestamp")
+                        if isinstance(ts, str):
+                            dt = datetime.fromisoformat(ts.replace("Z", "+00:00"))
+                            if dt.tzinfo is None:
+                                dt = dt.replace(tzinfo=timezone.utc)
+                            if dt < start:
+                                continue
+                        else:
+                            continue  # no valid timestamp -> not counted as "today"
+                        msg = obj.get("message", {})
+                        key = _key_for(msg.get("model", ""))  # may be None (unpriced)
+                        u = msg.get("usage", {})
+                        mid = msg.get("id")
+                        if mid is not None:
+                            by_id[mid] = (u, key)  # tokens still count; cost only if key
+                        else:
+                            extra_tokens += _tok(u)
+                            if key:
+                                extra_cost += _line_cost(u, key)
+                    except Exception:
+                        continue
+        except OSError:
+            continue
+
+    total_tokens = extra_tokens + sum(_tok(u) for u, _ in by_id.values())
+    total_cost = extra_cost + sum(_line_cost(u, key) for u, key in by_id.values() if key)
+    return {"tokens": int(total_tokens), "cost": total_cost}
+
+
+if __name__ == "__main__":
+    print(compute_today())