claude-calc 0.1.0__tar.gz

claude_calc-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hassan Ibrahim
+
+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.

claude_calc-0.1.0/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: claude-calc
+Version: 0.1.0
+Summary: Price your Claude Code session logs and view the spend in a local dashboard
+Author-email: Hassan Ibrahim <eng.hibrahem@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/hibrahem/claude-calc
+Project-URL: Issues, https://github.com/hibrahem/claude-calc/issues
+Keywords: claude,claude-code,anthropic,cost,tokens,dashboard
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Web Environment
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# claude-calc
+
+See what your Claude Code sessions would cost at pay-per-token API rates.
+
+It reads the session logs Claude Code keeps in `~/.claude/projects`, prices
+every API message, and shows the result in a local dashboard: spend over time,
+cost per model split by token type, and projects you can expand down to
+individual sessions.
+
+## Install
+
+```bash
+pipx install claude-calc
+```
+
+or `pip install claude-calc`. Python 3.9 or newer, no other dependencies.
+
+## Use
+
+```bash
+claude-calc
+```
+
+Starts the dashboard on http://localhost:8765 and opens it in your browser.
+Logs are rescanned on every page load and on the Rescan button.
+
+```bash
+claude-calc report
+```
+
+Prints a plain-text summary instead.
+
+Options:
+
+| Flag | Meaning |
+|---|---|
+| `--port 9000` | serve on a different port |
+| `--no-browser` | don't open a browser tab |
+| `--projects-dir DIR` | read logs from somewhere other than `~/.claude/projects` |
+
+## Pricing
+
+Rates are `$/MTok` in `PRICES` inside `claude_calc/costlib.py`, as
+`(input, output, cache_read, cache_write_5m, cache_write_1h)`. Messages are
+deduplicated by API message id, and cache writes are billed at the 5-minute
+or 1-hour rate depending on which the message used. Models with no rate are
+skipped and listed at the bottom of the page.
+
+## Develop
+
+```bash
+git clone https://github.com/hibrahem/claude-calc
+cd claude-calc
+python3 -m claude_calc.cli
+```
+
+Releases publish to PyPI from GitHub Actions when a `v*` tag is pushed.

claude_calc-0.1.0/README.md

@@ -0,0 +1,57 @@
+# claude-calc
+
+See what your Claude Code sessions would cost at pay-per-token API rates.
+
+It reads the session logs Claude Code keeps in `~/.claude/projects`, prices
+every API message, and shows the result in a local dashboard: spend over time,
+cost per model split by token type, and projects you can expand down to
+individual sessions.
+
+## Install
+
+```bash
+pipx install claude-calc
+```
+
+or `pip install claude-calc`. Python 3.9 or newer, no other dependencies.
+
+## Use
+
+```bash
+claude-calc
+```
+
+Starts the dashboard on http://localhost:8765 and opens it in your browser.
+Logs are rescanned on every page load and on the Rescan button.
+
+```bash
+claude-calc report
+```
+
+Prints a plain-text summary instead.
+
+Options:
+
+| Flag | Meaning |
+|---|---|
+| `--port 9000` | serve on a different port |
+| `--no-browser` | don't open a browser tab |
+| `--projects-dir DIR` | read logs from somewhere other than `~/.claude/projects` |
+
+## Pricing
+
+Rates are `$/MTok` in `PRICES` inside `claude_calc/costlib.py`, as
+`(input, output, cache_read, cache_write_5m, cache_write_1h)`. Messages are
+deduplicated by API message id, and cache writes are billed at the 5-minute
+or 1-hour rate depending on which the message used. Models with no rate are
+skipped and listed at the bottom of the page.
+
+## Develop
+
+```bash
+git clone https://github.com/hibrahem/claude-calc
+cd claude-calc
+python3 -m claude_calc.cli
+```
+
+Releases publish to PyPI from GitHub Actions when a `v*` tag is pushed.

claude_calc-0.1.0/claude_calc/__init__.py

@@ -0,0 +1,2 @@
+"""Price Claude Code session logs and view the spend in a local dashboard."""
+__version__ = "0.1.0"

claude_calc-0.1.0/claude_calc/cli.py

@@ -0,0 +1,46 @@
+import argparse
+import os
+import sys
+
+from . import __version__
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser(
+        prog="claude-calc",
+        description="Price your Claude Code session logs and view the spend in a local dashboard.",
+    )
+    p.add_argument("--version", action="version", version=f"claude-calc {__version__}")
+    p.add_argument("--projects-dir", metavar="DIR",
+                   help="folder holding the session logs (default: ~/.claude/projects)")
+    sub = p.add_subparsers(dest="cmd")
+
+    s = sub.add_parser("serve", help="start the dashboard (default)")
+    s.add_argument("-p", "--port", type=int, default=8765)
+    s.add_argument("--no-browser", action="store_true", help="don't open a browser tab")
+
+    sub.add_parser("report", help="print a plain-text summary")
+
+    args = p.parse_args(argv)
+    projects_dir = os.path.expanduser(args.projects_dir) if args.projects_dir else None
+    if projects_dir and not os.path.isdir(projects_dir):
+        p.error(f"no such directory: {projects_dir}")
+
+    if args.cmd == "report":
+        from .report import report
+        report(projects_dir)
+        return 0
+
+    from .server import serve
+    port = getattr(args, "port", 8765)
+    open_browser = not getattr(args, "no_browser", False)
+    try:
+        serve(port=port, open_browser=open_browser, projects_dir=projects_dir)
+    except OSError as e:
+        print(f"Could not start on port {port}: {e.strerror}. Try --port <other>.", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

claude_calc-0.1.0/claude_calc/costlib.py

@@ -0,0 +1,144 @@
+"""Scan Claude Code session logs and price every API message.
+
+Shared by the CLI (cost.py) and the web portal (serve.py).
+"""
+import collections
+import glob
+import json
+import os
+
+# $/MTok: (input, output, cache_read, cache_write_5m, cache_write_1h)
+PRICES = {
+    "claude-fable-5-1": (10, 50, 0.25, 12.5, 20),
+    "claude-fable-5":   (10, 50, 1.00, 12.5, 20),
+    "claude-opus-5":    (5, 25, 0.50, 6.25, 10),
+    "claude-opus-4-8":  (5, 25, 0.50, 6.25, 10),
+    "claude-sonnet-5":  (2, 10, 0.20, 2.5, 4),
+    "claude-haiku-4-5": (1, 5, 0.10, 1.25, 2),
+}
+
+PROJECTS_DIR = os.path.expanduser("~/.claude/projects")
+
+
+def price(model):
+    if model.startswith("claude-haiku-4-5"):
+        return PRICES["claude-haiku-4-5"]
+    return PRICES.get(model)
+
+
+def _first_text(content):
+    """Return the first plain-text piece of a user message, or ''."""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        for part in content:
+            if isinstance(part, dict) and part.get("type") == "text":
+                return part.get("text", "")
+    return ""
+
+
+def _display_project(cwd, dirname):
+    home = os.path.expanduser("~")
+    if cwd:
+        if cwd.startswith(home + "/"):
+            return cwd[len(home) + 1:]
+        return cwd
+    # Fallback: undo the "-Users-name-..." encoding of the directory name.
+    encoded_home = home.replace("/", "-")
+    if dirname.startswith(encoded_home + "-"):
+        return dirname[len(encoded_home) + 1:].replace("-", "/")
+    return dirname
+
+
+def load(projects_dir=PROJECTS_DIR):
+    """Return {"rows": [...], "sessions": {...}, "unknown": {...}, "pricing": {...}}.
+
+    rows: one record per deduplicated assistant API message.
+    sessions: sessionId -> {"project", "started", "title"}.
+    unknown: model -> total tokens for models with no price.
+    """
+    seen = {}
+    sessions = {}
+    pattern = os.path.join(projects_dir, "**", "*.jsonl")
+    for path in glob.glob(pattern, recursive=True):
+        dirname = os.path.basename(os.path.dirname(path))
+        with open(path, errors="replace") as fh:
+            for line in fh:
+                try:
+                    d = json.loads(line)
+                except ValueError:
+                    continue
+                kind = d.get("type")
+                sid = d.get("sessionId")
+                if kind == "user" and sid and not d.get("isSidechain"):
+                    meta = sessions.setdefault(sid, {
+                        "project": _display_project(d.get("cwd"), dirname),
+                        "started": d.get("timestamp", ""),
+                        "title": "",
+                    })
+                    if not meta["title"]:
+                        text = _first_text((d.get("message") or {}).get("content"))
+                        text = " ".join(text.split())
+                        if text and not text.startswith("<"):
+                            meta["title"] = text[:140]
+                    continue
+                if kind != "assistant":
+                    continue
+                m = d.get("message") or {}
+                u = m.get("usage")
+                mid = m.get("id")
+                if not u or not mid:
+                    continue
+                seen[mid] = (d, u, m.get("model", ""), dirname)
+
+    rows = []
+    unknown = collections.Counter()
+    for mid, (d, u, model, dirname) in seen.items():
+        pr = price(model)
+        inp = u.get("input_tokens", 0) or 0
+        out = u.get("output_tokens", 0) or 0
+        cr = u.get("cache_read_input_tokens", 0) or 0
+        cc = u.get("cache_creation") or {}
+        w5 = cc.get("ephemeral_5m_input_tokens")
+        w1 = cc.get("ephemeral_1h_input_tokens")
+        if w5 is None and w1 is None:
+            w5 = u.get("cache_creation_input_tokens", 0)
+            w1 = 0
+        w5 = w5 or 0
+        w1 = w1 or 0
+        if pr is None:
+            unknown[model] += inp + out + cr + w5 + w1
+            continue
+        sid = d.get("sessionId")
+        ts = d.get("timestamp", "")
+        meta = sessions.setdefault(sid, {
+            "project": _display_project(d.get("cwd"), dirname),
+            "started": ts,
+            "title": "",
+        })
+        if ts and (not meta["started"] or ts < meta["started"]):
+            meta["started"] = ts
+        rows.append({
+            "ts": ts,
+            "model": model,
+            "session": sid,
+            "in": inp, "out": out, "cr": cr, "w5": w5, "w1": w1,
+            "c_in": inp * pr[0] / 1e6,
+            "c_out": out * pr[1] / 1e6,
+            "c_cr": cr * pr[2] / 1e6,
+            "c_w": (w5 * pr[3] + w1 * pr[4]) / 1e6,
+        })
+    for r in rows:
+        r["cost"] = r["c_in"] + r["c_out"] + r["c_cr"] + r["c_w"]
+        for k in ("c_in", "c_out", "c_cr", "c_w", "cost"):
+            r[k] = round(r[k], 6)
+    rows.sort(key=lambda r: r["ts"])
+    # Only keep sessions that have priced rows.
+    used = {r["session"] for r in rows}
+    sessions = {k: v for k, v in sessions.items() if k in used}
+    return {
+        "rows": rows,
+        "sessions": sessions,
+        "unknown": {k: v for k, v in unknown.items() if v},
+        "pricing": {k: list(v) for k, v in PRICES.items()},
+    }

claude_calc-0.1.0/claude_calc/report.py

@@ -0,0 +1,49 @@
+"""Plain-text spend report, the same summary the original script printed."""
+import collections
+
+from .costlib import load
+
+
+def report(projects_dir=None):
+    data = load(projects_dir) if projects_dir else load()
+    rows = data["rows"]
+    sessions = data["sessions"]
+
+    by_model = collections.defaultdict(lambda: collections.Counter())
+    by_proj = collections.defaultdict(float)
+    by_month = collections.defaultdict(float)
+    by_session = collections.defaultdict(float)
+    for r in rows:
+        c = by_model[r["model"]]
+        c["msgs"] += 1
+        for k in ("in", "out", "cr", "w5", "w1", "c_in", "c_out", "c_cr", "c_w", "cost"):
+            c[k] += r[k]
+        by_proj[sessions[r["session"]]["project"]] += r["cost"]
+        by_month[r["ts"][:7]] += r["cost"]
+        by_session[r["session"]] += r["cost"]
+
+    total = sum(c["cost"] for c in by_model.values())
+    print(f"Deduped API messages priced: {len(rows)}")
+    print(f"\nTOTAL: ${total:,.2f}\n")
+    if not rows:
+        print("No priced messages found.")
+        return
+    print(f"{'model':28}{'msgs':>7}{'input':>12}{'output':>11}{'cache_rd':>13}{'cw_5m':>11}{'cw_1h':>12}{'cost':>11}")
+    for mdl, c in sorted(by_model.items(), key=lambda x: -x[1]['cost']):
+        print(f"{mdl:28}{c['msgs']:7d}{c['in']:12,d}{c['out']:11,d}{c['cr']:13,d}{c['w5']:11,d}{c['w1']:12,d}{c['cost']:11,.2f}")
+    print("\nCost split by token type:")
+    for k, lab in [("c_in", "uncached input"), ("c_out", "output"), ("c_cr", "cache reads"), ("c_w", "cache writes")]:
+        v = sum(c[k] for c in by_model.values())
+        print(f"  {lab:16}${v:9,.2f}  ({v/total*100:4.1f}%)")
+    print("\nBy month:")
+    for k in sorted(by_month):
+        print(f"  {k}  ${by_month[k]:9,.2f}")
+    print("\nBy project:")
+    for k, v in sorted(by_proj.items(), key=lambda x: -x[1]):
+        print(f"  ${v:9,.2f}  {k}")
+    print("\nTop 10 sessions:")
+    for k, v in sorted(by_session.items(), key=lambda x: -x[1])[:10]:
+        s = sessions[k]
+        print(f"  ${v:8,.2f}  {s['started'][:10]}  {k[:8]}  {s['project']}")
+    if data["unknown"]:
+        print("\nSkipped (unpriced) models, total tokens:", data["unknown"])

claude_calc-0.1.0/claude_calc/server.py

@@ -0,0 +1,58 @@
+"""Local web portal for Claude Code spend."""
+import json
+import os
+import threading
+import time
+import webbrowser
+from functools import partial
+from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
+
+from .costlib import load
+
+STATIC = os.path.join(os.path.dirname(os.path.abspath(__file__)), "static")
+
+
+class Handler(SimpleHTTPRequestHandler):
+    def __init__(self, *a, projects_dir=None, **kw):
+        self.projects_dir = projects_dir
+        super().__init__(*a, directory=STATIC, **kw)
+
+    def do_GET(self):
+        if self.path.split("?")[0] == "/api/rows":
+            t0 = time.time()
+            data = load(self.projects_dir) if self.projects_dir else load()
+            data["generated_at"] = time.strftime("%Y-%m-%dT%H:%M:%S")
+            data["scan_ms"] = int((time.time() - t0) * 1000)
+            body = json.dumps(data).encode()
+            self.send_response(200)
+            self.send_header("Content-Type", "application/json")
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+            return
+        if self.path == "/":
+            self.path = "/index.html"
+        return super().do_GET()
+
+    def end_headers(self):
+        self.send_header("Cache-Control", "no-store")
+        super().end_headers()
+
+    def log_message(self, fmt, *args):
+        if "/api/" in (args[0] if args else ""):
+            super().log_message(fmt, *args)
+
+
+def serve(port=8765, open_browser=True, projects_dir=None):
+    handler = partial(Handler, projects_dir=projects_dir)
+    srv = ThreadingHTTPServer(("127.0.0.1", port), handler)
+    url = f"http://localhost:{port}"
+    print(f"Claude Code spend portal: {url}  (Ctrl+C to stop)")
+    if open_browser:
+        threading.Timer(0.5, webbrowser.open, args=(url,)).start()
+    try:
+        srv.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        srv.server_close()