cli-consumption 0.0.6__tar.gz → 0.0.7__tar.gz

{cli_consumption-0.0.6 → cli_consumption-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cli-consumption
-Version: 0.0.6
+Version: 0.0.7
 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, Kilo Code, Pi, OpenCode, and the core Claude Code local transcript format are
-supported.
+Codex, Gemini CLI, Kilo Code, Pi, OpenCode, and the core Claude Code local transcript
+format are supported.
 
 The collector deliberately excludes prompts, responses, tool arguments, and
 credentials. See [Privacy](docs/privacy.md) before sharing a database or export.
@@ -120,6 +120,12 @@ Select Pi to read `~/.pi/agent/sessions/` instead:
 uv run cli-consumption collect --provider pi --database usage.sqlite
 ```
 
+Select Gemini CLI to read `~/.gemini/tmp/*/chats/` instead:
+
+```bash
+uv run cli-consumption collect --provider gemini --database usage.sqlite
+```
+
 Use `all` to detect and collect every supported provider present on the machine:
 
 ```bash
@@ -184,6 +190,14 @@ uv run cli-consumption collect --provider pi \
   --source laptop=/data/pi/laptop
 ```
 
+Copied Gemini CLI sources point to the configuration directory containing `tmp/`:
+
+```bash
+uv run cli-consumption collect --provider gemini \
+  --source desktop=/data/gemini/desktop \
+  --source laptop=/data/gemini/laptop
+```
+
 ## SQLite and PostgreSQL
 
 A file path selects SQLite. A SQLAlchemy URL selects PostgreSQL:

{cli_consumption-0.0.6 → cli_consumption-0.0.7}/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, Kilo Code, Pi, OpenCode, and the core Claude Code local transcript format are
-supported.
+Codex, Gemini CLI, Kilo Code, Pi, OpenCode, and the core Claude Code local transcript
+format are supported.
 
 The collector deliberately excludes prompts, responses, tool arguments, and
 credentials. See [Privacy](docs/privacy.md) before sharing a database or export.
@@ -92,6 +92,12 @@ Select Pi to read `~/.pi/agent/sessions/` instead:
 uv run cli-consumption collect --provider pi --database usage.sqlite
 ```
 
+Select Gemini CLI to read `~/.gemini/tmp/*/chats/` instead:
+
+```bash
+uv run cli-consumption collect --provider gemini --database usage.sqlite
+```
+
 Use `all` to detect and collect every supported provider present on the machine:
 
 ```bash
@@ -156,6 +162,14 @@ uv run cli-consumption collect --provider pi \
   --source laptop=/data/pi/laptop
 ```
 
+Copied Gemini CLI sources point to the configuration directory containing `tmp/`:
+
+```bash
+uv run cli-consumption collect --provider gemini \
+  --source desktop=/data/gemini/desktop \
+  --source laptop=/data/gemini/laptop
+```
+
 ## SQLite and PostgreSQL
 
 A file path selects SQLite. A SQLAlchemy URL selects PostgreSQL:

{cli_consumption-0.0.6 → cli_consumption-0.0.7}/docs/architecture.md

@@ -17,8 +17,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,
-  Kilo Code, OpenCode, and Pi expose the core dimensions available in their local
-  stores.
+  Gemini CLI, Kilo Code, OpenCode, and Pi 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.6 → cli_consumption-0.0.7}/docs/provider-support.md

@@ -4,6 +4,7 @@
 | --- | --- | --- |
 | Codex | Supported | Local rollout JSONL and optional metadata-only subagent state |
 | Claude Code | Supported (core) | Local project transcript JSONL |
+| Gemini CLI | Supported (core) | Local automatic chat history JSON and JSONL |
 | Kilo Code | Supported (core) | Local SQLite session store |
 | OpenCode | Supported (core) | Local SQLite v2 session store |
 | Pi | Supported (core) | Local session JSONL v1-v3 |
@@ -36,6 +37,23 @@ 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.
 
+Gemini CLI reads automatic session history from
+`~/.gemini/tmp/<project-hash>/chats/session-*.jsonl` and the legacy `.json` form. It
+replays append-only message updates, metadata checkpoints, and rewinds before extracting
+user turns, Gemini model calls, token usage, and tool names. Prompts, responses, thoughts,
+summaries, memory scratchpads, tool arguments/results/status details, directories, and
+project hashes are discarded.
+
+Gemini reports prompt, cached prompt, visible candidate, thought, tool-prompt, and total
+token counters. Normalized input is the prompt count, cached input is its bounded subset,
+and normalized output combines candidate and thought tokens. Provider totals above the
+attributed input/output sum remain unattributed; tool-prompt tokens are treated as a
+prompt subset rather than added twice. This adapter does not derive a project name from
+Gemini's one-way project hash, collect nested subagent sessions, compaction timestamps,
+context-window sizes, configuration labels, tool outcomes, or provider-reported
+durations. Gemini CLI's internal history schema can change without notice, and local
+token events are not billing data.
+
 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,

{cli_consumption-0.0.6 → cli_consumption-0.0.7}/docs/roadmap.md

@@ -6,6 +6,7 @@
 - Core Claude Code local transcript collector
 - Core Pi local session collector
 - Core Kilo Code local SQLite collector
+- Core Gemini CLI local chat-history collector
 - Offline multi-machine deduplication
 - SQLite and PostgreSQL storage
 - Metadata-only central collection API

{cli_consumption-0.0.6 → cli_consumption-0.0.7}/pyproject.toml

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

{cli_consumption-0.0.6 → cli_consumption-0.0.7}/src/cli_consumption/adapters/__init__.py

@@ -1,5 +1,6 @@
 from cli_consumption.adapters.claude import ClaudeAdapter
 from cli_consumption.adapters.codex import CodexAdapter
+from cli_consumption.adapters.gemini import GeminiAdapter
 from cli_consumption.adapters.kilo import KiloAdapter
 from cli_consumption.adapters.opencode import OpenCodeAdapter
 from cli_consumption.adapters.pi import PiAdapter
@@ -7,6 +8,7 @@ from cli_consumption.adapters.pi import PiAdapter
 __all__ = [
     "ClaudeAdapter",
     "CodexAdapter",
+    "GeminiAdapter",
     "KiloAdapter",
     "OpenCodeAdapter",
     "PiAdapter",

cli_consumption-0.0.7/src/cli_consumption/adapters/gemini.py

@@ -0,0 +1,397 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import re
+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 _Candidate:
+    machine: str
+    path: Path
+    external_id: str
+    event_count: int
+    digest: str
+
+
+class GeminiAdapter:
+    """Read Gemini CLI chat metadata while discarding conversation content."""
+
+    name = "gemini"
+
+    def collect(
+        self,
+        sources: list[tuple[str, Path]],
+        project_mappings: list[tuple[str, str]] | None = None,
+    ) -> Snapshot:
+        del project_mappings  # Gemini stores only a one-way project hash.
+        selected: dict[str, _Candidate] = {}
+        duplicates = malformed = 0
+        for machine, home in sources:
+            temporary = home / "tmp"
+            if not temporary.is_dir():
+                raise ValueError(f"Missing Gemini CLI temporary directory: {temporary}")
+            paths = sorted(temporary.glob("*/chats/session-*.json"))
+            paths.extend(sorted(temporary.glob("*/chats/session-*.jsonl")))
+            for path in paths:
+                metadata, _, invalid, event_count, digest = _read_session(path)
+                malformed += invalid
+                external_id = _label(metadata.get("sessionId"), 512)
+                if external_id is None:
+                    malformed += 1
+                    continue
+                candidate = _Candidate(
+                    machine=machine,
+                    path=path,
+                    external_id=external_id,
+                    event_count=event_count,
+                    digest=digest,
+                )
+                previous = selected.get(external_id)
+                if previous is None:
+                    selected[external_id] = candidate
+                    continue
+                duplicates += 1
+                if _rank(candidate) > _rank(previous):
+                    selected[external_id] = candidate
+
+        snapshot = Snapshot(
+            provider=self.name,
+            duplicate_conversations=duplicates,
+            malformed_records=malformed,
+        )
+        for candidate in sorted(selected.values(), key=lambda item: item.external_id):
+            metadata, messages, _, _, _ = _read_session(candidate.path)
+            self._normalize(snapshot, candidate, metadata, messages)
+        return snapshot
+
+    def _normalize(
+        self,
+        snapshot: Snapshot,
+        source: _Candidate,
+        metadata: dict[str, Any],
+        messages: list[dict[str, Any]],
+    ) -> None:
+        conversation_id = f"gemini:{source.external_id}"
+        turns: dict[str, dict[str, Any]] = {}
+        turn_models: dict[str, set[str]] = {}
+        active: str | None = None
+        calls: list[tuple[str | None, datetime | None, str, dict[str, int]]] = []
+        tools: list[tuple[str | None, datetime | None, str]] = []
+        timestamps = [
+            timestamp
+            for value in (metadata.get("startTime"), metadata.get("lastUpdated"))
+            if (timestamp := _timestamp(value)) is not None
+        ]
+
+        for message in messages:
+            timestamp = _timestamp(message.get("timestamp"))
+            if timestamp is not None:
+                timestamps.append(timestamp)
+            message_type = message.get("type")
+            if message_type == "user":
+                if active is not None:
+                    _finish_turn(turns[active], timestamp)
+                external_id = _label(message.get("id"), 512) or (
+                    f"turn-{len(turns) + 1}"
+                )
+                if external_id in turns:
+                    external_id = f"turn-{len(turns) + 1}"
+                active = 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_type in {"error", "warning"} and active is not None:
+                turns[active]["status"] = "aborted"
+                turns[active]["ended_at"] = _iso(timestamp)
+                continue
+            if message_type != "gemini":
+                continue
+
+            model = _label(message.get("model"), 255) or "unknown"
+            tokens = _usage(message.get("tokens"))
+            calls.append((active, timestamp, model, tokens))
+            if active is not None:
+                turns[active]["status"] = "completed"
+                turns[active]["ended_at"] = _iso(timestamp)
+
+            tool_calls = message.get("toolCalls")
+            if not isinstance(tool_calls, list):
+                continue
+            for tool_call in tool_calls:
+                if not isinstance(tool_call, dict):
+                    continue
+                name = _label(tool_call.get("name"), 512)
+                if name:
+                    tools.append(
+                        (
+                            active,
+                            _timestamp(tool_call.get("timestamp")) or timestamp,
+                            name,
+                        )
+                    )
+
+        ended_at = max(timestamps, default=None)
+        if active is not None:
+            _finish_turn(turns[active], ended_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 "")
+            if turn:
+                turn["model_calls"] += 1
+                turn_models[turn_key or ""].add(model)
+                _add_tokens(turn, tokens)
+            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 key, turn in turns.items():
+            snapshot.turns.append(turn)
+            observed_models = 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_models))
+                    if len(observed_models) == 1
+                    else None,
+                    "effort": None,
+                    "collaboration_mode": None,
+                    "service_tier": None,
+                    "context_window_tokens": None,
+                }
+            )
+
+        started_at = min(timestamps, default=None)
+        snapshot.conversations.append(
+            {
+                "id": conversation_id,
+                "provider": self.name,
+                "external_id": source.external_id,
+                "source_machine": source.machine,
+                "project": "outside-project",
+                "project_source": "none",
+                "started_at": _iso(started_at),
+                "ended_at": _iso(ended_at),
+                "duration_seconds": (
+                    (ended_at - started_at).total_seconds()
+                    if started_at and ended_at
+                    else None
+                ),
+                "source": "local-jsonl"
+                if source.path.suffix == ".jsonl"
+                else "local-json",
+                "models": sorted(models),
+                "iterations": len(turns),
+                "model_calls": len(calls),
+                "tool_calls": len(tools),
+                "compactions": 0,
+                "event_count": source.event_count,
+                "content_hash": source.digest,
+                **totals,
+            }
+        )
+
+
+def _read_session(
+    path: Path,
+) -> tuple[dict[str, Any], list[dict[str, Any]], int, int, str]:
+    digest_builder = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest_builder.update(chunk)
+    digest = digest_builder.hexdigest()
+    records: list[dict[str, Any]] = []
+    malformed = 0
+    if path.suffix == ".jsonl":
+        with path.open("rb") as handle:
+            for line in handle:
+                if not line.strip():
+                    continue
+                try:
+                    record = json.loads(line)
+                except (json.JSONDecodeError, UnicodeDecodeError):
+                    malformed += 1
+                    continue
+                if isinstance(record, dict):
+                    records.append(record)
+                else:
+                    malformed += 1
+    else:
+        try:
+            record = json.loads(path.read_bytes())
+        except (json.JSONDecodeError, UnicodeDecodeError):
+            return {}, [], 1, 0, digest
+        if not isinstance(record, dict):
+            return {}, [], 1, 0, digest
+        records.append(record)
+
+    metadata: dict[str, Any] = {}
+    messages: dict[str, dict[str, Any]] = {}
+    for record in records:
+        rewind_to = _label(record.get("$rewindTo"), 512)
+        if rewind_to is not None:
+            identifiers = list(messages)
+            try:
+                start = identifiers.index(rewind_to)
+            except ValueError:
+                messages.clear()
+            else:
+                for identifier in identifiers[start:]:
+                    del messages[identifier]
+            continue
+
+        updates = record.get("$set")
+        if isinstance(updates, dict):
+            checkpoint = updates.get("messages")
+            if isinstance(checkpoint, list):
+                messages.clear()
+                for message in checkpoint:
+                    if isinstance(message, dict) and (
+                        identifier := _label(message.get("id"), 512)
+                    ):
+                        messages[identifier] = message
+            metadata.update(
+                {key: value for key, value in updates.items() if key != "messages"}
+            )
+            continue
+
+        identifier = _label(record.get("id"), 512)
+        if identifier is not None:
+            messages[identifier] = record
+            continue
+
+        if isinstance(record.get("sessionId"), str):
+            metadata.update(
+                {key: value for key, value in record.items() if key != "messages"}
+            )
+            legacy_messages = record.get("messages")
+            if isinstance(legacy_messages, list):
+                for message in legacy_messages:
+                    if isinstance(message, dict) and (
+                        identifier := _label(message.get("id"), 512)
+                    ):
+                        messages[identifier] = message
+    return metadata, list(messages.values()), malformed, len(records), digest
+
+
+def _usage(value: object) -> dict[str, int]:
+    usage = value if isinstance(value, dict) else {}
+    input_tokens = _counter(usage.get("input"))
+    cached = min(input_tokens, _counter(usage.get("cached")))
+    visible = _counter(usage.get("output"))
+    reasoning = _counter(usage.get("thoughts"))
+    output_tokens = _sum(visible, reasoning)
+    attributed = _sum(input_tokens, output_tokens)
+    total = max(attributed, _counter(usage.get("total")))
+    return {
+        "input_tokens": input_tokens,
+        "cached_input_tokens": cached,
+        "cache_write_input_tokens": 0,
+        "output_tokens": output_tokens,
+        "reasoning_output_tokens": reasoning,
+        "total_tokens": total,
+        "uncached_input_tokens": input_tokens - cached,
+        "visible_output_tokens": visible,
+        "unattributed_tokens": max(0, total - attributed),
+    }
+
+
+def _rank(value: _Candidate) -> tuple[int, str]:
+    return value.event_count, value.digest
+
+
+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 _timestamp(value: object) -> datetime | None:
+    if not isinstance(value, str) or not value:
+        return None
+    try:
+        return datetime.fromisoformat(value.replace("Z", "+00:00")).astimezone(UTC)
+    except ValueError:
+        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.6 → cli_consumption-0.0.7}/src/cli_consumption/cli.py

@@ -11,6 +11,7 @@ from cli_consumption import __version__
 from cli_consumption.adapters import (
     ClaudeAdapter,
     CodexAdapter,
+    GeminiAdapter,
     KiloAdapter,
     OpenCodeAdapter,
     PiAdapter,
@@ -54,6 +55,7 @@ def providers() -> None:
     """Show implemented and planned CLI adapters."""
     typer.echo("all      auto-detect supported providers")
     typer.echo("codex    supported")
+    typer.echo("gemini   supported")
     typer.echo("claude   supported")
     typer.echo("kilo     supported")
     typer.echo("opencode supported")
@@ -230,6 +232,7 @@ def _collect_snapshots(
     provider = "claude" if provider == "claude-code" else provider
     adapters = {
         "codex": (CodexAdapter, ".codex", "sessions"),
+        "gemini": (GeminiAdapter, ".gemini", "tmp"),
         "claude": (ClaudeAdapter, ".claude", "projects"),
         "kilo": (KiloAdapter, ".local/share/kilo", "kilo.db"),
         "opencode": (

{cli_consumption-0.0.6 → cli_consumption-0.0.7}/tests/test_cli.py

@@ -23,6 +23,7 @@ def test_provider_status_is_explicit() -> None:
     assert result.exit_code == 0
     assert "all      auto-detect" in result.stdout
     assert "codex    supported" in result.stdout
+    assert "gemini   supported" in result.stdout
     assert "claude   supported" in result.stdout
     assert "kilo     supported" in result.stdout
     assert "opencode supported" in result.stdout
@@ -198,6 +199,34 @@ def test_collects_pi(tmp_path: Path) -> None:
     assert "1 written" in result.stdout
 
 
+def test_collects_gemini_cli(tmp_path: Path) -> None:
+    home = tmp_path / "gemini"
+    path = home / "tmp" / "project" / "chats" / "session-main.jsonl"
+    path.parent.mkdir(parents=True)
+    path.write_text(
+        '{"sessionId":"session","projectHash":"hash",'
+        '"startTime":"2026-08-25T10:00:00Z"}\n'
+        '{"id":"prompt","type":"user",'
+        '"timestamp":"2026-08-25T10:00:01Z","content":"synthetic"}\n'
+    )
+    result = runner.invoke(
+        app,
+        [
+            "collect",
+            "--provider",
+            "gemini",
+            "--source",
+            f"desktop={home}",
+            "--database",
+            str(tmp_path / "gemini.sqlite"),
+        ],
+    )
+
+    assert result.exit_code == 0, result.output
+    assert "Ingestion gemini" 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.7/tests/test_gemini_adapter.py

@@ -0,0 +1,275 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from cli_consumption.adapters.gemini import GeminiAdapter
+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 = "gemini privacy canary secret"
+
+
+def session(home: Path, *, extra: bool = False) -> Path:
+    records: list[dict[str, Any]] = [
+        {
+            "sessionId": "session-1",
+            "projectHash": "private-project-hash",
+            "startTime": "2026-08-25T10:00:00Z",
+            "lastUpdated": "2026-08-25T10:00:30Z",
+        },
+        {
+            "id": "prompt-1",
+            "timestamp": "2026-08-25T10:00:01Z",
+            "type": "user",
+            "content": CANARY,
+        },
+        {
+            "id": "response-1",
+            "timestamp": "2026-08-25T10:00:02Z",
+            "type": "gemini",
+            "content": CANARY,
+            "model": "gemini-2.5-pro",
+        },
+        {
+            "id": "response-1",
+            "timestamp": "2026-08-25T10:00:02Z",
+            "type": "gemini",
+            "content": CANARY,
+            "thoughts": [{"subject": CANARY, "description": CANARY}],
+            "model": "gemini-2.5-pro",
+            "tokens": {
+                "input": 100,
+                "output": 20,
+                "cached": 40,
+                "thoughts": 5,
+                "tool": 10,
+                "total": 130,
+            },
+            "toolCalls": [
+                {
+                    "id": "tool-1",
+                    "name": "run_shell_command",
+                    "args": {"command": CANARY},
+                    "result": CANARY,
+                    "description": CANARY,
+                    "status": "success",
+                    "timestamp": "2026-08-25T10:00:03Z",
+                }
+            ],
+        },
+        {
+            "$set": {
+                "lastUpdated": "2026-08-25T10:00:20Z",
+                "summary": CANARY,
+                "directories": [f"/private/{CANARY}"],
+                "memoryScratchpad": {"workflowSummary": CANARY},
+            }
+        },
+        {
+            "id": "prompt-2",
+            "timestamp": "2026-08-25T10:00:10Z",
+            "type": "user",
+            "content": CANARY,
+        },
+        {
+            "id": "response-2",
+            "timestamp": "2026-08-25T10:00:11Z",
+            "type": "gemini",
+            "content": CANARY,
+            "model": "gemini-2.5-flash",
+            "tokens": {
+                "input": 20,
+                "output": 4,
+                "cached": 30,
+                "thoughts": 2,
+                "total": 27,
+            },
+        },
+        {
+            "id": "discarded-prompt",
+            "timestamp": "2026-08-25T10:00:12Z",
+            "type": "user",
+            "content": CANARY,
+        },
+        {
+            "id": "discarded-error",
+            "timestamp": "2026-08-25T10:00:13Z",
+            "type": "error",
+            "content": CANARY,
+        },
+        {"$rewindTo": "discarded-prompt"},
+        {
+            "id": "prompt-3",
+            "timestamp": "2026-08-25T10:00:14Z",
+            "type": "user",
+            "content": CANARY,
+        },
+        {
+            "id": "response-3",
+            "timestamp": "2026-08-25T10:00:15Z",
+            "type": "gemini",
+            "content": CANARY,
+            "model": "gemini-2.5-flash",
+            "tokens": {"input": 3, "output": 1, "total": 4},
+        },
+    ]
+    if extra:
+        records.append({"$set": {"lastUpdated": "2026-08-25T10:00:30Z"}})
+    path = home / "tmp" / "project-hash" / "chats" / "session-main.jsonl"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        "".join(json.dumps(record) + "\n" for record in records), encoding="utf-8"
+    )
+    return path
+
+
+def test_collects_current_usage_tools_turns_and_rewinds(tmp_path: Path) -> None:
+    home = tmp_path / "gemini"
+    session(home)
+    snapshot = GeminiAdapter().collect(
+        [("laptop", home)], [("must-not-map", "/private")]
+    )
+
+    conversation = snapshot.conversations[0]
+    assert conversation["id"] == "gemini:session-1"
+    assert conversation["project"] == "outside-project"
+    assert conversation["models"] == ["gemini-2.5-flash", "gemini-2.5-pro"]
+    assert conversation["model_calls"] == 3
+    assert conversation["tool_calls"] == 1
+    assert conversation["input_tokens"] == 123
+    assert conversation["uncached_input_tokens"] == 63
+    assert conversation["cached_input_tokens"] == 60
+    assert conversation["output_tokens"] == 32
+    assert conversation["reasoning_output_tokens"] == 7
+    assert conversation["visible_output_tokens"] == 25
+    assert conversation["total_tokens"] == 161
+    assert conversation["unattributed_tokens"] == 6
+    assert [turn["status"] for turn in snapshot.turns] == [
+        "completed",
+        "completed",
+        "completed",
+    ]
+    assert snapshot.tool_calls[0]["tool_name"] == "run_shell_command"
+    assert snapshot.tool_calls[0]["turn_id"] == "gemini:session-1:prompt-1"
+    assert CANARY not in str(snapshot.to_dict())
+    assert "private-project-hash" not in str(snapshot.to_dict())
+
+
+def test_supports_legacy_json_and_current_checkpoints(tmp_path: Path) -> None:
+    home = tmp_path / "gemini"
+    path = home / "tmp" / "project" / "chats" / "session-legacy.json"
+    path.parent.mkdir(parents=True)
+    path.write_text(
+        json.dumps(
+            {
+                "sessionId": "legacy-session",
+                "startTime": "2026-08-25T10:00:00Z",
+                "lastUpdated": "2026-08-25T10:00:01Z",
+                "messages": [
+                    {
+                        "id": "prompt",
+                        "timestamp": "2026-08-25T10:00:00Z",
+                        "type": "user",
+                        "content": CANARY,
+                    },
+                    {
+                        "id": "response",
+                        "timestamp": "2026-08-25T10:00:01Z",
+                        "type": "gemini",
+                        "content": CANARY,
+                        "model": "gemini-1.5-pro",
+                        "tokens": {"input": 2, "output": 1, "total": 3},
+                    },
+                ],
+            }
+        ),
+        encoding="utf-8",
+    )
+    snapshot = GeminiAdapter().collect([("machine", home)])
+    assert snapshot.conversations[0]["source"] == "local-json"
+    assert snapshot.conversations[0]["total_tokens"] == 3
+    assert CANARY not in str(snapshot.to_dict())
+
+    path.unlink()
+    current = home / "tmp" / "project" / "chats" / "session-checkpoint.jsonl"
+    messages = [
+        {
+            "id": "prompt",
+            "timestamp": "2026-08-25T10:00:00Z",
+            "type": "user",
+            "content": CANARY,
+        }
+    ]
+    current.write_text(
+        json.dumps({"sessionId": "checkpoint-session", "projectHash": "hash"})
+        + "\n"
+        + json.dumps({"$set": {"messages": messages}})
+        + "\n",
+        encoding="utf-8",
+    )
+    snapshot = GeminiAdapter().collect([("machine", home)])
+    assert len(snapshot.turns) == 1
+    assert snapshot.turns[0]["external_id"] == "prompt"
+
+
+def test_deduplicates_copies_and_rejects_malformed_fields(tmp_path: Path) -> None:
+    first, second = tmp_path / "first", tmp_path / "second"
+    session(first)
+    path = session(second, extra=True)
+    with path.open("a", encoding="utf-8") as handle:
+        handle.write("not-json\n[]\n")
+        handle.write(
+            '{"id":"bad","type":"gemini","model":"'
+            + CANARY
+            + '","tokens":{"input":Infinity,"output":-1},'
+            + '"toolCalls":[{"name":"'
+            + CANARY
+            + '","args":{"secret":"'
+            + CANARY
+            + '"}}]}\n'
+        )
+    snapshot = GeminiAdapter().collect([("desktop", first), ("laptop", second)])
+
+    assert snapshot.duplicate_conversations == 1
+    assert snapshot.malformed_records == 2
+    assert snapshot.conversations[0]["source_machine"] == "laptop"
+    assert snapshot.model_calls[-1]["model"] == "unknown"
+    assert snapshot.model_calls[-1]["total_tokens"] == 0
+    assert len(snapshot.tool_calls) == 1
+    assert CANARY not in str(snapshot.to_dict())
+    assert (
+        snapshot.to_dict()
+        == GeminiAdapter().collect([("desktop", first), ("laptop", second)]).to_dict()
+    )
+
+    with pytest.raises(ValueError, match="Missing Gemini CLI temporary directory"):
+        GeminiAdapter().collect([("machine", tmp_path / "missing")])
+
+
+def test_privacy_canary_is_absent_from_storage_and_exports(tmp_path: Path) -> None:
+    home = tmp_path / "gemini"
+    session(home)
+    snapshot = GeminiAdapter().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.6 → cli_consumption-0.0.7}/uv.lock

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