cli-consumption 0.0.3__tar.gz → 0.0.4__tar.gz

{cli_consumption-0.0.3 → cli_consumption-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cli-consumption
-Version: 0.0.3
+Version: 0.0.4
 Summary: Analyze and consolidate AI coding CLI consumption across machines.
 Project-URL: Homepage, https://github.com/Guillaume-Lombardo/cli-consumption
 Project-URL: Documentation, https://github.com/Guillaume-Lombardo/cli-consumption#readme
@@ -33,8 +33,8 @@ models, tokens, tools, conversations, and turns. It can analyze one workstation,
 consolidate copied data from several machines, or send metadata-only snapshots to a
 central collector.
 
-Codex and the core Claude Code local transcript format are supported. OpenCode, Kilo
-Code, and Pi are planned behind the same provider-neutral adapter contract.
+Codex, OpenCode, and the core Claude Code local transcript format are supported. Kilo
+Code and Pi are planned behind the same provider-neutral adapter contract.
 
 The collector deliberately excludes prompts, responses, tool arguments, and
 credentials. See [Privacy](docs/privacy.md) before sharing a database or export.
@@ -102,6 +102,12 @@ Select Claude Code to read `~/.claude/projects/` instead:
 uv run cli-consumption collect --provider claude --database usage.sqlite
 ```
 
+Select OpenCode to read `~/.local/share/opencode/opencode.db` instead:
+
+```bash
+uv run cli-consumption collect --provider opencode --database usage.sqlite
+```
+
 Use `all` to detect and collect every supported provider present on the machine:
 
 ```bash
@@ -142,6 +148,14 @@ uv run cli-consumption collect --provider claude \
   --source laptop=/data/claude/laptop
 ```
 
+Copied OpenCode sources point to the data directory containing `opencode.db`:
+
+```bash
+uv run cli-consumption collect --provider opencode \
+  --source desktop=/data/opencode/desktop \
+  --source laptop=/data/opencode/laptop
+```
+
 ## SQLite and PostgreSQL
 
 A file path selects SQLite. A SQLAlchemy URL selects PostgreSQL:

{cli_consumption-0.0.3 → cli_consumption-0.0.4}/README.md

@@ -5,8 +5,8 @@ models, tokens, tools, conversations, and turns. It can analyze one workstation,
 consolidate copied data from several machines, or send metadata-only snapshots to a
 central collector.
 
-Codex and the core Claude Code local transcript format are supported. OpenCode, Kilo
-Code, and Pi are planned behind the same provider-neutral adapter contract.
+Codex, OpenCode, and the core Claude Code local transcript format are supported. Kilo
+Code and Pi are planned behind the same provider-neutral adapter contract.
 
 The collector deliberately excludes prompts, responses, tool arguments, and
 credentials. See [Privacy](docs/privacy.md) before sharing a database or export.
@@ -74,6 +74,12 @@ Select Claude Code to read `~/.claude/projects/` instead:
 uv run cli-consumption collect --provider claude --database usage.sqlite
 ```
 
+Select OpenCode to read `~/.local/share/opencode/opencode.db` instead:
+
+```bash
+uv run cli-consumption collect --provider opencode --database usage.sqlite
+```
+
 Use `all` to detect and collect every supported provider present on the machine:
 
 ```bash
@@ -114,6 +120,14 @@ uv run cli-consumption collect --provider claude \
   --source laptop=/data/claude/laptop
 ```
 
+Copied OpenCode sources point to the data directory containing `opencode.db`:
+
+```bash
+uv run cli-consumption collect --provider opencode \
+  --source desktop=/data/opencode/desktop \
+  --source laptop=/data/opencode/laptop
+```
+
 ## SQLite and PostgreSQL
 
 A file path selects SQLite. A SQLAlchemy URL selects PostgreSQL:

{cli_consumption-0.0.3 → cli_consumption-0.0.4}/docs/architecture.md

@@ -16,8 +16,8 @@ provider files -> adapter -> metadata-only snapshot -> SQL storage -> dashboard/
 
 - `adapters`: parse a CLI's local data into conversations, turns, model calls, tool
   calls, context-pressure samples, bounded turn settings, compactions, and content-free
-  work-item intervals. Codex exposes the complete analytics contract; Claude Code
-  exposes the core dimensions available in its local transcripts.
+  work-item intervals. Codex exposes the complete analytics contract; Claude Code and
+  OpenCode expose the core dimensions available in their local stores.
 - `models`: define the transport boundary shared by offline and API ingestion.
 - `storage`: owns the normalized schema, idempotent replacement rules, SQLite, and
   PostgreSQL engine creation.

{cli_consumption-0.0.3 → cli_consumption-0.0.4}/docs/provider-support.md

@@ -4,7 +4,7 @@
 | --- | --- | --- |
 | Codex | Supported | Local rollout JSONL and optional metadata-only subagent state |
 | Claude Code | Supported (core) | Local project transcript JSONL |
-| OpenCode | Planned | To be verified before implementation |
+| OpenCode | Supported (core) | Local SQLite v2 session store |
 | Kilo Code | Planned | To be verified before implementation |
 | Pi | Planned | To be verified before implementation |
 
@@ -36,6 +36,19 @@ is not billing data. This first increment does not collect subagent transcripts,
 context-window sizes, effort/service-tier settings, TTFT, provider-reported duration,
 or technical work-item intervals.
 
-Provider formats can change without notice. Unknown fields are ignored; malformed JSONL
-records are counted and skipped. Compatibility fixes should add a fixture for both the
-old and new format whenever possible.
+OpenCode reads `opencode.db` from its XDG data directory (normally
+`~/.local/share/opencode/`). It extracts v2 session messages, model references, token
+usage, tool names, and compaction timestamps while discarding message text, reasoning,
+tool inputs/results, shell commands/output, paths, titles, errors, costs, and arbitrary
+metadata. Model labels combine OpenCode's provider and model identifiers.
+
+OpenCode reports uncached input, cache reads, cache writes, visible output, and
+reasoning separately. Normalized input and output totals include their respective
+components. The adapter does not currently read pre-v2 JSON storage, legacy
+`message`/`part` tables, child-session relationships, context-window sizes, or
+provider-reported cost. The SQLite schema is internal and may change without notice;
+local token events are not billing data.
+
+Provider formats can change without notice. Unknown fields are ignored; malformed
+provider records are counted and skipped. Compatibility fixes should add a fixture for
+both the old and new format whenever possible.

{cli_consumption-0.0.3 → cli_consumption-0.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cli-consumption"
-version = "0.0.3"
+version = "0.0.4"
 description = "Analyze and consolidate AI coding CLI consumption across machines."
 readme = "README.md"
 requires-python = ">=3.14"

cli_consumption-0.0.4/src/cli_consumption/adapters/__init__.py

@@ -0,0 +1,5 @@
+from cli_consumption.adapters.claude import ClaudeAdapter
+from cli_consumption.adapters.codex import CodexAdapter
+from cli_consumption.adapters.opencode import OpenCodeAdapter
+
+__all__ = ["ClaudeAdapter", "CodexAdapter", "OpenCodeAdapter"]

cli_consumption-0.0.4/src/cli_consumption/adapters/opencode.py

@@ -0,0 +1,463 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import re
+import sqlite3
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from cli_consumption.models import Snapshot, empty_tokens
+
+MAX_BIGINT = 9_223_372_036_854_775_807
+SAFE_LABEL = re.compile(r"[A-Za-z0-9][A-Za-z0-9_.:/+-]*")
+
+
+@dataclass(slots=True)
+class _Message:
+    external_id: str
+    kind: str
+    sequence: int
+    created_at: datetime | None
+    updated_at: datetime | None
+    data: dict[str, Any]
+
+
+@dataclass(slots=True)
+class _Conversation:
+    machine: str
+    external_id: str
+    directory: str | None
+    created_at: datetime | None
+    updated_at: datetime | None
+    messages: list[_Message]
+    digest: str
+
+
+class OpenCodeAdapter:
+    """Read metadata from OpenCode's SQLite v2 store without retaining content."""
+
+    name = "opencode"
+
+    def collect(
+        self,
+        sources: list[tuple[str, Path]],
+        project_mappings: list[tuple[str, str]] | None = None,
+    ) -> Snapshot:
+        selected: dict[str, _Conversation] = {}
+        duplicates = malformed = 0
+        for machine, home in sources:
+            database = home / "opencode.db"
+            if not database.is_file():
+                raise ValueError(f"Missing OpenCode database: {database}")
+            conversations, invalid = _read_database(database, machine)
+            malformed += invalid
+            for candidate in conversations:
+                previous = selected.get(candidate.external_id)
+                if previous is None:
+                    selected[candidate.external_id] = candidate
+                    continue
+                duplicates += 1
+                if _rank(candidate) > _rank(previous):
+                    selected[candidate.external_id] = candidate
+
+        snapshot = Snapshot(
+            provider=self.name,
+            duplicate_conversations=duplicates,
+            malformed_records=malformed,
+        )
+        for conversation in sorted(
+            selected.values(), key=lambda item: item.external_id
+        ):
+            self._normalize(snapshot, conversation, project_mappings or [])
+        return snapshot
+
+    def _normalize(
+        self,
+        snapshot: Snapshot,
+        source: _Conversation,
+        mappings: list[tuple[str, str]],
+    ) -> None:
+        conversation_id = f"opencode:{source.external_id}"
+        turns: dict[str, dict[str, Any]] = {}
+        turn_models: dict[str, set[str]] = {}
+        active: str | None = None
+        effective_model: str | None = None
+        calls: list[tuple[str | None, datetime | None, str, dict[str, int]]] = []
+        tools: list[tuple[str | None, datetime | None, str]] = []
+        compactions: list[tuple[str | None, datetime | None]] = []
+        timestamps = [source.created_at]
+
+        for message in source.messages:
+            timestamp = message.created_at or _timestamp(
+                _mapping(message.data.get("time")).get("created")
+            )
+            completed_at = _timestamp(
+                _mapping(message.data.get("time")).get("completed")
+            )
+            timestamps.extend((timestamp, completed_at))
+
+            if message.kind == "user":
+                if active is not None:
+                    _finish_turn(turns[active], timestamp)
+                active = message.external_id
+                turns[active] = {
+                    "id": f"{conversation_id}:{active}",
+                    "conversation_id": conversation_id,
+                    "external_id": active,
+                    "started_at": _iso(timestamp),
+                    "ended_at": None,
+                    "status": "in-progress",
+                    "duration_ms": None,
+                    "time_to_first_token_ms": None,
+                    "model_calls": 0,
+                    "tool_calls": 0,
+                    **empty_tokens(),
+                }
+                turn_models[active] = set()
+                continue
+
+            if message.kind == "model-switched":
+                effective_model = _model(message.data.get("model"))
+                continue
+
+            if message.kind == "compaction":
+                compactions.append((active, timestamp))
+                continue
+
+            if message.kind != "assistant":
+                continue
+
+            model = _model(message.data.get("model")) or effective_model or "unknown"
+            effective_model = model if model != "unknown" else effective_model
+            tokens = _usage(message.data.get("tokens"))
+            calls.append((active, timestamp, model, tokens))
+            turn = turns.get(active or "")
+            if turn:
+                turn["model_calls"] += 1
+                turn_models[active or ""].add(model)
+                _add_tokens(turn, tokens)
+                turn["ended_at"] = _iso(completed_at or timestamp) or turn["ended_at"]
+                if isinstance(message.data.get("error"), dict):
+                    turn["status"] = "aborted"
+                elif (
+                    completed_at is not None or _label(message.data.get("finish"), 255)
+                ) and turn["status"] != "aborted":
+                    turn["status"] = "completed"
+
+            content = message.data.get("content")
+            if not isinstance(content, list):
+                continue
+            for part in content:
+                if not isinstance(part, dict) or part.get("type") != "tool":
+                    continue
+                name = _label(part.get("name"), 512)
+                if not name:
+                    continue
+                part_time = _mapping(part.get("time"))
+                tools.append(
+                    (active, _timestamp(part_time.get("created")) or timestamp, name)
+                )
+
+        ended_at = max(
+            (value for value in timestamps if value is not None), default=None
+        )
+        if active is not None:
+            _finish_turn(turns[active], ended_at or source.updated_at)
+
+        totals = empty_tokens()
+        models: set[str] = set()
+        for sequence, (turn_key, timestamp, model, tokens) in enumerate(calls, 1):
+            models.add(model)
+            _add_tokens(totals, tokens)
+            turn = turns.get(turn_key or "")
+            snapshot.model_calls.append(
+                {
+                    "id": f"{conversation_id}:model:{sequence}",
+                    "conversation_id": conversation_id,
+                    "turn_id": turn["id"] if turn else None,
+                    "sequence": sequence,
+                    "timestamp": _iso(timestamp),
+                    "model": model,
+                    **tokens,
+                }
+            )
+
+        for sequence, (turn_key, timestamp, name) in enumerate(tools, 1):
+            turn = turns.get(turn_key or "")
+            if turn:
+                turn["tool_calls"] += 1
+            snapshot.tool_calls.append(
+                {
+                    "id": f"{conversation_id}:tool:{sequence}",
+                    "conversation_id": conversation_id,
+                    "turn_id": turn["id"] if turn else None,
+                    "sequence": sequence,
+                    "timestamp": _iso(timestamp),
+                    "tool_name": name,
+                    "outer_tool_name": name,
+                }
+            )
+
+        for sequence, (turn_key, timestamp) in enumerate(compactions, 1):
+            turn = turns.get(turn_key or "")
+            snapshot.compaction_events.append(
+                {
+                    "id": f"{conversation_id}:compaction:{sequence}",
+                    "conversation_id": conversation_id,
+                    "turn_id": turn["id"] if turn else None,
+                    "sequence": sequence,
+                    "timestamp": _iso(timestamp),
+                }
+            )
+
+        for key, turn in turns.items():
+            snapshot.turns.append(turn)
+            observed = turn_models[key]
+            snapshot.turn_settings.append(
+                {
+                    "id": f"{conversation_id}:settings:{key}",
+                    "conversation_id": conversation_id,
+                    "turn_id": turn["id"],
+                    "model": next(iter(observed)) if len(observed) == 1 else None,
+                    "effort": None,
+                    "collaboration_mode": None,
+                    "service_tier": None,
+                    "context_window_tokens": None,
+                }
+            )
+
+        started_at = source.created_at or min(
+            (value for value in timestamps if value is not None), default=None
+        )
+        ended_at = ended_at or source.updated_at
+        project, project_source = _project(source.directory, mappings)
+        snapshot.conversations.append(
+            {
+                "id": conversation_id,
+                "provider": self.name,
+                "external_id": source.external_id,
+                "source_machine": source.machine,
+                "project": project,
+                "project_source": project_source,
+                "started_at": _iso(started_at),
+                "ended_at": _iso(ended_at),
+                "duration_seconds": (
+                    max(0.0, (ended_at - started_at).total_seconds())
+                    if started_at and ended_at
+                    else None
+                ),
+                "source": "local-sqlite-v2",
+                "models": sorted(models),
+                "iterations": len(turns),
+                "model_calls": len(calls),
+                "tool_calls": len(tools),
+                "compactions": len(compactions),
+                "event_count": len(source.messages),
+                "content_hash": source.digest,
+                **totals,
+            }
+        )
+
+
+def _read_database(path: Path, machine: str) -> tuple[list[_Conversation], int]:
+    try:
+        connection = sqlite3.connect(f"{path.resolve().as_uri()}?mode=ro", uri=True)
+        connection.row_factory = sqlite3.Row
+        connection.execute("PRAGMA trusted_schema=OFF")
+        connection.execute("PRAGMA query_only=ON")
+        session_columns = _columns(connection, "session")
+        message_columns = _columns(connection, "session_message")
+        required_session = {"id", "time_created", "time_updated"}
+        required_message = {
+            "id",
+            "session_id",
+            "type",
+            "seq",
+            "time_created",
+            "time_updated",
+            "data",
+        }
+        if (
+            not required_session <= session_columns
+            or not required_message <= message_columns
+        ):
+            raise ValueError(f"Unsupported OpenCode database schema: {path}")
+
+        directory = "directory" if "directory" in session_columns else "NULL"
+        rows = connection.execute(
+            f"SELECT id, {directory} AS directory, time_created, time_updated "
+            "FROM session ORDER BY id"
+        ).fetchall()
+        conversations: list[_Conversation] = []
+        malformed = 0
+        for row in rows:
+            external_id = _label(row["id"], 500)
+            if not external_id:
+                malformed += 1
+                continue
+            message_rows = connection.execute(
+                "SELECT id, type, seq, time_created, time_updated, data "
+                "FROM session_message WHERE session_id = ? ORDER BY seq, id",
+                (row["id"],),
+            ).fetchall()
+            digest = hashlib.sha256()
+            messages: list[_Message] = []
+            for message_row in message_rows:
+                digest.update(str(tuple(message_row)).encode())
+                message_id = _label(message_row["id"], 512)
+                kind = _label(message_row["type"], 64)
+                try:
+                    data = json.loads(message_row["data"])
+                except (json.JSONDecodeError, TypeError, UnicodeDecodeError):
+                    malformed += 1
+                    continue
+                if not message_id or not kind or not isinstance(data, dict):
+                    malformed += 1
+                    continue
+                sequence = _counter(message_row["seq"])
+                messages.append(
+                    _Message(
+                        message_id,
+                        kind,
+                        sequence,
+                        _timestamp(message_row["time_created"]),
+                        _timestamp(message_row["time_updated"]),
+                        data,
+                    )
+                )
+            conversations.append(
+                _Conversation(
+                    machine=machine,
+                    external_id=external_id,
+                    directory=row["directory"]
+                    if isinstance(row["directory"], str)
+                    else None,
+                    created_at=_timestamp(row["time_created"]),
+                    updated_at=_timestamp(row["time_updated"]),
+                    messages=messages,
+                    digest=digest.hexdigest(),
+                )
+            )
+        return conversations, malformed
+    except sqlite3.DatabaseError:
+        raise ValueError(f"Could not read OpenCode database: {path}") from None
+    finally:
+        if "connection" in locals():
+            connection.close()
+
+
+def _columns(connection: sqlite3.Connection, table: str) -> set[str]:
+    return {
+        str(row["name"]) for row in connection.execute(f'PRAGMA table_info("{table}")')
+    }
+
+
+def _rank(value: _Conversation) -> tuple[int, datetime, str]:
+    return (
+        len(value.messages),
+        value.updated_at or datetime.min.replace(tzinfo=UTC),
+        value.digest,
+    )
+
+
+def _usage(value: object) -> dict[str, int]:
+    usage = _mapping(value)
+    cache = _mapping(usage.get("cache"))
+    uncached = _counter(usage.get("input"))
+    cached = _counter(cache.get("read"))
+    cache_write = _counter(cache.get("write"))
+    visible = _counter(usage.get("output"))
+    reasoning = _counter(usage.get("reasoning"))
+    input_tokens = _sum(uncached, cached, cache_write)
+    output_tokens = _sum(visible, reasoning)
+    attributed = _sum(input_tokens, output_tokens)
+    reported = _counter(usage.get("total"))
+    total = max(attributed, reported)
+    return {
+        "input_tokens": input_tokens,
+        "cached_input_tokens": cached,
+        "cache_write_input_tokens": cache_write,
+        "output_tokens": output_tokens,
+        "reasoning_output_tokens": reasoning,
+        "total_tokens": total,
+        "uncached_input_tokens": uncached,
+        "visible_output_tokens": visible,
+        "unattributed_tokens": max(0, total - attributed),
+    }
+
+
+def _model(value: object) -> str | None:
+    model = _mapping(value)
+    provider = _label(model.get("providerID"), 127)
+    identifier = _label(model.get("id") or model.get("modelID"), 127)
+    if provider and identifier:
+        return f"{provider}/{identifier}"
+    return identifier
+
+
+def _project(directory: str | None, mappings: list[tuple[str, str]]) -> tuple[str, str]:
+    if directory:
+        normalized = directory.replace("\\", "/").rstrip("/")
+        for name, prefix in sorted(
+            mappings, key=lambda item: len(item[1]), reverse=True
+        ):
+            prefix = prefix.replace("\\", "/").rstrip("/")
+            if normalized == prefix or normalized.startswith(prefix + "/"):
+                return name, "mapping"
+    return "outside-project", "none"
+
+
+def _finish_turn(turn: dict[str, Any], fallback: datetime | None) -> None:
+    turn["ended_at"] = turn["ended_at"] or _iso(fallback)
+    start, end = _timestamp(turn["started_at"]), _timestamp(turn["ended_at"])
+    if start and end:
+        turn["duration_ms"] = max(0, int((end - start).total_seconds() * 1000))
+
+
+def _mapping(value: object) -> dict[str, Any]:
+    return value if isinstance(value, dict) else {}
+
+
+def _timestamp(value: object) -> datetime | None:
+    try:
+        if isinstance(value, bool):
+            return None
+        if isinstance(value, int | float) and math.isfinite(value):
+            return datetime.fromtimestamp(value / 1000, UTC)
+        if isinstance(value, str) and value:
+            return datetime.fromisoformat(value.replace("Z", "+00:00")).astimezone(UTC)
+    except (OSError, OverflowError, ValueError):
+        pass
+    return None
+
+
+def _iso(value: object) -> str | None:
+    return value.isoformat() if isinstance(value, datetime) else None
+
+
+def _label(value: object, maximum: int) -> str | None:
+    if not isinstance(value, str):
+        return None
+    value = value.strip()
+    return value if 0 < len(value) <= maximum and SAFE_LABEL.fullmatch(value) else None
+
+
+def _counter(value: object) -> int:
+    if isinstance(value, bool) or not isinstance(value, int | float):
+        return 0
+    if isinstance(value, float) and not math.isfinite(value):
+        return 0
+    return min(MAX_BIGINT, max(0, int(value)))
+
+
+def _sum(*values: int) -> int:
+    return min(MAX_BIGINT, sum(values))
+
+
+def _add_tokens(target: dict[str, Any], tokens: dict[str, int]) -> None:
+    for field, value in tokens.items():
+        target[field] = _sum(int(target[field]), value)

{cli_consumption-0.0.3 → cli_consumption-0.0.4}/src/cli_consumption/cli.py

@@ -8,7 +8,7 @@ from typing import Annotated
 import typer
 
 from cli_consumption import __version__
-from cli_consumption.adapters import ClaudeAdapter, CodexAdapter
+from cli_consumption.adapters import ClaudeAdapter, CodexAdapter, OpenCodeAdapter
 from cli_consumption.api import create_app
 from cli_consumption.dashboard import generate_dashboard
 from cli_consumption.exporting import export_csv
@@ -49,7 +49,8 @@ def providers() -> None:
     typer.echo("all      auto-detect supported providers")
     typer.echo("codex    supported")
     typer.echo("claude   supported")
-    for provider in ("opencode", "kilo", "pi"):
+    typer.echo("opencode supported")
+    for provider in ("kilo", "pi"):
         typer.echo(f"{provider:<8} planned")
 
 
@@ -224,6 +225,11 @@ def _collect_snapshots(
     adapters = {
         "codex": (CodexAdapter, ".codex", "sessions"),
         "claude": (ClaudeAdapter, ".claude", "projects"),
+        "opencode": (
+            OpenCodeAdapter,
+            ".local/share/opencode",
+            "opencode.db",
+        ),
     }
     if provider != "all" and provider not in adapters:
         raise typer.BadParameter(
@@ -243,7 +249,7 @@ def _collect_snapshots(
         sources = _parse_source_values(source_values)
         matched_labels: set[str] = set()
         for adapter, _, directory in adapters.values():
-            matched = [source for source in sources if (source[1] / directory).is_dir()]
+            matched = [source for source in sources if (source[1] / directory).exists()]
             if matched:
                 matched_labels.update(label for label, _ in matched)
                 snapshots.append(adapter().collect(matched, mappings))
@@ -257,7 +263,7 @@ def _collect_snapshots(
         machine = platform.node()
         for adapter, home, directory in adapters.values():
             path = (Path.home() / home).resolve()
-            if (path / directory).is_dir():
+            if (path / directory).exists():
                 snapshots.append(adapter().collect([(machine, path)], mappings))
     if not snapshots:
         raise typer.BadParameter("No supported provider data detected.")
@@ -271,9 +277,9 @@ def _parse_sources(
         values = [f"{platform.node()}={Path.home() / home}"]
     result = _parse_source_values(values)
     for _, path in result:
-        if not (path / directory).is_dir():
+        if not (path / directory).exists():
             raise typer.BadParameter(
-                f"Missing {directory} directory: {path / directory}"
+                f"Missing provider data {directory}: {path / directory}"
             )
     return result
 

{cli_consumption-0.0.3 → cli_consumption-0.0.4}/tests/test_cli.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import json
+import sqlite3
 from pathlib import Path
 
 from click.utils import strip_ansi
@@ -22,6 +24,7 @@ def test_provider_status_is_explicit() -> None:
     assert "all      auto-detect" in result.stdout
     assert "codex    supported" in result.stdout
     assert "claude   supported" in result.stdout
+    assert "opencode supported" in result.stdout
 
 
 def test_version_and_unsupported_provider_are_explicit(tmp_path: Path) -> None:
@@ -31,7 +34,7 @@ def test_version_and_unsupported_provider_are_explicit(tmp_path: Path) -> None:
 
     result = runner.invoke(
         app,
-        ["collect", "--provider", "opencode", "--database", str(tmp_path / "db")],
+        ["collect", "--provider", "kilo", "--database", str(tmp_path / "db")],
     )
     assert result.exit_code == 2
     assert "not implemented yet" in result.output
@@ -62,6 +65,54 @@ def test_collects_claude_code(tmp_path: Path) -> None:
     assert "1 written" in result.stdout
 
 
+def test_collects_opencode(tmp_path: Path) -> None:
+    home = tmp_path / "opencode"
+    home.mkdir()
+    connection = sqlite3.connect(home / "opencode.db")
+    connection.executescript(
+        """
+        CREATE TABLE session (
+            id TEXT PRIMARY KEY,
+            time_created INTEGER NOT NULL,
+            time_updated INTEGER NOT NULL
+        );
+        CREATE TABLE session_message (
+            id TEXT PRIMARY KEY,
+            session_id TEXT NOT NULL,
+            type TEXT NOT NULL,
+            seq INTEGER NOT NULL,
+            time_created INTEGER NOT NULL,
+            time_updated INTEGER NOT NULL,
+            data TEXT NOT NULL
+        );
+        """
+    )
+    connection.execute("INSERT INTO session VALUES ('ses_cli', 1000, 2000)")
+    connection.execute(
+        "INSERT INTO session_message VALUES (?, ?, ?, ?, ?, ?, ?)",
+        ("msg_cli", "ses_cli", "user", 1, 1000, 1000, json.dumps({"text": "x"})),
+    )
+    connection.commit()
+    connection.close()
+
+    result = runner.invoke(
+        app,
+        [
+            "collect",
+            "--provider",
+            "opencode",
+            "--source",
+            f"desktop={home}",
+            "--database",
+            str(tmp_path / "opencode.sqlite"),
+        ],
+    )
+
+    assert result.exit_code == 0, result.output
+    assert "Ingestion opencode" in result.stdout
+    assert "1 written" in result.stdout
+
+
 def test_collects_all_detected_providers(tmp_path: Path, rollout_factory) -> None:
     codex_home = tmp_path / "codex"
     claude_home = tmp_path / "claude"

cli_consumption-0.0.4/tests/test_opencode_adapter.py

@@ -0,0 +1,261 @@
+from __future__ import annotations
+
+import json
+import sqlite3
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from cli_consumption.adapters.opencode import OpenCodeAdapter
+from cli_consumption.dashboard import generate_dashboard
+from cli_consumption.exporting import export_csv
+from cli_consumption.storage import (
+    TABLES,
+    create_database_engine,
+    ingest_snapshot,
+    read_table,
+)
+
+CANARY = "privacy canary secret"
+
+
+def database(home: Path, *, extra: bool = False, malformed: bool = False) -> Path:
+    path = home / "opencode.db"
+    home.mkdir(parents=True, exist_ok=True)
+    connection = sqlite3.connect(path)
+    connection.executescript(
+        """
+        CREATE TABLE session (
+            id TEXT PRIMARY KEY,
+            directory TEXT NOT NULL,
+            title TEXT NOT NULL,
+            metadata TEXT,
+            time_created INTEGER NOT NULL,
+            time_updated INTEGER NOT NULL
+        );
+        CREATE TABLE session_message (
+            id TEXT PRIMARY KEY,
+            session_id TEXT NOT NULL,
+            type TEXT NOT NULL,
+            seq INTEGER NOT NULL,
+            time_created INTEGER NOT NULL,
+            time_updated INTEGER NOT NULL,
+            data TEXT NOT NULL
+        );
+        """
+    )
+    connection.execute(
+        "INSERT INTO session VALUES (?, ?, ?, ?, ?, ?)",
+        (
+            "ses_test",
+            "/srv/work/acme/service",
+            CANARY,
+            json.dumps({"secret": CANARY}),
+            1_777_114_800_000,
+            1_777_114_812_000 if extra else 1_777_114_811_000,
+        ),
+    )
+    messages: list[tuple[str, str, int, int, dict[str, Any]]] = [
+        (
+            "msg_user_1",
+            "user",
+            1,
+            1_777_114_800_000,
+            {"text": CANARY, "files": [{"path": CANARY}]},
+        ),
+        (
+            "msg_assistant_1",
+            "assistant",
+            2,
+            1_777_114_801_000,
+            {
+                "agent": "build",
+                "model": {"providerID": "anthropic", "id": "claude-sonnet-4-6"},
+                "content": [
+                    {"type": "text", "id": "part_text", "text": CANARY},
+                    {
+                        "type": "tool",
+                        "id": "part_tool",
+                        "name": "bash",
+                        "state": {
+                            "status": "completed",
+                            "input": {"command": CANARY},
+                            "content": [{"type": "text", "text": CANARY}],
+                            "structured": {"output": CANARY},
+                        },
+                        "time": {
+                            "created": 1_777_114_801_500,
+                            "completed": 1_777_114_802_000,
+                        },
+                    },
+                ],
+                "finish": "tool-calls",
+                "tokens": {
+                    "input": 100,
+                    "output": 20,
+                    "reasoning": 5,
+                    "cache": {"read": 40, "write": 10},
+                },
+                "time": {
+                    "created": 1_777_114_801_000,
+                    "completed": 1_777_114_802_000,
+                },
+                "metadata": {"secret": CANARY},
+            },
+        ),
+        (
+            "msg_compaction",
+            "compaction",
+            3,
+            1_777_114_803_000,
+            {"reason": "auto", "summary": CANARY, "recent": CANARY},
+        ),
+        (
+            "msg_user_2",
+            "user",
+            4,
+            1_777_114_810_000,
+            {"text": CANARY, "files": []},
+        ),
+        (
+            "msg_assistant_2",
+            "assistant",
+            5,
+            1_777_114_811_000,
+            {
+                "model": {"providerID": "openai", "id": "gpt-5"},
+                "content": [{"type": "text", "id": "part", "text": CANARY}],
+                "tokens": {
+                    "input": 2,
+                    "output": 0,
+                    "reasoning": 1,
+                    "cache": {"read": 0, "write": 0},
+                },
+                "error": {"type": "unknown", "message": CANARY},
+                "time": {
+                    "created": 1_777_114_811_000,
+                    "completed": 1_777_114_811_500,
+                },
+            },
+        ),
+    ]
+    if extra:
+        messages.append(
+            (
+                "msg_system",
+                "system",
+                6,
+                1_777_114_812_000,
+                {"text": CANARY},
+            )
+        )
+    connection.executemany(
+        "INSERT INTO session_message "
+        "(id, session_id, type, seq, time_created, time_updated, data) "
+        "VALUES (?, 'ses_test', ?, ?, ?, ?, ?)",
+        [
+            (identifier, kind, sequence, timestamp, timestamp, json.dumps(data))
+            for identifier, kind, sequence, timestamp, data in messages
+        ],
+    )
+    if malformed:
+        connection.execute(
+            "INSERT INTO session_message VALUES (?, ?, ?, ?, ?, ?, ?)",
+            (
+                "msg_bad_json",
+                "ses_test",
+                "assistant",
+                99,
+                1_777_114_899_000,
+                1_777_114_899_000,
+                "not-json",
+            ),
+        )
+    connection.commit()
+    connection.close()
+    return path
+
+
+def test_collects_v2_usage_tools_turns_and_compactions(tmp_path: Path) -> None:
+    home = tmp_path / "opencode"
+    database(home)
+
+    snapshot = OpenCodeAdapter().collect(
+        [("laptop", home)], [("acme", "/srv/work/acme")]
+    )
+
+    conversation = snapshot.conversations[0]
+    assert conversation["id"] == "opencode:ses_test"
+    assert conversation["project"] == "acme"
+    assert conversation["models"] == ["anthropic/claude-sonnet-4-6", "openai/gpt-5"]
+    assert conversation["model_calls"] == 2
+    assert conversation["tool_calls"] == 1
+    assert conversation["input_tokens"] == 152
+    assert conversation["uncached_input_tokens"] == 102
+    assert conversation["cached_input_tokens"] == 40
+    assert conversation["cache_write_input_tokens"] == 10
+    assert conversation["output_tokens"] == 26
+    assert conversation["reasoning_output_tokens"] == 6
+    assert conversation["visible_output_tokens"] == 20
+    assert conversation["total_tokens"] == 178
+    assert [turn["status"] for turn in snapshot.turns] == ["completed", "aborted"]
+    assert snapshot.tool_calls[0]["tool_name"] == "bash"
+    assert snapshot.compaction_events[0]["turn_id"] == "opencode:ses_test:msg_user_1"
+    assert CANARY not in str(snapshot.to_dict())
+
+
+def test_deduplicates_copies_and_handles_partial_or_malformed_rows(
+    tmp_path: Path,
+) -> None:
+    first, second = tmp_path / "first", tmp_path / "second"
+    database(first, malformed=True)
+    database(second, extra=True)
+
+    snapshot = OpenCodeAdapter().collect([("desktop", first), ("laptop", second)])
+
+    assert snapshot.duplicate_conversations == 1
+    assert snapshot.malformed_records == 1
+    assert snapshot.conversations[0]["source_machine"] == "laptop"
+    assert snapshot.conversations[0]["event_count"] == 6
+    assert (
+        snapshot.to_dict()
+        == OpenCodeAdapter().collect([("desktop", first), ("laptop", second)]).to_dict()
+    )
+
+    with pytest.raises(ValueError, match="Missing OpenCode database"):
+        OpenCodeAdapter().collect([("machine", tmp_path / "missing")])
+
+
+def test_rejects_old_schema_without_exposing_records(tmp_path: Path) -> None:
+    home = tmp_path / "old"
+    home.mkdir()
+    connection = sqlite3.connect(home / "opencode.db")
+    connection.execute("CREATE TABLE session (id TEXT PRIMARY KEY)")
+    connection.commit()
+    connection.close()
+
+    with pytest.raises(
+        ValueError, match="Unsupported OpenCode database schema"
+    ) as error:
+        OpenCodeAdapter().collect([("machine", home)])
+    assert CANARY not in str(error.value)
+
+
+def test_privacy_canary_is_absent_from_storage_and_exports(tmp_path: Path) -> None:
+    home = tmp_path / "opencode"
+    database(home, extra=True)
+    snapshot = OpenCodeAdapter().collect([("machine", home)])
+    engine = create_database_engine(tmp_path / "usage.sqlite")
+    try:
+        ingest_snapshot(engine, snapshot)
+        rows = {name: read_table(engine, name) for name in TABLES}
+        assert CANARY not in json.dumps(rows)
+        output = tmp_path / "reports"
+        paths = export_csv(engine, output)
+        dashboard = output / "dashboard.html"
+        generate_dashboard(engine, dashboard)
+        assert all(CANARY not in path.read_text() for path in paths)
+        assert CANARY not in dashboard.read_text()
+    finally:
+        engine.dispose()

{cli_consumption-0.0.3 → cli_consumption-0.0.4}/uv.lock

@@ -56,7 +56,7 @@ wheels = [
 
 [[package]]
 name = "cli-consumption"
-version = "0.0.3"
+version = "0.0.4"
 source = { editable = "." }
 dependencies = [
     { name = "fastapi" },

cli_consumption-0.0.3/src/cli_consumption/adapters/__init__.py

@@ -1,4 +0,0 @@
-from cli_consumption.adapters.claude import ClaudeAdapter
-from cli_consumption.adapters.codex import CodexAdapter
-
-__all__ = ["ClaudeAdapter", "CodexAdapter"]