codex-stats 0.1.0__tar.gz

codex_stats-0.1.0/LICENSE

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

codex_stats-0.1.0/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: codex-stats
+Version: 0.1.0
+Summary: Local AI usage observability CLI for Codex sessions.
+Author: Vivek
+License: MIT
+Project-URL: Homepage, https://github.com/vivek378521/codex-stats
+Project-URL: Repository, https://github.com/vivek378521/codex-stats
+Project-URL: Issues, https://github.com/vivek378521/codex-stats/issues
+Keywords: codex,cli,analytics,sqlite,usage
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: build>=1.2.2; extra == "dev"
+Dynamic: license-file
+
+# codex-stats
+
+Local AI usage observability CLI for Codex sessions.
+
+## What it does
+
+`codex-stats` reads local Codex state from `~/.codex` and shows:
+
+- session totals from `state_5.sqlite`
+- request counts from rollout JSONL files
+- model and project breakdown from local session metadata
+- estimated cost from a local pricing table
+
+## Install
+
+```bash
+pip install .
+```
+
+After publish:
+
+```bash
+pipx install codex-stats
+```
+
+For local development:
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+python -m pip install -U pip setuptools
+python -m pip install -e .
+```
+
+## Usage
+
+```bash
+codex-stats
+codex-stats today
+codex-stats session
+codex-stats session --id <session_id>
+codex-stats --json
+```
+
+From the repo without installing:
+
+```bash
+PYTHONPATH=src python3 -m codex_stats
+```
+
+## Notes
+
+- This tool does not intercept Codex API traffic.
+- Costs are estimates, not authoritative billing values.
+- The current MVP relies on local file formats that may evolve with Codex CLI versions.
+
+## Release
+
+Recommended publish flow:
+
+1. Create the GitHub repository `vivek378521/codex-stats`.
+2. Create a PyPI project named `codex-stats`.
+3. Configure PyPI Trusted Publishing for the GitHub repository.
+4. Push a version tag and publish a GitHub release.
+5. The release workflow will build and upload the package to PyPI.

codex_stats-0.1.0/README.md

@@ -0,0 +1,65 @@
+# codex-stats
+
+Local AI usage observability CLI for Codex sessions.
+
+## What it does
+
+`codex-stats` reads local Codex state from `~/.codex` and shows:
+
+- session totals from `state_5.sqlite`
+- request counts from rollout JSONL files
+- model and project breakdown from local session metadata
+- estimated cost from a local pricing table
+
+## Install
+
+```bash
+pip install .
+```
+
+After publish:
+
+```bash
+pipx install codex-stats
+```
+
+For local development:
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+python -m pip install -U pip setuptools
+python -m pip install -e .
+```
+
+## Usage
+
+```bash
+codex-stats
+codex-stats today
+codex-stats session
+codex-stats session --id <session_id>
+codex-stats --json
+```
+
+From the repo without installing:
+
+```bash
+PYTHONPATH=src python3 -m codex_stats
+```
+
+## Notes
+
+- This tool does not intercept Codex API traffic.
+- Costs are estimates, not authoritative billing values.
+- The current MVP relies on local file formats that may evolve with Codex CLI versions.
+
+## Release
+
+Recommended publish flow:
+
+1. Create the GitHub repository `vivek378521/codex-stats`.
+2. Create a PyPI project named `codex-stats`.
+3. Configure PyPI Trusted Publishing for the GitHub repository.
+4. Push a version tag and publish a GitHub release.
+5. The release workflow will build and upload the package to PyPI.

codex_stats-0.1.0/pyproject.toml

@@ -0,0 +1,46 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "codex-stats"
+version = "0.1.0"
+description = "Local AI usage observability CLI for Codex sessions."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [
+  { name = "Vivek" }
+]
+keywords = ["codex", "cli", "analytics", "sqlite", "usage"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "Topic :: Utilities",
+]
+
+[project.optional-dependencies]
+dev = [
+  "build>=1.2.2",
+]
+
+[project.scripts]
+codex-stats = "codex_stats.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/vivek378521/codex-stats"
+Repository = "https://github.com/vivek378521/codex-stats"
+Issues = "https://github.com/vivek378521/codex-stats/issues"
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]

codex_stats-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

codex_stats-0.1.0/src/codex_stats/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

codex_stats-0.1.0/src/codex_stats/__main__.py

@@ -0,0 +1,5 @@
+from .cli import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

codex_stats-0.1.0/src/codex_stats/cli.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import argparse
+import sys
+
+from .config import Paths
+from .display import as_json, format_session, format_summary
+from .ingest import get_session, get_session_details
+from .metrics import summarize_today
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="codex-stats", description="Local usage analytics for Codex.")
+    parser.add_argument("--json", action="store_true", dest="json_output", help="Output JSON.")
+    subparsers = parser.add_subparsers(dest="command")
+
+    today_parser = subparsers.add_parser("today", help="Show today's usage summary.")
+    today_parser.add_argument("--json", action="store_true", dest="json_output", help="Output JSON.")
+
+    session_parser = subparsers.add_parser("session", help="Show a session summary.")
+    session_parser.add_argument("--id", dest="session_id", help="Specific session ID.")
+    session_parser.add_argument("--json", action="store_true", dest="json_output", help="Output JSON.")
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    paths = Paths.discover()
+
+    if args.command in (None, "today"):
+        summary = summarize_today(paths)
+        if args.json_output:
+            print(as_json(summary.to_dict()))
+        else:
+            print(format_summary(summary))
+        return 0
+
+    if args.command == "session":
+        session = get_session(paths, session_id=args.session_id)
+        if session is None:
+            print("No Codex session found.", file=sys.stderr)
+            return 1
+        details = get_session_details(paths, session)
+        if args.json_output:
+            print(as_json(details.to_dict()))
+        else:
+            print(format_session(details))
+        return 0
+
+    parser.print_help()
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

codex_stats-0.1.0/src/codex_stats/config.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class Paths:
+    codex_home: Path
+    state_db: Path
+    logs_db: Path
+    sessions_dir: Path
+
+    @classmethod
+    def discover(cls) -> "Paths":
+        codex_home = Path(os.environ.get("CODEX_HOME", "~/.codex")).expanduser()
+        return cls(
+            codex_home=codex_home,
+            state_db=codex_home / "state_5.sqlite",
+            logs_db=codex_home / "logs_1.sqlite",
+            sessions_dir=codex_home / "sessions",
+        )

codex_stats-0.1.0/src/codex_stats/display.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import json
+from datetime import UTC
+
+from .models import SessionDetails, TimeSummary
+
+
+def format_summary(summary: TimeSummary) -> str:
+    lines = [
+        "Codex Usage Summary",
+        "",
+        f"Window: {summary.label}",
+        f"Sessions: {summary.sessions}",
+        f"Requests: {summary.requests}",
+        f"Input tokens: {summary.input_tokens:,}",
+        f"Output tokens: {summary.output_tokens:,}",
+        f"Cached input tokens: {summary.cached_input_tokens:,}",
+        f"Reasoning tokens: {summary.reasoning_output_tokens:,}",
+        f"Total tokens: {summary.total_tokens:,}",
+        f"Estimated cost: ${summary.estimated_cost_usd:.2f}",
+    ]
+    if summary.top_model:
+        lines.append(f"Top model: {summary.top_model}")
+    return "\n".join(lines)
+
+
+def format_session(details: SessionDetails) -> str:
+    session = details.session
+    lines = [
+        "Session Summary",
+        "",
+        f"Session ID: {session.session_id}",
+        f"Project: {session.project_name}",
+        f"Model: {session.model or 'unknown'}",
+        f"Started: {_fmt_dt(details.started_at or session.created_at)}",
+        f"Updated: {_fmt_dt(session.updated_at)}",
+        f"Requests: {details.request_count}",
+        f"Input tokens: {_fmt_optional_int(details.input_tokens)}",
+        f"Output tokens: {_fmt_optional_int(details.output_tokens)}",
+        f"Cached input tokens: {_fmt_optional_int(details.cached_input_tokens)}",
+        f"Reasoning tokens: {_fmt_optional_int(details.reasoning_output_tokens)}",
+        f"Total tokens: {details.effective_total_tokens():,}",
+    ]
+    return "\n".join(lines)
+
+
+def as_json(payload: dict) -> str:
+    return json.dumps(payload, indent=2, sort_keys=True)
+
+
+def _fmt_dt(value) -> str:
+    return value.astimezone(UTC).isoformat() if value else "unknown"
+
+
+def _fmt_optional_int(value: int | None) -> str:
+    if value is None:
+        return "unknown"
+    return f"{value:,}"

codex_stats-0.1.0/src/codex_stats/ingest.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+import json
+import sqlite3
+from collections.abc import Iterable
+from datetime import UTC, date, datetime, tzinfo
+from pathlib import Path
+
+from .config import Paths
+from .models import SessionDetails, SessionRecord
+
+
+def _dt_from_unix(timestamp: int) -> datetime:
+    return datetime.fromtimestamp(timestamp, tz=UTC)
+
+
+def _connect_sqlite(path: Path) -> sqlite3.Connection:
+    connection = sqlite3.connect(path)
+    connection.row_factory = sqlite3.Row
+    return connection
+
+
+def iter_sessions(paths: Paths) -> Iterable[SessionRecord]:
+    if not paths.state_db.exists():
+        return []
+
+    query = """
+        SELECT
+            id,
+            created_at,
+            updated_at,
+            cwd,
+            model,
+            model_provider,
+            tokens_used,
+            rollout_path,
+            git_branch,
+            git_origin_url
+        FROM threads
+        ORDER BY updated_at DESC, created_at DESC
+    """
+    with _connect_sqlite(paths.state_db) as connection:
+        rows = connection.execute(query).fetchall()
+
+    sessions: list[SessionRecord] = []
+    for row in rows:
+        sessions.append(
+            SessionRecord(
+                session_id=row["id"],
+                created_at=_dt_from_unix(row["created_at"]),
+                updated_at=_dt_from_unix(row["updated_at"]),
+                cwd=row["cwd"],
+                model=row["model"],
+                model_provider=row["model_provider"],
+                tokens_used=row["tokens_used"],
+                rollout_path=Path(row["rollout_path"]),
+                git_branch=row["git_branch"],
+                git_origin_url=row["git_origin_url"],
+            )
+        )
+    return sessions
+
+
+def get_session(paths: Paths, session_id: str | None = None) -> SessionRecord | None:
+    sessions = list(iter_sessions(paths))
+    if not sessions:
+        return None
+    if session_id is None:
+        return sessions[0]
+    for session in sessions:
+        if session.session_id == session_id:
+            return session
+    return None
+
+
+def _read_rollout_details(path: Path) -> dict[str, int | str | None]:
+    details: dict[str, int | str | None] = {
+        "request_count": 0,
+        "input_tokens": None,
+        "output_tokens": None,
+        "cached_input_tokens": None,
+        "reasoning_output_tokens": None,
+        "total_tokens_from_rollout": None,
+        "started_at": None,
+    }
+    if not path.exists():
+        return details
+
+    with path.open("r", encoding="utf-8") as handle:
+        for raw_line in handle:
+            line = raw_line.strip()
+            if not line:
+                continue
+            try:
+                event = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+
+            event_type = event.get("type")
+            payload = event.get("payload", {})
+            if event_type == "session_meta":
+                timestamp = payload.get("timestamp")
+                if isinstance(timestamp, str):
+                    details["started_at"] = timestamp
+            if event_type != "event_msg":
+                continue
+
+            payload_type = payload.get("type")
+            if payload_type == "user_message":
+                details["request_count"] = int(details["request_count"] or 0) + 1
+            elif payload_type == "token_count":
+                info = payload.get("info") or {}
+                total_usage = info.get("total_token_usage") or {}
+                if total_usage:
+                    details["input_tokens"] = total_usage.get("input_tokens")
+                    details["output_tokens"] = total_usage.get("output_tokens")
+                    details["cached_input_tokens"] = total_usage.get("cached_input_tokens")
+                    details["reasoning_output_tokens"] = total_usage.get("reasoning_output_tokens")
+                    details["total_tokens_from_rollout"] = total_usage.get("total_tokens")
+
+    return details
+
+
+def get_session_details(paths: Paths, session: SessionRecord) -> SessionDetails:
+    rollout_details = _read_rollout_details(session.rollout_path)
+    started_at_raw = rollout_details["started_at"]
+    started_at = None
+    if isinstance(started_at_raw, str):
+        started_at = datetime.fromisoformat(started_at_raw.replace("Z", "+00:00"))
+
+    return SessionDetails(
+        session=session,
+        request_count=int(rollout_details["request_count"] or 0),
+        input_tokens=_as_optional_int(rollout_details["input_tokens"]),
+        output_tokens=_as_optional_int(rollout_details["output_tokens"]),
+        cached_input_tokens=_as_optional_int(rollout_details["cached_input_tokens"]),
+        reasoning_output_tokens=_as_optional_int(rollout_details["reasoning_output_tokens"]),
+        total_tokens_from_rollout=_as_optional_int(rollout_details["total_tokens_from_rollout"]),
+        started_at=started_at,
+    )
+
+
+def sessions_for_day(paths: Paths, target_day: date, timezone: tzinfo | None = None) -> list[SessionRecord]:
+    return [
+        session
+        for session in iter_sessions(paths)
+        if session.created_at.astimezone(timezone or UTC).date() == target_day
+    ]
+
+
+def _as_optional_int(value: object) -> int | None:
+    if value is None:
+        return None
+    if isinstance(value, int):
+        return value
+    return int(value)

codex_stats-0.1.0/src/codex_stats/metrics.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from collections import Counter
+from datetime import datetime, tzinfo
+
+from .config import Paths
+from .ingest import get_session_details, sessions_for_day
+from .models import SessionDetails, TimeSummary
+
+# Conservative placeholder pricing. Replace with model-specific pricing later.
+DEFAULT_USD_PER_1K_TOKENS = 0.01
+
+
+def estimate_cost_usd(total_tokens: int, usd_per_1k_tokens: float = DEFAULT_USD_PER_1K_TOKENS) -> float:
+    return round((total_tokens / 1000.0) * usd_per_1k_tokens, 4)
+
+
+def summarize_today(paths: Paths, now: datetime | None = None) -> TimeSummary:
+    current_time = now or datetime.now().astimezone()
+    timezone = current_time.tzinfo
+    sessions = sessions_for_day(paths, current_time.date(), timezone)
+    details = [get_session_details(paths, session) for session in sessions]
+    return summarize_details("today", details)
+
+
+def summarize_details(label: str, details: list[SessionDetails]) -> TimeSummary:
+    sessions_count = len(details)
+    requests = sum(detail.request_count for detail in details)
+    input_tokens = sum(detail.input_tokens or 0 for detail in details)
+    output_tokens = sum(detail.output_tokens or 0 for detail in details)
+    cached_input_tokens = sum(detail.cached_input_tokens or 0 for detail in details)
+    reasoning_output_tokens = sum(detail.reasoning_output_tokens or 0 for detail in details)
+    total_tokens = sum(detail.effective_total_tokens() for detail in details)
+    model_counter = Counter(detail.session.model for detail in details if detail.session.model)
+    top_model = model_counter.most_common(1)[0][0] if model_counter else None
+    return TimeSummary(
+        label=label,
+        sessions=sessions_count,
+        requests=requests,
+        input_tokens=input_tokens,
+        output_tokens=output_tokens,
+        cached_input_tokens=cached_input_tokens,
+        reasoning_output_tokens=reasoning_output_tokens,
+        total_tokens=total_tokens,
+        estimated_cost_usd=estimate_cost_usd(total_tokens),
+        top_model=top_model,
+    )
+
+
+def local_date(value: datetime, timezone: tzinfo | None) -> datetime.date:
+    target_timezone = timezone or value.astimezone().tzinfo
+    return value.astimezone(target_timezone).date()

codex_stats-0.1.0/src/codex_stats/models.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+
+@dataclass(frozen=True)
+class SessionRecord:
+    session_id: str
+    created_at: datetime
+    updated_at: datetime
+    cwd: str
+    model: str | None
+    model_provider: str
+    tokens_used: int
+    rollout_path: Path
+    git_branch: str | None
+    git_origin_url: str | None
+
+    @property
+    def project_name(self) -> str:
+        cwd_path = Path(self.cwd)
+        return cwd_path.name or self.cwd
+
+    def to_dict(self) -> dict[str, Any]:
+        payload = asdict(self)
+        payload["created_at"] = self.created_at.isoformat()
+        payload["updated_at"] = self.updated_at.isoformat()
+        payload["rollout_path"] = str(self.rollout_path)
+        payload["project_name"] = self.project_name
+        return payload
+
+
+@dataclass(frozen=True)
+class SessionDetails:
+    session: SessionRecord
+    request_count: int
+    input_tokens: int | None
+    output_tokens: int | None
+    cached_input_tokens: int | None
+    reasoning_output_tokens: int | None
+    total_tokens_from_rollout: int | None
+    started_at: datetime | None
+
+    def effective_total_tokens(self) -> int:
+        if self.total_tokens_from_rollout is not None:
+            return self.total_tokens_from_rollout
+        return self.session.tokens_used
+
+    def to_dict(self) -> dict[str, Any]:
+        payload = {
+            "session": self.session.to_dict(),
+            "request_count": self.request_count,
+            "input_tokens": self.input_tokens,
+            "output_tokens": self.output_tokens,
+            "cached_input_tokens": self.cached_input_tokens,
+            "reasoning_output_tokens": self.reasoning_output_tokens,
+            "total_tokens_from_rollout": self.total_tokens_from_rollout,
+            "effective_total_tokens": self.effective_total_tokens(),
+            "started_at": self.started_at.isoformat() if self.started_at else None,
+        }
+        return payload
+
+
+@dataclass(frozen=True)
+class TimeSummary:
+    label: str
+    sessions: int
+    requests: int
+    input_tokens: int
+    output_tokens: int
+    cached_input_tokens: int
+    reasoning_output_tokens: int
+    total_tokens: int
+    estimated_cost_usd: float
+    top_model: str | None
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)

codex_stats-0.1.0/src/codex_stats.egg-info/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: codex-stats
+Version: 0.1.0
+Summary: Local AI usage observability CLI for Codex sessions.
+Author: Vivek
+License: MIT
+Project-URL: Homepage, https://github.com/vivek378521/codex-stats
+Project-URL: Repository, https://github.com/vivek378521/codex-stats
+Project-URL: Issues, https://github.com/vivek378521/codex-stats/issues
+Keywords: codex,cli,analytics,sqlite,usage
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: build>=1.2.2; extra == "dev"
+Dynamic: license-file
+
+# codex-stats
+
+Local AI usage observability CLI for Codex sessions.
+
+## What it does
+
+`codex-stats` reads local Codex state from `~/.codex` and shows:
+
+- session totals from `state_5.sqlite`
+- request counts from rollout JSONL files
+- model and project breakdown from local session metadata
+- estimated cost from a local pricing table
+
+## Install
+
+```bash
+pip install .
+```
+
+After publish:
+
+```bash
+pipx install codex-stats
+```
+
+For local development:
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+python -m pip install -U pip setuptools
+python -m pip install -e .
+```
+
+## Usage
+
+```bash
+codex-stats
+codex-stats today
+codex-stats session
+codex-stats session --id <session_id>
+codex-stats --json
+```
+
+From the repo without installing:
+
+```bash
+PYTHONPATH=src python3 -m codex_stats
+```
+
+## Notes
+
+- This tool does not intercept Codex API traffic.
+- Costs are estimates, not authoritative billing values.
+- The current MVP relies on local file formats that may evolve with Codex CLI versions.
+
+## Release
+
+Recommended publish flow:
+
+1. Create the GitHub repository `vivek378521/codex-stats`.
+2. Create a PyPI project named `codex-stats`.
+3. Configure PyPI Trusted Publishing for the GitHub repository.
+4. Push a version tag and publish a GitHub release.
+5. The release workflow will build and upload the package to PyPI.

codex_stats-0.1.0/src/codex_stats.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+pyproject.toml
+src/codex_stats/__init__.py
+src/codex_stats/__main__.py
+src/codex_stats/cli.py
+src/codex_stats/config.py
+src/codex_stats/display.py
+src/codex_stats/ingest.py
+src/codex_stats/metrics.py
+src/codex_stats/models.py
+src/codex_stats.egg-info/PKG-INFO
+src/codex_stats.egg-info/SOURCES.txt
+src/codex_stats.egg-info/dependency_links.txt
+src/codex_stats.egg-info/entry_points.txt
+src/codex_stats.egg-info/requires.txt
+src/codex_stats.egg-info/top_level.txt
+tests/test_cli.py
+tests/test_metrics.py

codex_stats-0.1.0/src/codex_stats.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

codex_stats-0.1.0/src/codex_stats.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+codex-stats = codex_stats.cli:main

codex_stats-0.1.0/src/codex_stats.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[dev]
+build>=1.2.2

codex_stats-0.1.0/src/codex_stats.egg-info/top_level.txt

@@ -0,0 +1 @@
+codex_stats

codex_stats-0.1.0/tests/test_cli.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from codex_stats.cli import build_parser
+
+
+class CliTestCase(unittest.TestCase):
+    def test_default_parser(self) -> None:
+        parser = build_parser()
+        args = parser.parse_args([])
+        self.assertIsNone(args.command)
+        self.assertFalse(args.json_output)
+
+    def test_session_parser(self) -> None:
+        parser = build_parser()
+        args = parser.parse_args(["session", "--id", "abc"])
+        self.assertEqual(args.command, "session")
+        self.assertEqual(args.session_id, "abc")
+
+
+if __name__ == "__main__":
+    unittest.main()

codex_stats-0.1.0/tests/test_metrics.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import json
+import sqlite3
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from codex_stats.config import Paths
+from codex_stats.ingest import get_session, get_session_details
+from codex_stats.metrics import summarize_today
+
+
+class MetricsTestCase(unittest.TestCase):
+    def setUp(self) -> None:
+        self.tmpdir = tempfile.TemporaryDirectory()
+        root = Path(self.tmpdir.name)
+        codex_home = root / ".codex"
+        sessions_dir = codex_home / "sessions" / "2026" / "04" / "03"
+        sessions_dir.mkdir(parents=True)
+        self.state_db = codex_home / "state_5.sqlite"
+        rollout_path = sessions_dir / "rollout-test.jsonl"
+
+        connection = sqlite3.connect(self.state_db)
+        connection.execute(
+            """
+            CREATE TABLE threads (
+                id TEXT PRIMARY KEY,
+                rollout_path TEXT NOT NULL,
+                created_at INTEGER NOT NULL,
+                updated_at INTEGER NOT NULL,
+                source TEXT NOT NULL,
+                model_provider TEXT NOT NULL,
+                cwd TEXT NOT NULL,
+                title TEXT NOT NULL,
+                sandbox_policy TEXT NOT NULL,
+                approval_mode TEXT NOT NULL,
+                tokens_used INTEGER NOT NULL DEFAULT 0,
+                has_user_event INTEGER NOT NULL DEFAULT 0,
+                archived INTEGER NOT NULL DEFAULT 0,
+                archived_at INTEGER,
+                git_sha TEXT,
+                git_branch TEXT,
+                git_origin_url TEXT,
+                cli_version TEXT NOT NULL DEFAULT '',
+                first_user_message TEXT NOT NULL DEFAULT '',
+                agent_nickname TEXT,
+                agent_role TEXT,
+                memory_mode TEXT NOT NULL DEFAULT 'enabled',
+                model TEXT,
+                reasoning_effort TEXT,
+                agent_path TEXT
+            )
+            """
+        )
+        connection.execute(
+            """
+            INSERT INTO threads (
+                id, rollout_path, created_at, updated_at, source, model_provider, cwd,
+                title, sandbox_policy, approval_mode, tokens_used, model
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                "session-1",
+                str(rollout_path),
+                1775222209,
+                1775222447,
+                "cli",
+                "openai",
+                "/tmp/project",
+                "Test Thread",
+                "workspace-write",
+                "default",
+                223342,
+                "gpt-5.4",
+            ),
+        )
+        connection.commit()
+        connection.close()
+
+        lines = [
+            {
+                "timestamp": "2026-04-03T13:17:23.324Z",
+                "type": "session_meta",
+                "payload": {"timestamp": "2026-04-03T13:16:49.765Z"},
+            },
+            {
+                "timestamp": "2026-04-03T13:17:23.325Z",
+                "type": "event_msg",
+                "payload": {"type": "user_message", "message": "first"},
+            },
+            {
+                "timestamp": "2026-04-03T13:17:23.740Z",
+                "type": "event_msg",
+                "payload": {
+                    "type": "token_count",
+                    "info": {
+                        "total_token_usage": {
+                            "input_tokens": 100,
+                            "cached_input_tokens": 20,
+                            "output_tokens": 10,
+                            "reasoning_output_tokens": 3,
+                            "total_tokens": 110,
+                        }
+                    },
+                },
+            },
+            {
+                "timestamp": "2026-04-03T13:18:23.325Z",
+                "type": "event_msg",
+                "payload": {"type": "user_message", "message": "second"},
+            },
+            {
+                "timestamp": "2026-04-03T13:18:23.740Z",
+                "type": "event_msg",
+                "payload": {
+                    "type": "token_count",
+                    "info": {
+                        "total_token_usage": {
+                            "input_tokens": 250,
+                            "cached_input_tokens": 50,
+                            "output_tokens": 30,
+                            "reasoning_output_tokens": 7,
+                            "total_tokens": 280,
+                        }
+                    },
+                },
+            },
+        ]
+        rollout_path.write_text("\n".join(json.dumps(line) for line in lines), encoding="utf-8")
+        self.paths = Paths(
+            codex_home=codex_home,
+            state_db=self.state_db,
+            logs_db=codex_home / "logs_1.sqlite",
+            sessions_dir=codex_home / "sessions",
+        )
+
+    def tearDown(self) -> None:
+        self.tmpdir.cleanup()
+
+    def test_session_details_are_read_from_local_state(self) -> None:
+        session = get_session(self.paths, "session-1")
+        assert session is not None
+        details = get_session_details(self.paths, session)
+        self.assertEqual(details.request_count, 2)
+        self.assertEqual(details.input_tokens, 250)
+        self.assertEqual(details.output_tokens, 30)
+        self.assertEqual(details.effective_total_tokens(), 280)
+
+    def test_today_summary_aggregates_sessions(self) -> None:
+        summary = summarize_today(self.paths)
+        self.assertEqual(summary.sessions, 1)
+        self.assertEqual(summary.requests, 2)
+        self.assertEqual(summary.total_tokens, 280)
+        self.assertEqual(summary.top_model, "gpt-5.4")
+
+
+if __name__ == "__main__":
+    unittest.main()