cctrack 0.1.0__py3-none-any.whl

cctrack/__init__.py

@@ -0,0 +1,342 @@
+#!/usr/bin/env python3
+"""cctrack — Claude Code cost reporter.
+
+Scans JSONL logs from Claude Code and Sandy sandboxes,
+tallies token usage, and prints daily + monthly cost summaries.
+
+Usage:
+    python cctrack.py                          # local only
+    python cctrack.py --days 7                 # last 7 days
+    python cctrack.py --remote dgx macbook-air # aggregate with remote hosts
+    python cctrack.py --dirs ~/custom          # custom log directory
+"""
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+from collections import defaultdict
+from datetime import datetime, timezone
+from pathlib import Path
+
+# ── Rate card (per million tokens) ──────────────────────────────────────
+
+# Longer/more-specific prefixes MUST come first — "claude-opus-4-6" would
+# otherwise match "claude-opus-4" and get the wrong rate.
+RATES = [
+    {"family": "claude-opus-4-6",   "input": 5.0,   "output": 25.0,  "cache_read": 0.50,  "cache_write": 6.25},
+    {"family": "claude-opus-4-5",   "input": 5.0,   "output": 25.0,  "cache_read": 0.50,  "cache_write": 6.25},
+    {"family": "claude-opus-4",     "input": 15.0,  "output": 75.0,  "cache_read": 1.50,  "cache_write": 18.75},
+    {"family": "claude-sonnet-4",   "input": 3.0,   "output": 15.0,  "cache_read": 0.30,  "cache_write": 3.75},
+    {"family": "claude-haiku-4-5",  "input": 1.0,   "output": 5.0,   "cache_read": 0.10,  "cache_write": 1.25},
+    {"family": "claude-haiku-3",    "input": 0.80,  "output": 4.0,   "cache_read": 0.08,  "cache_write": 1.00},
+]
+
+SONNET_RATES = RATES[3]  # fallback
+
+
+def get_rates(model: str) -> dict:
+    """Match model name by prefix. Unknown models fall back to Sonnet."""
+    for r in RATES:
+        if model.startswith(r["family"]):
+            return r
+    return SONNET_RATES
+
+
+def calculate_cost(model: str, input_t: int, output_t: int, cache_read: int, cache_write: int) -> float:
+    r = get_rates(model)
+    return (
+        input_t / 1_000_000 * r["input"]
+        + output_t / 1_000_000 * r["output"]
+        + cache_read / 1_000_000 * r["cache_read"]
+        + cache_write / 1_000_000 * r["cache_write"]
+    )
+
+
+# ── File discovery ──────────────────────────────────────────────────────
+
+def default_dirs() -> list[str]:
+    home = Path.home()
+    dirs = [str(home / ".claude" / "projects")]
+    sandy = home / ".sandy" / "sandboxes"
+    if sandy.exists():
+        dirs.append(str(sandy))
+    return dirs
+
+
+def discover_files(dirs: list[str]) -> list[str]:
+    """Walk directories, return all .jsonl file paths."""
+    files = []
+    for d in dirs:
+        p = Path(d)
+        if not p.exists():
+            continue
+        for f in p.rglob("*.jsonl"):
+            files.append(str(f))
+    return files
+
+
+# ── Remote host support ────────────────────────────────────────────────
+
+REMOTE_DIRS = "~/.claude/projects ~/.sandy/sandboxes"
+
+
+def fetch_remote_jsonl(host: str) -> str:
+    """SSH to host and cat all JSONL files from default dirs. Returns raw output."""
+    # Single SSH call: find all .jsonl files and cat them with a separator
+    # so we can split per-file for dedup. We use a marker line between files.
+    cmd = [
+        "ssh", "-o", "ConnectTimeout=10", "-o", "BatchMode=yes", host,
+        f"find {REMOTE_DIRS} -name '*.jsonl' -exec echo '___CCTRACK_FILE_SEP___' \\; -exec cat {{}} \\; 2>/dev/null"
+    ]
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
+        if result.returncode != 0 and not result.stdout:
+            print(f"  Warning: SSH to {host} failed: {result.stderr.strip()}", file=sys.stderr)
+            return ""
+        return result.stdout
+    except subprocess.TimeoutExpired:
+        print(f"  Warning: SSH to {host} timed out", file=sys.stderr)
+        return ""
+    except FileNotFoundError:
+        print(f"  Warning: ssh command not found", file=sys.stderr)
+        return ""
+
+
+def parse_remote_events(host: str) -> list[dict]:
+    """Fetch and parse JSONL from a remote host via SSH."""
+    print(f"  Fetching from {host}...", file=sys.stderr)
+    raw = fetch_remote_jsonl(host)
+    if not raw:
+        return []
+
+    # Split into per-file chunks for correct dedup (per-file, not global)
+    chunks = raw.split("___CCTRACK_FILE_SEP___")
+    all_events = []
+    for chunk in chunks:
+        events = parse_lines(chunk.splitlines())
+        all_events.extend(events)
+    return all_events
+
+
+# ── JSONL parsing + dedup ───────────────────────────────────────────────
+
+def parse_lines(lines: list[str]) -> list[dict]:
+    """Parse JSONL lines from a single file. Dedup by request_id (last wins)."""
+    by_request_id: dict[str, dict] = {}
+    no_request_id: list[dict] = []
+
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            event = json.loads(line)
+        except (json.JSONDecodeError, ValueError):
+            continue
+
+        if event.get("type") != "assistant":
+            continue
+
+        usage = event.get("message", {}).get("usage", {})
+        input_t = usage.get("input_tokens", 0)
+        output_t = usage.get("output_tokens", 0)
+        cache_read = usage.get("cache_read_input_tokens", 0)
+        cache_write = usage.get("cache_creation_input_tokens", 0)
+
+        if input_t == 0 and output_t == 0 and cache_read == 0 and cache_write == 0:
+            continue
+
+        entry = {
+            "model": event.get("message", {}).get("model", ""),
+            "timestamp": event.get("timestamp", ""),
+            "input": input_t,
+            "output": output_t,
+            "cache_read": cache_read,
+            "cache_write": cache_write,
+        }
+
+        req_id = event.get("requestId", "")
+        if req_id:
+            by_request_id[req_id] = entry
+        else:
+            no_request_id.append(entry)
+
+    return list(by_request_id.values()) + no_request_id
+
+
+def parse_events(files: list[str]) -> list[dict]:
+    """Parse all local JSONL files. Dedup by request_id (last event wins per file)."""
+    all_events = []
+    for path in files:
+        try:
+            with open(path, "r", errors="replace") as f:
+                events = parse_lines(f.readlines())
+                all_events.extend(events)
+        except (OSError, IOError):
+            continue
+    return all_events
+
+
+# ── Aggregation ─────────────────────────────────────────────────────────
+
+def new_bucket() -> dict:
+    return {"input": 0, "output": 0, "cache_read": 0, "cache_write": 0, "cost": 0.0}
+
+
+def aggregate(events: list[dict]) -> tuple[dict, dict]:
+    """
+    Returns:
+        daily: {date_str: {input, output, cache_read, cache_write, cost}}
+        monthly: {month_str: {input, output, cache_read, cache_write, cost}}
+    """
+    daily = defaultdict(new_bucket)
+    monthly = defaultdict(new_bucket)
+
+    for e in events:
+        ts = e["timestamp"]
+        if not ts:
+            continue
+
+        try:
+            dt = datetime.fromisoformat(ts.replace("Z", "+00:00"))
+        except (ValueError, AttributeError):
+            continue
+
+        date_str = dt.strftime("%Y-%m-%d")
+        month_str = dt.strftime("%Y-%m")
+
+        cost = calculate_cost(e["model"], e["input"], e["output"], e["cache_read"], e["cache_write"])
+
+        for bucket in (daily[date_str], monthly[month_str]):
+            bucket["input"] += e["input"]
+            bucket["output"] += e["output"]
+            bucket["cache_read"] += e["cache_read"]
+            bucket["cache_write"] += e["cache_write"]
+            bucket["cost"] += cost
+
+    return dict(daily), dict(monthly)
+
+
+# ── Output ──────────────────────────────────────────────────────────────
+
+def format_tokens(n: int) -> str:
+    return f"{n:,}"
+
+
+def total_tokens(b: dict) -> int:
+    return b["input"] + b["output"] + b["cache_read"] + b["cache_write"]
+
+
+def print_report(daily: dict, monthly: dict, days: int | None = None):
+    if not daily and not monthly:
+        print("cctrack — no log data found")
+        print()
+        print("Looked in:")
+        for d in default_dirs():
+            print(f"  {d}")
+        return
+
+    now = datetime.now(timezone.utc)
+    current_month = now.strftime("%Y-%m")
+    current_month_name = now.strftime("%B %Y")
+
+    sorted_days = sorted(daily.keys(), reverse=True)
+    sorted_months = sorted(monthly.keys(), reverse=True)
+
+    # Header
+    print("cctrack — Claude Code Cost Report")
+    print("══════════════════════════════════")
+    print()
+
+    # Current month-to-date
+    if current_month in monthly:
+        m = monthly[current_month]
+        current_days = [d for d in sorted_days if d.startswith(current_month)]
+        days_active = len(current_days)
+        day_of_month = now.day
+        print(f"{current_month_name} — month to date (day {day_of_month}, {days_active} active)")
+        print("───────────────────────────────────────")
+        print(f"  Input tokens:   {format_tokens(m['input']):>15}")
+        print(f"  Output tokens:  {format_tokens(m['output']):>15}")
+        if m['cache_read'] or m['cache_write']:
+            print(f"  Cache read:     {format_tokens(m['cache_read']):>15}")
+            print(f"  Cache write:    {format_tokens(m['cache_write']):>15}")
+        print(f"  Total tokens:   {format_tokens(total_tokens(m)):>15}")
+        print(f"  Total cost:     ${m['cost']:.2f}")
+        if days_active > 0:
+            avg_daily = m['cost'] / days_active
+            projected = avg_daily * 30
+            print(f"  Avg/day:        ${avg_daily:.2f}")
+            print(f"  Projected/mo:   ${projected:.2f} (based on {days_active}-day avg)")
+        print()
+
+    # Daily breakdown (current month first, then previous)
+    current_month_days = [d for d in sorted_days if d.startswith(current_month)]
+    prev_month_days = [d for d in sorted_days if not d.startswith(current_month)]
+
+    if current_month_days:
+        print("Daily breakdown:")
+        print(f"  {'Date':<12} {'Input':>12} {'Output':>12} {'Cache R':>12} {'Cache W':>12} {'Cost':>10}")
+        print(f"  {'─'*12} {'─'*12} {'─'*12} {'─'*12} {'─'*12} {'─'*10}")
+        display_days = current_month_days
+        if days is not None:
+            display_days = display_days[:days]
+        for date_str in display_days:
+            d = daily[date_str]
+            print(f"  {date_str:<12} {format_tokens(d['input']):>12} {format_tokens(d['output']):>12} {format_tokens(d['cache_read']):>12} {format_tokens(d['cache_write']):>12} ${d['cost']:>8.2f}")
+
+    # Previous months summary
+    prev_months = [m for m in sorted_months if m != current_month]
+    if prev_months:
+        print()
+        print("Previous months:")
+        print(f"  {'Month':<12} {'Input':>12} {'Output':>12} {'Cache R':>12} {'Cache W':>12} {'Cost':>10}")
+        print(f"  {'─'*12} {'─'*12} {'─'*12} {'─'*12} {'─'*12} {'─'*10}")
+        for month_str in prev_months:
+            m = monthly[month_str]
+            month_days = [d for d in prev_month_days if d.startswith(month_str)]
+            days_str = f" ({len(month_days)}d)" if month_days else ""
+            print(f"  {month_str + days_str:<12} {format_tokens(m['input']):>12} {format_tokens(m['output']):>12} {format_tokens(m['cache_read']):>12} {format_tokens(m['cache_write']):>12} ${m['cost']:>8.2f}")
+
+    print()
+
+
+# ── CLI ─────────────────────────────────────────────────────────────────
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Claude Code cost reporter — scans JSONL logs and reports token usage + cost"
+    )
+    parser.add_argument(
+        "--days", type=int, default=None,
+        help="Limit daily breakdown to last N days"
+    )
+    parser.add_argument(
+        "--dirs", nargs="+", default=None,
+        help="Custom log directories to scan (default: ~/.claude/projects and ~/.sandy/sandboxes)"
+    )
+    parser.add_argument(
+        "--remote", nargs="+", default=None, metavar="HOST",
+        help="SSH hosts to fetch logs from (e.g. dgx macbook-air user@server)"
+    )
+    args = parser.parse_args()
+
+    # Local events
+    dirs = args.dirs if args.dirs else default_dirs()
+    files = discover_files(dirs)
+    events = parse_events(files)
+
+    # Remote events
+    if args.remote:
+        for host in args.remote:
+            remote_events = parse_remote_events(host)
+            events.extend(remote_events)
+
+    daily, monthly = aggregate(events)
+    print_report(daily, monthly, days=args.days)
+
+
+if __name__ == "__main__":
+    main()

cctrack/__main__.py

@@ -0,0 +1,3 @@
+from cctrack import main
+
+main()

cctrack-0.1.0.dist-info/METADATA

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: cctrack
+Version: 0.1.0
+Summary: Claude Code cost tracker — scans JSONL logs and reports token usage + estimated cost
+Project-URL: Homepage, https://github.com/ksred/cctrack
+Project-URL: Repository, https://github.com/ksred/cctrack
+Project-URL: Issues, https://github.com/ksred/cctrack/issues
+Author: Dan Rapp
+License-Expression: MIT
+License-File: LICENSE
+Keywords: anthropic,claude,claude-code,cost,tokens
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# cctrack
+
+A lightweight CLI tool that scans [Claude Code](https://docs.anthropic.com/en/docs/claude-code) JSONL logs and reports token usage and estimated cost. Zero dependencies, runs anywhere Python 3.10+ is available.
+
+## Install
+
+```bash
+# Run directly (no install needed)
+uvx cctrack
+
+# Or install globally
+uv tool install cctrack
+```
+
+## Usage
+
+```bash
+# Scan local logs and print report
+cctrack
+
+# Last 7 days only
+cctrack --days 7
+
+# Aggregate with remote machines via SSH
+cctrack --remote dgx macbook-air
+
+# Custom log directories
+cctrack --dirs ~/.claude/projects ~/.sandy/sandboxes
+```
+
+## Example output
+
+```
+cctrack — Claude Code Cost Report
+══════════════════════════════════
+
+April 2026 — month to date (day 1, 1 active)
+───────────────────────────────────────
+  Input tokens:            23,381
+  Output tokens:          199,069
+  Cache read:          30,862,977
+  Cache write:          1,051,023
+  Total tokens:        32,136,450
+  Total cost:     $25.85
+  Avg/day:        $25.85
+  Projected/mo:   $775.50 (based on 1-day avg)
+
+Daily breakdown:
+  Date                Input       Output      Cache R      Cache W       Cost
+  ──────────── ──────────── ──────────── ──────────── ──────────── ──────────
+  2026-04-01         23,381      199,069   30,862,977    1,051,023 $   25.85
+```
+
+## What it does
+
+1. Walks `~/.claude/projects/` and `~/.sandy/sandboxes/` for JSONL log files
+2. Parses `assistant` events with token usage
+3. Deduplicates by `requestId` (last event wins, matching Claude Code's semantics)
+4. Calculates cost using Anthropic's published rates per model
+5. Prints daily breakdown with input/output/cache token splits and monthly summaries
+
+## Remote aggregation
+
+With `--remote`, cctrack SSHs to each host (one call per host) and streams back all JSONL content for local parsing. Requires SSH key auth.
+
+```bash
+# Aggregate this machine + DGX server + laptop
+cctrack --remote dgx macbook-air
+```
+
+## Rate card
+
+Prices per million tokens, from [Anthropic's pricing page](https://www.anthropic.com/pricing):
+
+| Model | Input | Output | Cache Read | Cache Write |
+|---|---|---|---|---|
+| Opus 4.6 / 4.5 | $5.00 | $25.00 | $0.50 | $6.25 |
+| Opus 4 / 4.1 | $15.00 | $75.00 | $1.50 | $18.75 |
+| Sonnet 4.x | $3.00 | $15.00 | $0.30 | $3.75 |
+| Haiku 4.5 | $1.00 | $5.00 | $0.10 | $1.25 |
+| Haiku 3.x | $0.80 | $4.00 | $0.08 | $1.00 |
+
+Unknown models fall back to Sonnet rates.
+
+## Origins
+
+This is a Python rewrite of the Go-based [cctrack dashboard](https://github.com/ksred/cctrack). The Go version provides a full web dashboard with real-time updates, session explorer, and project breakdown. This Python version strips it down to the essentials: a single command that parses logs and prints a cost report. The JSONL parsing logic, deduplication strategy, and rate card are ported directly from the Go implementation.
+
+## License
+
+[MIT](LICENSE)

cctrack-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+cctrack/__init__.py,sha256=IrSOjvION4Qj-zI1mNnkGV6cukuHTVqXFMN6vqXxo_M,13307
+cctrack/__main__.py,sha256=md2QSn4SrSK-4i-y-APpj12Tb6eXTEYErUirBmjPB1I,33
+cctrack-0.1.0.dist-info/METADATA,sha256=EpWhNuubXV1v59oW1TxFfN7_RZwf4v0-zdx-85fWe5U,4195
+cctrack-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+cctrack-0.1.0.dist-info/entry_points.txt,sha256=7VbGGKr38GwJ0YjzqepgpL1RIbeVj6lK0sSdJ3md_Gs,41
+cctrack-0.1.0.dist-info/licenses/LICENSE,sha256=m_p7Y3rYS5a2MD93VXSfeWsXVfi9E6gdShfcll5HYI8,1065
+cctrack-0.1.0.dist-info/RECORD,,

cctrack-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

cctrack-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cctrack = cctrack:main

cctrack-0.1.0.dist-info/licenses/LICENSE

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