usage-cli 0.29.32__py3-none-any.whl

adapters/__init__.py

@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (C) 2026 lollapalooza <https://github.com/aqua5230>
+#
+# Part of "usage". Free software licensed under the GNU Affero General Public
+# License v3.0 only; see the LICENSE file for full terms and the warranty disclaimer.

adapters/agy.py

@@ -0,0 +1,68 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (C) 2026 lollapalooza <https://github.com/aqua5230>
+#
+# Part of "usage". Free software licensed under the GNU Affero General Public
+# License v3.0 only; see the LICENSE file for full terms and the warranty disclaimer.
+
+from __future__ import annotations
+
+import agy_loader as shared_agy_loader
+
+from i18n import t
+
+from .types import AgentInfo, UsageEntry
+
+# Source: tokscale's aliases.rs. Keep unknown Antigravity model IDs unchanged
+# so pricing's existing fallback can handle them.
+_MODEL_ALIASES = {
+    "gemini-3-flash-a": "gemini-3-flash-preview",
+    "gemini-3-flash-c": "gemini-3-flash-preview",
+    "gemini-3-flash": "gemini-3-flash-preview",
+    "gemini-3.1-pro-high": "gemini-3.1-pro",
+    "gemini-3.1-pro-low": "gemini-3.1-pro",
+    "gemini-3-pro-high": "gemini-3-pro",
+    "gemini-3-pro-low": "gemini-3-pro",
+}
+
+_PROJECT_NAME = "Antigravity"
+
+
+def detect() -> AgentInfo | None:
+    sessions_dir = shared_agy_loader.AGY_SESSIONS_DIR
+    if sessions_dir.is_dir():
+        return AgentInfo(
+            id="antigravity",
+            name=t("agy_name"),
+            data_dir=str(sessions_dir),
+            installed=True,
+        )
+    return None
+
+
+def load_entries(hours_back: int = 0) -> list[UsageEntry]:
+    result = shared_agy_loader.load_entries_with_stats(hours_back)
+    return [_to_usage_entry(entry) for entry in result.entries]
+
+
+def _to_usage_entry(entry: shared_agy_loader.AgyUsageEntry) -> UsageEntry:
+    return UsageEntry(
+        timestamp=entry.timestamp,
+        session_id=entry.session_id,
+        message_id=entry.dedup_key,
+        request_id="",
+        model=_normalize_model(entry.model),
+        input_tokens=entry.input_tokens,
+        # Match Codex's existing convention: only its reported output tokens
+        # are attributed to UsageEntry.output_tokens; separate reasoning data
+        # is not added here.
+        output_tokens=entry.output_tokens,
+        cache_creation_tokens=0,
+        cache_read_tokens=entry.cache_read_tokens,
+        cost_usd=None,
+        project=_PROJECT_NAME,
+        agent_id="antigravity",
+    )
+
+
+def _normalize_model(model: str) -> str:
+    return _MODEL_ALIASES.get(model.lower(), model)

adapters/claude.py

@@ -0,0 +1,215 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (C) 2026 lollapalooza <https://github.com/aqua5230>
+#
+# Part of "usage". Free software licensed under the GNU Affero General Public
+# License v3.0 only; see the LICENSE file for full terms and the warranty disclaimer.
+
+import math
+import os
+import sys
+from collections import OrderedDict
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from jsonl_utils import iter_jsonl_dicts
+
+from .types import AgentInfo, UsageEntry
+
+CLAUDE_DIRS = [
+    os.path.expanduser("~/.claude/projects"),
+    os.path.expanduser("~/.config/claude/projects"),
+]
+_FILE_CACHE_MAXSIZE = 512
+_file_cache: OrderedDict[Path, tuple[float, int, list[UsageEntry]]] = OrderedDict()
+
+
+def detect() -> AgentInfo | None:
+    for d in get_claude_dirs():
+        if Path(d).is_dir():
+            return AgentInfo(
+                id="claude-code",
+                name="Claude Code",
+                data_dir=d,
+                installed=True,
+            )
+    return None
+
+
+def load_entries(hours_back: int = 0) -> list[UsageEntry]:
+    entries: list[UsageEntry] = []
+    seen: set[str] = set()
+    cutoff = None
+    if hours_back > 0:
+        from datetime import timedelta
+        cutoff = datetime.now(timezone.utc) - timedelta(hours=hours_back)
+
+    for base_dir in get_claude_dirs():
+        base = Path(base_dir)
+        if not base.is_dir():
+            continue
+        for jsonl_path in base.rglob("*.jsonl"):
+            fallback_project = extract_project_from_dir(jsonl_path, base)
+            parse_jsonl(jsonl_path, fallback_project, entries, seen, cutoff)
+
+    entries.sort(key=lambda e: e.timestamp)
+    return entries
+
+
+def get_claude_dirs() -> list[str]:
+    dirs = list(CLAUDE_DIRS)
+    env = os.environ.get("CLAUDE_CONFIG_DIR")
+    if env:
+        for p in env.split(","):
+            projects_dir = os.path.join(p.strip(), "projects")
+            if projects_dir not in dirs:
+                dirs.insert(0, projects_dir)
+    return dirs
+
+
+def project_from_cwd(cwd: str) -> str:
+    home = os.path.expanduser("~")
+    rel = cwd[len(home):] if cwd.startswith(home) else cwd
+    # Windows sessions read transcripts whose cwd may use either separator
+    # (e.g. POSIX-style paths). POSIX filenames may legitimately contain
+    # backslashes, so only normalize them on Windows.
+    if sys.platform == "win32":
+        rel = rel.replace("\\", "/")
+        sep = "/"
+    else:
+        sep = os.sep
+    rel = rel.strip(sep)
+    parts = rel.split(sep)
+    return parts[-1] if parts and parts[-1] else rel or "unknown"
+
+
+def extract_project_from_dir(jsonl_path: Path, base: Path) -> str:
+    rel = jsonl_path.relative_to(base)
+    project_dir = str(rel.parts[0]) if rel.parts else "unknown"
+    decoded = project_dir.replace("-", os.sep).strip(os.sep)
+    home = os.path.expanduser("~").strip(os.sep)
+    if decoded.startswith(home):
+        decoded = decoded[len(home):].strip(os.sep)
+    parts = decoded.split(os.sep)
+    return parts[-1] if parts else "unknown"
+
+
+def parse_jsonl(
+    path: Path,
+    project: str,
+    entries: list[UsageEntry],
+    seen: set[str],
+    cutoff: datetime | None,
+) -> None:
+    try:
+        st = path.stat()
+    except (OSError, PermissionError) as exc:
+        _debug_file_error("failed to stat Claude log", path, exc)
+        return
+
+    cached = _file_cache.get(path)
+    parsed_entries: list[UsageEntry]
+    if cached is not None and cached[0] == st.st_mtime and cached[1] == st.st_size:
+        _file_cache.move_to_end(path)
+        parsed_entries = cached[2]
+    else:
+        parsed_entries = []
+        try:
+            for data in iter_jsonl_dicts(path):
+                if data.get("type") != "assistant":
+                    continue
+
+                entry = _parse_assistant_entry(data, project)
+                if entry is None:
+                    continue
+                parsed_entries.append(entry)
+        except (OSError, PermissionError, UnicodeDecodeError) as exc:
+            _debug_file_error("failed to read Claude log", path, exc)
+            return
+
+        if path not in _file_cache and len(_file_cache) >= _FILE_CACHE_MAXSIZE:
+            _file_cache.popitem(last=False)
+        _file_cache[path] = (st.st_mtime, st.st_size, parsed_entries)
+
+    for entry in parsed_entries:
+        if cutoff and entry.timestamp < cutoff:
+            continue
+
+        if entry.dedup_key in seen:
+            continue
+        seen.add(entry.dedup_key)
+
+        entries.append(entry)
+
+
+def _parse_assistant_entry(data: dict[str, Any], project: str) -> UsageEntry | None:
+    message = data.get("message")
+    if not message or not isinstance(message, dict):
+        return None
+
+    usage = message.get("usage")
+    if not usage or not isinstance(usage, dict):
+        return None
+
+    input_tokens = _as_int(usage.get("input_tokens"))
+    output_tokens = _as_int(usage.get("output_tokens"))
+    cache_creation = _as_int(usage.get("cache_creation_input_tokens"))
+    cache_read = _as_int(usage.get("cache_read_input_tokens"))
+
+    if input_tokens == 0 and output_tokens == 0 and cache_creation == 0 and cache_read == 0:
+        return None
+
+    timestamp_str = data.get("timestamp", "")
+    try:
+        ts = datetime.fromisoformat(timestamp_str.replace("Z", "+00:00"))
+    except (ValueError, AttributeError):
+        return None
+
+    message_id = message.get("id", "")
+    request_id = data.get("requestId") or ""
+    model = message.get("model", "unknown")
+    session_id = data.get("sessionId", "")
+    cost_usd = _as_optional_float(data.get("costUSD"))
+
+    cwd = data.get("cwd", "")
+    if cwd:
+        project = project_from_cwd(cwd)
+
+    return UsageEntry(
+        timestamp=ts,
+        session_id=session_id,
+        message_id=message_id,
+        request_id=request_id,
+        model=model,
+        input_tokens=input_tokens,
+        output_tokens=output_tokens,
+        cache_creation_tokens=cache_creation,
+        cache_read_tokens=cache_read,
+        cost_usd=cost_usd,
+        project=project,
+        agent_id="claude-code",
+    )
+
+
+def _debug_file_error(action: str, path: Path, exc: Exception) -> None:
+    if os.environ.get("USAGE_DEBUG") == "1":
+        print(f"{action} {path}: {exc}", file=sys.stderr)
+
+
+def _as_optional_float(value: Any) -> float | None:
+    if isinstance(value, bool):
+        return None
+    try:
+        number = float(value)
+    except (TypeError, ValueError):
+        return None
+    if not math.isfinite(number):
+        return None
+    return number
+
+
+def _as_int(value: Any) -> int:
+    number = _as_optional_float(value)
+    if number is None:
+        return 0
+    return int(number)

adapters/codex.py

@@ -0,0 +1,209 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (C) 2026 lollapalooza <https://github.com/aqua5230>
+#
+# Part of "usage". Free software licensed under the GNU Affero General Public
+# License v3.0 only; see the LICENSE file for full terms and the warranty disclaimer.
+
+import json
+import math
+import os
+import sqlite3
+import sys
+from collections import OrderedDict, defaultdict
+from contextlib import closing
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any
+
+import codex_loader as shared_codex_loader
+from codex_paths import codex_home
+
+from .types import AgentInfo, RateLimits, UsageEntry
+
+CODEX_DIR = str(codex_home())
+SESSIONS_DIR = os.path.join(CODEX_DIR, "sessions")
+STATE_DB = os.path.join(CODEX_DIR, "state_5.sqlite")
+_FILE_CACHE_MAXSIZE = 512
+_file_cache: OrderedDict[Path, tuple[float, int, list[dict[str, Any]]]] = OrderedDict()
+
+
+def _readonly_sqlite_uri(path: str | Path) -> str:
+    return f"{Path(path).resolve().as_uri()}?mode=ro"
+
+
+def detect() -> AgentInfo | None:
+    if Path(SESSIONS_DIR).is_dir():
+        return AgentInfo(
+            id="codex",
+            name="Codex",
+            data_dir=SESSIONS_DIR,
+            installed=True,
+        )
+    return None
+
+
+def load_entries(hours_back: int = 0) -> list[UsageEntry]:
+    cutoff = None
+    if hours_back > 0:
+        cutoff = datetime.now(timezone.utc) - timedelta(hours=hours_back)
+
+    models = _load_thread_models()
+    sessions_path = Path(SESSIONS_DIR)
+    delta_entries = shared_codex_loader._load_jsonl_entries(sessions_path, models, cutoff)
+    by_session: dict[str, list[Any]] = defaultdict(list)
+    for entry in delta_entries:
+        by_session[entry.session_id].append(entry)
+
+    entries = [_aggregate_session(session_entries) for session_entries in by_session.values()]
+    entries.sort(key=lambda e: e.timestamp)
+    return entries
+
+
+def _aggregate_session(session_entries: list[Any]) -> UsageEntry:
+    first = session_entries[0]
+    primary = max(session_entries, key=lambda entry: entry.total_tokens)
+    return UsageEntry(
+        timestamp=first.timestamp,
+        session_id=first.session_id,
+        message_id=first.session_id,
+        request_id="",
+        model=primary.model,
+        input_tokens=sum(entry.input_tokens for entry in session_entries),
+        output_tokens=sum(entry.output_tokens for entry in session_entries),
+        cache_creation_tokens=sum(entry.cache_creation_tokens for entry in session_entries),
+        cache_read_tokens=sum(entry.cache_read_tokens for entry in session_entries),
+        cost_usd=None,
+        project=first.project,
+        agent_id="codex",
+        message_count=len(session_entries),
+    )
+
+
+def _load_thread_models() -> dict[str, str]:
+    if not os.path.exists(STATE_DB):
+        return {}
+    try:
+        with closing(sqlite3.connect(_readonly_sqlite_uri(STATE_DB), uri=True)) as conn:
+            rows = conn.execute("SELECT id, model FROM threads WHERE model IS NOT NULL").fetchall()
+        return {row[0]: row[1] for row in rows}
+    except (sqlite3.Error, OSError) as exc:
+        _debug_file_error("failed to load Codex thread models from", Path(STATE_DB), exc)
+        return {}
+
+
+def _extract_rate_limits(path: Path, models: dict[str, str]) -> RateLimits | None:
+    session_id = ""
+    session_model = "unknown"
+    last_rl = None
+    try:
+        rows = _load_jsonl_rows(path)
+    except (OSError, PermissionError, UnicodeDecodeError) as exc:
+        _debug_file_error("failed to read Codex session log", path, exc)
+        return None
+
+    for data in rows:
+        if data.get("type") == "session_meta":
+            payload = data.get("payload", {})
+            session_id = payload.get("id", "")
+            session_model = _session_model(payload, session_model)
+        if data.get("type") == "turn_context":
+            session_model = _session_model(data.get("payload"), session_model)
+        if data.get("type") != "event_msg":
+            continue
+        payload = data.get("payload", {})
+        if payload.get("type") != "token_count":
+            continue
+        rl = payload.get("rate_limits")
+        if rl:
+            last_rl = (rl, data.get("timestamp", ""), session_id)
+
+    if not last_rl:
+        return None
+
+    rl, ts, sid = last_rl
+    primary = rl.get("primary") or {}
+    secondary = rl.get("secondary") or {}
+
+    five_pct = _as_optional_float(primary.get("used_percent"))
+    five_reset = _as_optional_int(primary.get("resets_at"))
+    seven_pct = _as_optional_float(secondary.get("used_percent"))
+    seven_reset = _as_optional_int(secondary.get("resets_at"))
+
+    now_ts = datetime.now(timezone.utc).timestamp()
+    if five_reset is not None and five_reset < now_ts:
+        five_pct = 0.0
+        five_reset = None
+    if seven_reset is not None and seven_reset < now_ts:
+        seven_pct = 0.0
+        seven_reset = None
+
+    if five_pct is None and seven_pct is None:
+        return None
+
+    model_name = models.get(sid, "")
+
+    return RateLimits(
+        five_hour_pct=five_pct,
+        five_hour_resets_at=five_reset,
+        seven_day_pct=seven_pct,
+        seven_day_resets_at=seven_reset,
+        model=model_name or session_model,
+        updated_at=ts,
+    )
+
+
+def _load_jsonl_rows(path: Path) -> list[dict[str, Any]]:
+    st = path.stat()
+    cached = _file_cache.get(path)
+    if cached is not None and cached[0] == st.st_mtime and cached[1] == st.st_size:
+        _file_cache.move_to_end(path)
+        return cached[2]
+
+    rows: list[dict[str, Any]] = []
+    with open(path, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                data = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            if isinstance(data, dict):
+                rows.append(data)
+
+    if path not in _file_cache and len(_file_cache) >= _FILE_CACHE_MAXSIZE:
+        _file_cache.popitem(last=False)
+    _file_cache[path] = (st.st_mtime, st.st_size, rows)
+    return rows
+
+
+def _as_optional_float(value: Any) -> float | None:
+    if isinstance(value, bool):
+        return None
+    try:
+        number = float(value)
+    except (TypeError, ValueError):
+        return None
+    if not math.isfinite(number):
+        return None
+    return number
+
+
+def _session_model(payload: Any, fallback: str) -> str:
+    model = payload.get("model") if isinstance(payload, dict) else ""
+    if not isinstance(model, str):
+        model = ""
+    return model or fallback
+
+
+def _as_optional_int(value: Any) -> int | None:
+    number = _as_optional_float(value)
+    if number is None:
+        return None
+    return int(number)
+
+
+def _debug_file_error(action: str, path: Path, exc: Exception) -> None:
+    if os.environ.get("USAGE_DEBUG") == "1":
+        print(f"{action} {path}: {exc}", file=sys.stderr)

adapters/rate_limits.py

@@ -0,0 +1,76 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (C) 2026 lollapalooza <https://github.com/aqua5230>
+#
+# Part of "usage". Free software licensed under the GNU Affero General Public
+# License v3.0 only; see the LICENSE file for full terms and the warranty disclaimer.
+
+import json
+import math
+import os
+from datetime import datetime, timezone
+from typing import Any
+
+from .types import RateLimits
+
+STATUS_FILE = os.path.expanduser("~/.claude/usage-status.json")
+LEGACY_STATUS_FILE = os.path.expanduser("~/.claude/usag-status.json")
+TT_STATUS_FILE = os.path.expanduser("~/.claude/tt-status.json")
+
+
+def _as_finite_float(value: Any) -> float | None:
+    if isinstance(value, bool):
+        return None
+    try:
+        numeric = float(value)
+    except (TypeError, ValueError):
+        return None
+    return numeric if math.isfinite(numeric) else None
+
+
+def _read_status() -> dict[str, Any] | None:
+    for path in (STATUS_FILE, LEGACY_STATUS_FILE, TT_STATUS_FILE):
+        if not os.path.exists(path):
+            continue
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                data: dict[str, Any] = json.load(f)
+                return data
+        except (json.JSONDecodeError, OSError, UnicodeDecodeError):
+            continue
+    return None
+
+
+def load_rate_limits() -> RateLimits | None:
+    data = _read_status()
+    if data is None:
+        return None
+
+    rl = data.get("rate_limits") or {}
+    five = rl.get("five_hour") or {}
+    seven = rl.get("seven_day") or {}
+
+    now_ts = datetime.now(timezone.utc).timestamp()
+    five_pct = _as_finite_float(five.get("used_percentage"))
+    five_reset = _as_finite_float(five.get("resets_at"))
+    if five_reset and five_reset < now_ts:
+        five_pct = 0.0
+
+    seven_pct = _as_finite_float(seven.get("used_percentage"))
+    seven_reset = _as_finite_float(seven.get("resets_at"))
+    if seven_reset and seven_reset < now_ts:
+        seven_pct = 0.0
+
+    model_info = data.get("model") or {}
+    model_name = model_info.get("display_name") or model_info.get("id") or ""
+
+    if five_pct is None and seven_pct is None and not model_name:
+        return None
+
+    return RateLimits(
+        five_hour_pct=five_pct,
+        five_hour_resets_at=int(five_reset) if five_reset is not None else None,
+        seven_day_pct=seven_pct,
+        seven_day_resets_at=int(seven_reset) if seven_reset is not None else None,
+        model=model_name,
+        updated_at=data.get("_received_at", ""),
+    )

adapters/registry.py

@@ -0,0 +1,17 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (C) 2026 lollapalooza <https://github.com/aqua5230>
+#
+# Part of "usage". Free software licensed under the GNU Affero General Public
+# License v3.0 only; see the LICENSE file for full terms and the warranty disclaimer.
+
+from .types import AgentInfo
+from . import agy, claude, codex
+
+
+def detect_agents() -> list[AgentInfo]:
+    agents: list[AgentInfo] = []
+    for detector in [claude.detect, codex.detect, agy.detect]:
+        info = detector()
+        if info:
+            agents.append(info)
+    return agents