aimpg 0.2.0__tar.gz → 0.3.1__tar.gz

{aimpg-0.2.0 → aimpg-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: aimpg
-Version: 0.2.0
+Version: 0.3.1
 Summary: Real-world energy per solved task for AI coding agents
 Project-URL: Homepage, https://github.com/kumarganduri/aimpg
 Project-URL: Issues, https://github.com/kumarganduri/aimpg/issues
@@ -28,28 +28,47 @@ uvx aimpg report
 
 ```
 YOUR AI CODING
-  Energy   11.34 kWh – 92.22 kWh
-           ≈ boiling a litre of water in a kettle 110–920 times · driving an electric car 67–540 km · 5.2–42.2 kg CO₂
-  Money    $1,210 API-equivalent (Anthropic's published prices)
-  Output   328 commits made with AI help
+  Energy   14.46 kWh – 130.59 kWh
+           ≈ boiling a litre of water in a kettle 140–1,300 times · driving an electric car 85–770 km · 6.6–59.8 kg CO₂
+  Money    $1,284 API-equivalent (Anthropic's published prices)
+  Output   353 commits made with AI help
 
-  A typical kept commit:  37.4 Wh – 283.5 Wh ≈ 2–17 full phone charges · $3.62
+  A typical kept commit:  36.6 Wh – 313.0 Wh ≈ 2–18 full phone charges · $2.05
 
 WHAT WOULD HAVE SAVED THE MOST (measured on your logs; upper bounds that overlap)
-  1. Start a fresh session after each commit: up to 44% less energy, $367
-     44% of your AI energy went to re-reading conversation from before your last commit.
+  1. Start a fresh session after each commit: up to 45% less energy, $397
+     45% of your AI energy went to re-reading conversation from before your last commit.
      → After committing, start a new session (or /clear) for the next task.
-  2. Use a mid-size model for routine work: up to 16% less energy, $316
+  2. Use a mid-size model for routine work: up to 16% less energy, $333
      94% of your AI energy ran on the largest models (Opus/Fable class).
      → Check a cheaper model is good enough on your own commits: `aimpg replay models`.
+
+WORKING CHANGES (commits that shipped and lasted 30 days)
+  Available on 2026-10-22: aimpg is keeping your history so it can tell.
 ```
 
 *(Real output from the author's last 30 days.)*
 
 ## What you can do with it
 
+### 0. See it live while you work
+```bash
+uv tool install aimpg && aimpg live install     # shows the change, asks y/N, keeps a backup
+```
+```
+⚡ task $1.96 · usual $2.05 · ctx 160k (92% from before your last commit) · /clear ≈ -92% per request · 5h 63%
+```
+After the agent commits, one line for you only (never sent to the model): *"that commit cost $2.40 over 31 AI requests. 92% of the context is from earlier work: /clear before the next task saves ~92% per request."* Undo with `aimpg live uninstall`.
+
+### Using Cursor?
+Cursor keeps its token counts online. Download them at **cursor.com/dashboard → Usage → Export CSV**, then:
+```bash
+aimpg report --cursor-usage ~/Downloads/usage-events.csv --cursor-repo ~/code/myproject
+```
+Team export? Add `--cursor-user "Your Name"` to count only your rows.
+
 ### 1. See your AI footprint in terms you can picture
-`aimpg report` reads the Claude Code logs already on your machine and ties every AI request to the git commit it produced. Energy is shown as an honest range and translated into kettles, phone charges, EV kilometres and CO₂. Money is the API-equivalent cost at Anthropic's published prices (for subscribers, what the same work would cost on the API).
+`aimpg report` reads the Claude Code (and Codex CLI) logs already on your machine and ties every AI request to the git commit it produced. Energy is shown as an honest range and translated into kettles, phone charges, EV kilometres and CO₂. Money is the API-equivalent cost at Anthropic's published prices (for subscribers, what the same work would cost on the API).
 
 ### 2. Get tips measured on your own habits, not generic advice
 The receipt replays your own logs under "what if" rules and tells you what would have saved the most, in Wh and dollars. For example: how much energy went into re-reading old conversation in long sessions, or into running the biggest model for routine fixes.
@@ -99,13 +118,15 @@ One row per AI-assisted commit: date, repo, energy range, CO₂ range and cost.
 
 **Matching requests to commits:** when the agent runs `git commit`, the commit lands inside that tool call, so the match is exact. Within a session, requests since the previous commit belong to the next one. Work before a 2h+ break is shown separately as *lead-up*. Hand-made commits are matched only if you authored them and they touch files the session edited. On the author's history, a hand-labeled check matched 20/20 commits correctly (`evals/`).
 
-**Energy:** a physical formula, not a price proxy. Prefill compute for new input, one KV-cache re-read per output token (so long contexts cost more), plus datacenter overhead. Model sizes aren't public, so every number is a range. Sources for every factor are in [`aimpg/factors.json`](aimpg/factors.json), [`aimpg/prices.json`](aimpg/prices.json) and [`aimpg/equivalences.json`](aimpg/equivalences.json).
+**Working changes:** aimpg keeps a small history of what each commit cost (never prompts or code), because Claude Code deletes its own logs after 30 days. Once a commit is 30 days old, it is judged: still on the main branch and not reverted or largely rewritten counts as a *working change*. The receipt then shows **cost per working change** and a **waste ratio** (AI spend on work that didn't last).
+
+**Energy:** a physical formula, not a price proxy. Prefill compute for new input, one KV-cache re-read per output token (so long contexts cost more), plus datacenter overhead. Model sizes aren't public, so every number is a range. Overheads follow Google's full-stack measurement of a median Gemini prompt (chips, host CPU and memory, idle capacity, cooling ≈ 1.7× the chips alone), and a chat-sized prompt on a mid-size model comes out at 0.017–0.34 Wh, bracketing Google's disclosed 0.24 Wh ([arXiv 2508.15734](https://arxiv.org/pdf/2508.15734)). Sources for every factor are in [`aimpg/factors.json`](aimpg/factors.json), [`aimpg/prices.json`](aimpg/prices.json) and [`aimpg/equivalences.json`](aimpg/equivalences.json).
 
 **Replays:** each run starts from the code just before your commit, in a fresh, history-free copy, inside a macOS sandbox. The only network allowed is the model API, through an allowlisting proxy. Your own tests judge the result, and edited tests are always restored before judging. Every token count is cross-checked against Claude Code's own totals. Details are in [docs/designs/aimpg-design.md](docs/designs/aimpg-design.md).
 
 ## Limits (honest list)
 
-- Claude Code logs only, for now. Replays need macOS and an Anthropic API key (about $0.10–0.30 per run).
+- Claude Code and Codex CLI logs are read automatically. Cursor keeps token usage on its servers, so it needs its usage export (below), and that export doesn't say which folder the work was in: give `--cursor-repo` and requests are matched to your next own commit there by time alone (shown as "by time only"). Codex's model prices aren't in the table yet; its requests count toward energy but are listed as unpriced. Replays need macOS and an Anthropic API key (about $0.10–0.30 per run).
 - Energy is an estimate with a wide range; dollars are close (within about 7% of Claude Code's own session totals on the author's logs).
 - Tips are upper bounds and overlap; they can't be added together.
 - Replays from commit messages alone are hard (12% solved on the author's repo); `--task-mode tests` shows the agent the tests, which makes tasks easier than real work but keeps comparisons fair.

{aimpg-0.2.0 → aimpg-0.3.1}/README.md

@@ -8,28 +8,47 @@ uvx aimpg report
 
 ```
 YOUR AI CODING
-  Energy   11.34 kWh – 92.22 kWh
-           ≈ boiling a litre of water in a kettle 110–920 times · driving an electric car 67–540 km · 5.2–42.2 kg CO₂
-  Money    $1,210 API-equivalent (Anthropic's published prices)
-  Output   328 commits made with AI help
+  Energy   14.46 kWh – 130.59 kWh
+           ≈ boiling a litre of water in a kettle 140–1,300 times · driving an electric car 85–770 km · 6.6–59.8 kg CO₂
+  Money    $1,284 API-equivalent (Anthropic's published prices)
+  Output   353 commits made with AI help
 
-  A typical kept commit:  37.4 Wh – 283.5 Wh ≈ 2–17 full phone charges · $3.62
+  A typical kept commit:  36.6 Wh – 313.0 Wh ≈ 2–18 full phone charges · $2.05
 
 WHAT WOULD HAVE SAVED THE MOST (measured on your logs; upper bounds that overlap)
-  1. Start a fresh session after each commit: up to 44% less energy, $367
-     44% of your AI energy went to re-reading conversation from before your last commit.
+  1. Start a fresh session after each commit: up to 45% less energy, $397
+     45% of your AI energy went to re-reading conversation from before your last commit.
      → After committing, start a new session (or /clear) for the next task.
-  2. Use a mid-size model for routine work: up to 16% less energy, $316
+  2. Use a mid-size model for routine work: up to 16% less energy, $333
      94% of your AI energy ran on the largest models (Opus/Fable class).
      → Check a cheaper model is good enough on your own commits: `aimpg replay models`.
+
+WORKING CHANGES (commits that shipped and lasted 30 days)
+  Available on 2026-10-22: aimpg is keeping your history so it can tell.
 ```
 
 *(Real output from the author's last 30 days.)*
 
 ## What you can do with it
 
+### 0. See it live while you work
+```bash
+uv tool install aimpg && aimpg live install     # shows the change, asks y/N, keeps a backup
+```
+```
+⚡ task $1.96 · usual $2.05 · ctx 160k (92% from before your last commit) · /clear ≈ -92% per request · 5h 63%
+```
+After the agent commits, one line for you only (never sent to the model): *"that commit cost $2.40 over 31 AI requests. 92% of the context is from earlier work: /clear before the next task saves ~92% per request."* Undo with `aimpg live uninstall`.
+
+### Using Cursor?
+Cursor keeps its token counts online. Download them at **cursor.com/dashboard → Usage → Export CSV**, then:
+```bash
+aimpg report --cursor-usage ~/Downloads/usage-events.csv --cursor-repo ~/code/myproject
+```
+Team export? Add `--cursor-user "Your Name"` to count only your rows.
+
 ### 1. See your AI footprint in terms you can picture
-`aimpg report` reads the Claude Code logs already on your machine and ties every AI request to the git commit it produced. Energy is shown as an honest range and translated into kettles, phone charges, EV kilometres and CO₂. Money is the API-equivalent cost at Anthropic's published prices (for subscribers, what the same work would cost on the API).
+`aimpg report` reads the Claude Code (and Codex CLI) logs already on your machine and ties every AI request to the git commit it produced. Energy is shown as an honest range and translated into kettles, phone charges, EV kilometres and CO₂. Money is the API-equivalent cost at Anthropic's published prices (for subscribers, what the same work would cost on the API).
 
 ### 2. Get tips measured on your own habits, not generic advice
 The receipt replays your own logs under "what if" rules and tells you what would have saved the most, in Wh and dollars. For example: how much energy went into re-reading old conversation in long sessions, or into running the biggest model for routine fixes.
@@ -79,13 +98,15 @@ One row per AI-assisted commit: date, repo, energy range, CO₂ range and cost.
 
 **Matching requests to commits:** when the agent runs `git commit`, the commit lands inside that tool call, so the match is exact. Within a session, requests since the previous commit belong to the next one. Work before a 2h+ break is shown separately as *lead-up*. Hand-made commits are matched only if you authored them and they touch files the session edited. On the author's history, a hand-labeled check matched 20/20 commits correctly (`evals/`).
 
-**Energy:** a physical formula, not a price proxy. Prefill compute for new input, one KV-cache re-read per output token (so long contexts cost more), plus datacenter overhead. Model sizes aren't public, so every number is a range. Sources for every factor are in [`aimpg/factors.json`](aimpg/factors.json), [`aimpg/prices.json`](aimpg/prices.json) and [`aimpg/equivalences.json`](aimpg/equivalences.json).
+**Working changes:** aimpg keeps a small history of what each commit cost (never prompts or code), because Claude Code deletes its own logs after 30 days. Once a commit is 30 days old, it is judged: still on the main branch and not reverted or largely rewritten counts as a *working change*. The receipt then shows **cost per working change** and a **waste ratio** (AI spend on work that didn't last).
+
+**Energy:** a physical formula, not a price proxy. Prefill compute for new input, one KV-cache re-read per output token (so long contexts cost more), plus datacenter overhead. Model sizes aren't public, so every number is a range. Overheads follow Google's full-stack measurement of a median Gemini prompt (chips, host CPU and memory, idle capacity, cooling ≈ 1.7× the chips alone), and a chat-sized prompt on a mid-size model comes out at 0.017–0.34 Wh, bracketing Google's disclosed 0.24 Wh ([arXiv 2508.15734](https://arxiv.org/pdf/2508.15734)). Sources for every factor are in [`aimpg/factors.json`](aimpg/factors.json), [`aimpg/prices.json`](aimpg/prices.json) and [`aimpg/equivalences.json`](aimpg/equivalences.json).
 
 **Replays:** each run starts from the code just before your commit, in a fresh, history-free copy, inside a macOS sandbox. The only network allowed is the model API, through an allowlisting proxy. Your own tests judge the result, and edited tests are always restored before judging. Every token count is cross-checked against Claude Code's own totals. Details are in [docs/designs/aimpg-design.md](docs/designs/aimpg-design.md).
 
 ## Limits (honest list)
 
-- Claude Code logs only, for now. Replays need macOS and an Anthropic API key (about $0.10–0.30 per run).
+- Claude Code and Codex CLI logs are read automatically. Cursor keeps token usage on its servers, so it needs its usage export (below), and that export doesn't say which folder the work was in: give `--cursor-repo` and requests are matched to your next own commit there by time alone (shown as "by time only"). Codex's model prices aren't in the table yet; its requests count toward energy but are listed as unpriced. Replays need macOS and an Anthropic API key (about $0.10–0.30 per run).
 - Energy is an estimate with a wide range; dollars are close (within about 7% of Claude Code's own session totals on the author's logs).
 - Tips are upper bounds and overlap; they can't be added together.
 - Replays from commit messages alone are hard (12% solved on the author's repo); `--task-mode tests` shows the agent the tests, which makes tasks easier than real work but keeps comparisons fair.

{aimpg-0.2.0 → aimpg-0.3.1}/aimpg/attribution.py

@@ -39,6 +39,7 @@ from aimpg.model import CommitCall, ParseResult, Request, Task
 
 PAD = 2.0  # seconds; git timestamps are whole seconds
 GRACE = 2 * 3600.0
+TIME_ONLY = "cursor:"  # session prefix of sources matched by time alone
 BREAK = 2 * 3600.0  # a pause this long between requests starts a new work burst  # hand commits often land a while after the session goes quiet
 
 NOT_IN_REPO = "not in a git repo (or repo moved/deleted)"
@@ -149,6 +150,9 @@ def attribute(
     exact = set(tasks)
     emails: dict[str, str] = {}
     for session, rest in leftovers.items():
+        if session.startswith(TIME_ONLY):
+            _time_tier(session, rest, session_repos, commits_by_repo, exact, emails, task_for, result)
+            continue
         matches: list[tuple[str, Commit]] = []
         for repo in sorted(session_repos.get(session, set())):
             if repo not in emails:
@@ -169,6 +173,36 @@ def attribute(
     return result
 
 
+def _time_tier(session, rest, session_repos, commits_by_repo, exact, emails, task_for, result) -> None:
+    """Sources with no file or commit evidence (Cursor's usage export): each
+    request goes to your next own commit in the repo, if one follows within 2h."""
+    repos = sorted(session_repos.get(session, set()))
+    if not repos:
+        result.unattributed.setdefault(NOT_IN_REPO, []).extend(rest)
+        return
+    repo = repos[0]
+    if repo not in emails:
+        emails[repo] = user_email(repo)
+    own = sorted(
+        (c for c in commits_by_repo.get(repo, {}).values()
+         if emails[repo] and c.author_email == emails[repo] and (repo, c.sha) not in exact
+         and rest[0].ts - PAD <= c.ts <= rest[-1].ts + GRACE),
+        key=lambda c: c.ts,
+    )
+    i = 0
+    for commit in own:
+        j = i
+        while j < len(rest) and rest[j].ts <= commit.ts + PAD:
+            j += 1
+        if j > i and commit.ts - rest[j - 1].ts <= GRACE:
+            _add_bursts(task_for(repo, commit, "time"), rest[i:j], 1.0)
+        elif j > i:
+            result.unattributed.setdefault(NO_COMMIT_YET, []).extend(rest[i:j])
+        i = j
+    if i < len(rest):
+        result.unattributed.setdefault(NO_COMMIT_YET, []).extend(rest[i:])
+
+
 def _add_bursts(task: Task, segment: list[Request], weight: float) -> None:
     """The final work burst before a commit is its direct cost; earlier bursts are lead-up.
 

{aimpg-0.2.0 → aimpg-0.3.1}/aimpg/cli.py

@@ -4,6 +4,7 @@
     pr        AI energy + cost of the current branch's commits (markdown; --post to the PR)
     export    one CSV row per AI-assisted commit, for teams and sustainability reports
     replay    compare agent setups and models on your own past commits
+    live      install/uninstall the live status line + post-commit note in Claude Code
 """
 
 from __future__ import annotations
@@ -24,13 +25,25 @@ from aimpg.replay import cli as replay_cli
 def _common(p: argparse.ArgumentParser, days: int) -> None:
     p.add_argument("--days", type=int, default=days, help=f"window size in days (default {days})")
     p.add_argument("--logs", type=Path, default=DEFAULT_ROOT, help="Claude Code projects dir")
+    p.add_argument("--codex-logs", type=Path, default=None, help="Codex sessions dir (default ~/.codex/sessions)")
+    p.add_argument("--cursor-usage", type=Path, action="append", default=[], metavar="CSV",
+                   help="Cursor usage export (cursor.com/dashboard → Usage → Export CSV); repeatable")
+    p.add_argument("--cursor-repo", type=Path, default=None, help="repo the Cursor work was in (matches it to your commits by time)")
+    p.add_argument("--cursor-user", default=None, help="only this User's rows (team exports)")
     p.add_argument("--fetch", action="store_true", help="git fetch each repo first (uses the network)")
 
 
 def _analyze(args):
+    from aimpg import codex_logs, cursor_usage
+
     now = time.time()
     since = now - args.days * DAY
-    parsed = parse_logs(iter_log_files(args.logs))
+    cursor_repo = str(args.cursor_repo.expanduser().resolve()) if args.cursor_repo else ""
+    parsed = codex_logs.merge(
+        parse_logs(iter_log_files(args.logs)),
+        codex_logs.parse_codex(codex_logs.iter_files(args.codex_logs)),
+        cursor_usage.parse_cursor([p.expanduser() for p in args.cursor_usage], cursor_repo, args.cursor_user),
+    )
     return parsed, attribute(parsed, since, now, refresh=args.fetch), since, now
 
 
@@ -51,17 +64,52 @@ def main(argv: list[str] | None = None) -> int:
     export.add_argument("--no-subjects", action="store_true", help="leave commit messages out (privacy)")
     export.add_argument("--no-authors", action="store_true", help="leave author emails out (privacy)")
 
+    live = sub.add_parser("live", help="live status line + post-commit note inside Claude Code")
+    live.add_argument("action", choices=("install", "uninstall"))
+    sub.add_parser("statusline", help=argparse.SUPPRESS)  # called by Claude Code
+    hook = sub.add_parser("hook", help=argparse.SUPPRESS)  # called by Claude Code
+    hook.add_argument("event", choices=("post-commit",))
+
     replay_cli.add_parser(sub)
     args = parser.parse_args(argv)
     if args.command == "replay":
         return replay_cli.main(args)
+    if args.command in ("statusline", "hook", "live"):
+        from aimpg import live as live_mod
+
+        if args.command == "statusline":
+            return live_mod.run_statusline(live_mod.previous_statusline())
+        if args.command == "hook":
+            return live_mod.run_post_commit_hook()
+        if args.action == "install":
+            import shutil
+
+            exe = shutil.which("aimpg")
+            if exe is None:
+                print("Install aimpg permanently first so Claude Code can call it:  uv tool install aimpg")
+                return 1
+            print(live_mod.install(exe=exe))
+        else:
+            print(live_mod.uninstall())
+        return 0
 
     if args.days <= 0:
         parser.error("--days must be positive")
-    if not args.logs.is_dir():
+    from aimpg import codex_logs
+    from aimpg.cursor_usage import CursorExportError
+
+    if not (args.logs.is_dir() or args.cursor_usage or (args.codex_logs or codex_logs.DEFAULT_ROOT).is_dir()):
         print(f"No Claude Code logs found at {args.logs}. Nothing to report.")
         return 0
-    parsed, attribution, since, now = _analyze(args)
+    for path in args.cursor_usage:
+        if not path.expanduser().is_file():
+            print(f"Cursor export not found: {path}")
+            return 1
+    try:
+        parsed, attribution, since, now = _analyze(args)
+    except (CursorExportError, UnicodeDecodeError) as exc:
+        print(f"Can't read the Cursor export: {exc}")
+        return 1
 
     if args.command == "export":
         rows = share.csv_rows(attribution, subjects=not args.no_subjects, authors=not args.no_authors)
@@ -85,7 +133,12 @@ def main(argv: list[str] | None = None) -> int:
             print("\nPosted to the pull request.")
         return 0
 
-    sys.stdout.write(render(parsed, attribution, since, now))
+    from aimpg import durable, ledger
+    from aimpg.receipt import task_energy
+
+    ledger.record(task_energy(attribution.tasks))
+    judged = durable.judge(ledger.load(), now)
+    sys.stdout.write(render(parsed, attribution, since, now, judged))
     return 0
 
 

aimpg-0.3.1/aimpg/codex_logs.py

@@ -0,0 +1,142 @@
+"""Read OpenAI Codex CLI session logs (~/.codex/sessions/**/rollout-*.jsonl).
+
+Verified on real files (codex-cli 0.159):
+  * `event_msg` / `token_count` events carry `info.last_token_usage` for each
+    model call: input_tokens (includes cached), cached_input_tokens,
+    cache_write_input_tokens, output_tokens, reasoning_output_tokens.
+  * `turn_context` carries the model (e.g. gpt-6-luna) and cwd; `session_meta`
+    carries the session id and starting cwd.
+
+Not yet verified on a real file (no local session ran shell commands): how a
+`git commit` tool call is recorded. Detection is tolerant: any response_item
+tool call whose arguments contain `git ... commit`, closed by an output item
+with the same call_id. Commits made by hand are still matched by the fuzzy tier.
+
+Codex token usage is mapped onto the same buckets as Claude Code:
+    fresh_in = input − cached − cache_write · cache_read = cached
+    cache_write = cache_write_input · output = output + reasoning (generated text)
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Iterable, Iterator
+
+from aimpg.logs import _GIT_COMMIT, commit_cwd, parse_ts
+from aimpg.model import CommitCall, ParseResult, Request, Usage
+
+DEFAULT_ROOT = Path.home() / ".codex" / "sessions"
+TOOL_CALLS = ("function_call", "custom_tool_call", "local_shell_call")
+TOOL_OUTPUTS = ("function_call_output", "custom_tool_call_output", "local_shell_call_output")
+
+
+def iter_files(root: Path | None = None) -> Iterator[Path]:
+    root = root or DEFAULT_ROOT  # looked up at call time so tests can point it elsewhere
+    if root.is_dir():
+        yield from sorted(root.rglob("*.jsonl"))
+
+
+def _command_text(payload: dict) -> str:
+    for key in ("arguments", "input", "action"):
+        value = payload.get(key)
+        if isinstance(value, str):
+            try:
+                value = json.loads(value)
+            except ValueError:
+                return value
+        if isinstance(value, dict):
+            cmd = value.get("command") or value.get("cmd")
+            if isinstance(cmd, list):
+                return " ".join(str(c) for c in cmd)
+            if cmd:
+                return str(cmd)
+    return ""
+
+
+def parse_codex(files: Iterable[Path]) -> ParseResult:
+    result = ParseResult()
+    stats = {"files": 0, "rows": 0, "unique_requests": 0, "corrupt_rows": 0}
+    versions: dict[str, int] = {}
+    for path in files:
+        stats["files"] += 1
+        session, cwd, model = path.stem, "", ""
+        pending: dict[str, tuple[float, str]] = {}
+        n = 0
+        with open(path, "rb") as fh:
+            for line in fh:
+                if not line.strip():
+                    continue
+                stats["rows"] += 1
+                try:
+                    row = json.loads(line)
+                except ValueError:
+                    stats["corrupt_rows"] += 1
+                    continue
+                kind, payload = row.get("type"), row.get("payload") or {}
+                ts = parse_ts(row.get("timestamp"))
+                if kind == "session_meta":
+                    session = str(payload.get("session_id") or payload.get("id") or session)
+                    cwd = str(payload.get("cwd") or cwd)
+                    if payload.get("cli_version"):
+                        versions["codex " + str(payload["cli_version"])] = versions.get("codex " + str(payload["cli_version"]), 0) + 1
+                elif kind == "turn_context":
+                    model = str(payload.get("model") or model)
+                    cwd = str(payload.get("cwd") or cwd)
+                elif kind == "event_msg" and payload.get("type") == "token_count" and ts is not None:
+                    usage = ((payload.get("info") or {}).get("last_token_usage")) or {}
+                    if not usage:
+                        continue
+                    cached = int(usage.get("cached_input_tokens") or 0)
+                    written = int(usage.get("cache_write_input_tokens") or 0)
+                    total_in = int(usage.get("input_tokens") or 0)
+                    n += 1
+                    result.requests.append(Request(
+                        id=f"codex:{session}:{n}",
+                        session_id=f"codex:{session}",
+                        model=model or "codex-unknown",
+                        ts=ts,
+                        usage=Usage(
+                            fresh_in=max(0, total_in - cached - written),
+                            cache_write=written,
+                            cache_read=cached,
+                            output=int(usage.get("output_tokens") or 0) + int(usage.get("reasoning_output_tokens") or 0),
+                        ),
+                        cwd=cwd,
+                    ))
+                elif kind == "response_item" and ts is not None:
+                    ptype = payload.get("type")
+                    if ptype in TOOL_CALLS:
+                        command = _command_text(payload)
+                        if _GIT_COMMIT.search(command):
+                            repo_dir = commit_cwd(command, cwd) or cwd
+                            pending[str(payload.get("call_id") or payload.get("id"))] = (ts, repo_dir)
+                    elif ptype in TOOL_OUTPUTS:
+                        call = pending.pop(str(payload.get("call_id")), None)
+                        if call:
+                            result.commit_calls.append(CommitCall(f"codex:{session}", call[1], call[0], ts))
+        stats["unique_requests"] += n
+    result.requests.sort(key=lambda r: r.ts)
+    result.commit_calls.sort(key=lambda c: c.start)
+    result.stats = stats
+    result.versions = versions
+    return result
+
+
+def merge(*parts: ParseResult) -> ParseResult:
+    """One ParseResult from several agents' logs."""
+    out = ParseResult()
+    stats: dict[str, int] = {}
+    for p in parts:
+        out.requests.extend(p.requests)
+        out.commit_calls.extend(p.commit_calls)
+        for k, v in p.files_touched.items():
+            out.files_touched.setdefault(k, set()).update(v)
+        for k, v in p.stats.items():
+            stats[k] = stats.get(k, 0) + v
+        for k, v in p.versions.items():
+            out.versions[k] = out.versions.get(k, 0) + v
+    out.requests.sort(key=lambda r: r.ts)
+    out.commit_calls.sort(key=lambda c: c.start)
+    out.stats = stats
+    return out

aimpg-0.3.1/aimpg/cursor_usage.py

@@ -0,0 +1,97 @@
+"""Read Cursor's usage export (cursor.com/dashboard → Usage → Export CSV).
+
+Cursor keeps token counts on its servers, not on your machine, so the export is
+the only per-request source. Columns (checked against a public sample export):
+
+    Date, [User], Kind, Model, Max Mode, Input (w/ Cache Write),
+    Input (w/o Cache Write), Cache Read, Output Tokens, Total Tokens, Cost
+
+The four token columns add up to Total Tokens, so "Input (w/ Cache Write)" is
+the cache-write count and "Input (w/o Cache Write)" is fresh input.
+
+The export doesn't say which folder a request worked in. Its requests always
+count in the totals; with a repo given, they are matched to your own commits
+there by time alone (the "time" tier: no file evidence, lowest confidence).
+"""
+
+from __future__ import annotations
+
+import csv
+import re
+from pathlib import Path
+from typing import Iterable
+
+from aimpg.logs import parse_ts
+from aimpg.model import ParseResult, Request, Usage
+
+SESSION_PREFIX = "cursor:"
+REQUIRED = ("Date", "Model", "Input (w/ Cache Write)", "Input (w/o Cache Write)", "Cache Read", "Output Tokens")
+_CURSOR_CLAUDE = re.compile(r"^claude-(\d+)(?:\.(\d+))?-(opus|sonnet|haiku|fable)\b")
+
+
+class CursorExportError(ValueError):
+    pass
+
+
+def normalize_model(name: str) -> str:
+    """Cursor's model ids onto Anthropic's: claude-4.6-sonnet-medium-thinking → claude-sonnet-4-6."""
+    m = _CURSOR_CLAUDE.match(name)
+    if m:
+        major, minor, family = m.groups()
+        return f"claude-{family}-{major}" + (f"-{minor}" if minor else "")
+    if name.startswith("claude-"):
+        return name.replace(".", "-")
+    return name
+
+
+def _int(value: str | None) -> int:
+    try:
+        return int(float((value or "0").replace(",", "")))
+    except ValueError:
+        return 0
+
+
+def parse_cursor(paths: Iterable[Path], repo: str = "", user: str | None = None) -> ParseResult:
+    result = ParseResult()
+    seen: set[tuple] = set()
+    stats = {"files": 0, "rows": 0, "unique_requests": 0, "corrupt_rows": 0}
+    for path in paths:
+        stats["files"] += 1
+        with open(path, newline="", encoding="utf-8-sig") as fh:
+            reader = csv.DictReader(fh)
+            missing = [c for c in REQUIRED if c not in (reader.fieldnames or [])]
+            if missing:
+                raise CursorExportError(f"{path}: not a Cursor usage export (missing columns: {', '.join(missing)})")
+            for row in reader:
+                stats["rows"] += 1
+                if user is not None and row.get("User", user) != user:
+                    continue
+                ts = parse_ts(row.get("Date"))
+                if ts is None:
+                    stats["corrupt_rows"] += 1
+                    continue
+                usage = Usage(
+                    fresh_in=_int(row["Input (w/o Cache Write)"]),
+                    cache_write=_int(row["Input (w/ Cache Write)"]),
+                    cache_read=_int(row["Cache Read"]),
+                    output=_int(row["Output Tokens"]),
+                )
+                if not (usage.ctx_len or usage.output):
+                    continue  # errored / not-charged events carry no tokens
+                key = (row["Date"], row["Model"], row.get("User", ""), usage)
+                if key in seen:  # overlapping exports
+                    continue
+                seen.add(key)
+                result.requests.append(Request(
+                    id=f"cursor:{len(seen)}",
+                    session_id=SESSION_PREFIX + (row.get("User") or "me"),
+                    model=normalize_model(row["Model"].strip()),
+                    ts=ts,
+                    usage=usage,
+                    cwd=repo,
+                ))
+    stats["unique_requests"] = len(seen)
+    result.requests.sort(key=lambda r: r.ts)
+    result.stats = stats
+    result.versions = {"cursor export": len(seen)} if seen else {}
+    return result