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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cli-consumption
-Version: 0.0.4
+Version: 0.0.5
 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, OpenCode, and the core Claude Code local transcript format are supported. Kilo
-Code and Pi are planned behind the same provider-neutral adapter contract.
+Codex, Pi, OpenCode, and the core Claude Code local transcript format are supported.
+Kilo Code is 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.
@@ -108,6 +108,12 @@ Select OpenCode to read `~/.local/share/opencode/opencode.db` instead:
 uv run cli-consumption collect --provider opencode --database usage.sqlite
 ```
 
+Select Pi to read `~/.pi/agent/sessions/` instead:
+
+```bash
+uv run cli-consumption collect --provider pi --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 opencode \
   --source laptop=/data/opencode/laptop
 ```
 
+Copied Pi sources point to the agent directory containing `sessions/`:
+
+```bash
+uv run cli-consumption collect --provider pi \
+  --source desktop=/data/pi/desktop \
+  --source laptop=/data/pi/laptop
+```
+
 ## SQLite and PostgreSQL
 
 A file path selects SQLite. A SQLAlchemy URL selects PostgreSQL:

{cli_consumption-0.0.4 → cli_consumption-0.0.5}/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, OpenCode, and the core Claude Code local transcript format are supported. Kilo
-Code and Pi are planned behind the same provider-neutral adapter contract.
+Codex, Pi, OpenCode, and the core Claude Code local transcript format are supported.
+Kilo Code is 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.
@@ -80,6 +80,12 @@ Select OpenCode to read `~/.local/share/opencode/opencode.db` instead:
 uv run cli-consumption collect --provider opencode --database usage.sqlite
 ```
 
+Select Pi to read `~/.pi/agent/sessions/` instead:
+
+```bash
+uv run cli-consumption collect --provider pi --database usage.sqlite
+```
+
 Use `all` to detect and collect every supported provider present on the machine:
 
 ```bash
@@ -128,6 +134,14 @@ uv run cli-consumption collect --provider opencode \
   --source laptop=/data/opencode/laptop
 ```
 
+Copied Pi sources point to the agent directory containing `sessions/`:
+
+```bash
+uv run cli-consumption collect --provider pi \
+  --source desktop=/data/pi/desktop \
+  --source laptop=/data/pi/laptop
+```
+
 ## SQLite and PostgreSQL
 
 A file path selects SQLite. A SQLAlchemy URL selects PostgreSQL:

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

@@ -5,8 +5,8 @@
 | Codex | Supported | Local rollout JSONL and optional metadata-only subagent state |
 | Claude Code | Supported (core) | Local project transcript JSONL |
 | OpenCode | Supported (core) | Local SQLite v2 session store |
+| Pi | Supported (core) | Local session JSONL v1-v3 |
 | Kilo Code | Planned | To be verified before implementation |
-| Pi | Planned | To be verified before implementation |
 
 “Supported” means the adapter has synthetic fixtures, extracts conversations, turns,
 models, token usage, and tool names when available, and passes privacy regression tests.
@@ -49,6 +49,21 @@ components. The adapter does not currently read pre-v2 JSON storage, legacy
 provider-reported cost. The SQLite schema is internal and may change without notice;
 local token events are not billing data.
 
+Pi reads session JSONL files under `~/.pi/agent/sessions/` (or copied agent
+directories). It extracts user turns, assistant and compaction model calls, provider
+and model identifiers, token usage, tool names, thinking-level changes, and compaction
+timestamps while discarding prompts, responses, thinking, tool arguments/results,
+commands/output, summaries, errors, costs, paths, extension data, and arbitrary
+metadata. All persisted branches are counted because Pi retains branch history in the
+same session file.
+
+Pi reports uncached input, cache reads, cache writes, output, and optional reasoning
+tokens. Normalized input includes all three input components; reasoning is retained as
+a subset of output rather than added twice. This adapter does not collect custom
+session directories automatically, context-window sizes, costs, branch relationships,
+or provider-reported durations. Pi's JSONL schema can change without notice, and its
+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.4 → cli_consumption-0.0.5}/docs/roadmap.md

@@ -4,6 +4,7 @@
 
 - Complete Codex local collector
 - Core Claude Code local transcript collector
+- Core Pi local session collector
 - Offline multi-machine deduplication
 - SQLite and PostgreSQL storage
 - Metadata-only central collection API
@@ -14,7 +15,7 @@
 
 1. Extend Claude Code support only where local metadata has reliable semantics.
 2. Add OpenCode with the same normalized contract.
-3. Add Kilo Code and Pi after format and licensing review.
+3. Add Kilo Code after format and licensing review.
 4. Add cross-provider comparison views once at least two adapters expose reliable model
    and token dimensions.
 

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

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

{cli_consumption-0.0.4 → cli_consumption-0.0.5}/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.opencode import OpenCodeAdapter
+from cli_consumption.adapters.pi import PiAdapter
 
-__all__ = ["ClaudeAdapter", "CodexAdapter", "OpenCodeAdapter"]
+__all__ = ["ClaudeAdapter", "CodexAdapter", "OpenCodeAdapter", "PiAdapter"]

cli_consumption-0.0.5/src/cli_consumption/adapters/pi.py

@@ -0,0 +1,454 @@
+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_.:/+-]*")
+THINKING_LEVELS = {"off", "minimal", "low", "medium", "high", "xhigh", "max"}
+
+
+@dataclass(slots=True)
+class _Session:
+    machine: str
+    external_id: str
+    cwd: str | None
+    entries: list[dict[str, Any]]
+    event_count: int
+    digest: str
+
+
+class PiAdapter:
+    """Read Pi session metadata while discarding conversation content."""
+
+    name = "pi"
+
+    def collect(
+        self,
+        sources: list[tuple[str, Path]],
+        project_mappings: list[tuple[str, str]] | None = None,
+    ) -> Snapshot:
+        selected: dict[str, _Session] = {}
+        duplicates = malformed = 0
+        for machine, home in sources:
+            sessions = home / "sessions"
+            if not sessions.is_dir():
+                raise ValueError(f"Missing Pi sessions directory: {sessions}")
+            for path in sorted(sessions.rglob("*.jsonl")):
+                candidate, invalid = _read_session(path, machine)
+                malformed += invalid
+                if candidate is None:
+                    continue
+                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 session in sorted(selected.values(), key=lambda value: value.external_id):
+            self._normalize(snapshot, session, project_mappings or [])
+        return snapshot
+
+    def _normalize(
+        self,
+        snapshot: Snapshot,
+        source: _Session,
+        mappings: list[tuple[str, str]],
+    ) -> None:
+        conversation_id = f"pi:{source.external_id}"
+        entry_by_id = {
+            identifier: entry
+            for entry in source.entries
+            if (identifier := _label(entry.get("id"), 512)) is not None
+        }
+        turns: dict[str, dict[str, Any]] = {}
+        turn_models: dict[str, set[str]] = {}
+        turn_efforts: dict[str, str | None] = {}
+        active: 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: list[datetime | None] = []
+
+        for entry in source.entries:
+            timestamp = _timestamp(entry.get("timestamp"))
+            timestamps.append(timestamp)
+            message = _mapping(entry.get("message"))
+            role = message.get("role") if entry.get("type") == "message" else None
+
+            if role == "user":
+                if active is not None:
+                    _finish_turn(turns[active], timestamp)
+                external_id = _label(entry.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[external_id] = {
+                    "id": f"{conversation_id}:{external_id}",
+                    "conversation_id": conversation_id,
+                    "external_id": external_id,
+                    "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[external_id] = set()
+                turn_efforts[external_id] = _ancestral_effort(entry, entry_by_id)
+                continue
+
+            turn_key = _ancestral_turn(entry, entry_by_id) or active
+            if entry.get("type") == "compaction":
+                compactions.append((turn_key, timestamp))
+
+            if role == "assistant":
+                model = (
+                    _model(message) or _ancestral_model(entry, entry_by_id) or "unknown"
+                )
+                tokens = _usage(message.get("usage"))
+                calls.append((turn_key, timestamp, model, tokens))
+                turn = turns.get(turn_key or "")
+                if turn:
+                    turn["ended_at"] = _iso(timestamp) or turn["ended_at"]
+                    stop_reason = message.get("stopReason")
+                    if stop_reason in {"error", "aborted"}:
+                        turn["status"] = "aborted"
+                    elif stop_reason in {"stop", "length"}:
+                        turn["status"] = "completed"
+
+                content = message.get("content")
+                if isinstance(content, list):
+                    for block in content:
+                        if (
+                            not isinstance(block, dict)
+                            or block.get("type") != "toolCall"
+                        ):
+                            continue
+                        name = _label(block.get("name"), 512)
+                        if name:
+                            tools.append((turn_key, timestamp, name))
+
+            if entry.get("type") in {"compaction", "branch_summary"} and isinstance(
+                entry.get("usage"), dict
+            ):
+                calls.append(
+                    (
+                        turn_key,
+                        timestamp,
+                        _ancestral_model(entry, entry_by_id) or "unknown",
+                        _usage(entry.get("usage")),
+                    )
+                )
+
+        ended_at = max(
+            (value for value in timestamps if value is not None), default=None
+        )
+        for turn in turns.values():
+            _finish_turn(turn, 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 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": turn_efforts[key],
+                    "collaboration_mode": None,
+                    "service_tier": None,
+                    "context_window_tokens": None,
+                }
+            )
+
+        started_at = min(
+            (value for value in timestamps if value is not None), default=None
+        )
+        project, project_source = _project(source.cwd, 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": (
+                    (ended_at - started_at).total_seconds()
+                    if started_at and ended_at
+                    else None
+                ),
+                "source": "local-jsonl",
+                "models": sorted(models),
+                "iterations": len(turns),
+                "model_calls": len(calls),
+                "tool_calls": len(tools),
+                "compactions": len(compactions),
+                "event_count": source.event_count,
+                "content_hash": source.digest,
+                **totals,
+            }
+        )
+
+
+def _read_session(path: Path, machine: str) -> tuple[_Session | None, int]:
+    digest = hashlib.sha256()
+    entries: list[dict[str, Any]] = []
+    malformed = 0
+    with path.open("rb") as handle:
+        for line in handle:
+            digest.update(line)
+            try:
+                entry = json.loads(line)
+            except (json.JSONDecodeError, UnicodeDecodeError):
+                malformed += 1
+                continue
+            if not isinstance(entry, dict):
+                malformed += 1
+                continue
+            entries.append(entry)
+
+    header = next((entry for entry in entries if entry.get("type") == "session"), None)
+    if header is None or (external_id := _label(header.get("id"), 512)) is None:
+        return None, malformed + 1
+    return (
+        _Session(
+            machine=machine,
+            external_id=external_id,
+            cwd=header.get("cwd") if isinstance(header.get("cwd"), str) else None,
+            entries=entries,
+            event_count=len(entries),
+            digest=digest.hexdigest(),
+        ),
+        malformed,
+    )
+
+
+def _rank(value: _Session) -> tuple[int, str]:
+    return value.event_count, value.digest
+
+
+def _ancestral_turn(
+    entry: dict[str, Any], entry_by_id: dict[str, dict[str, Any]]
+) -> str | None:
+    for ancestor in _ancestors(entry, entry_by_id):
+        message = _mapping(ancestor.get("message"))
+        if ancestor.get("type") == "message" and message.get("role") == "user":
+            return _label(ancestor.get("id"), 512)
+    return None
+
+
+def _ancestral_model(
+    entry: dict[str, Any], entry_by_id: dict[str, dict[str, Any]]
+) -> str | None:
+    for ancestor in _ancestors(entry, entry_by_id):
+        if ancestor.get("type") == "model_change":
+            return _model_change(ancestor)
+        message = _mapping(ancestor.get("message"))
+        if (
+            ancestor.get("type") == "message"
+            and message.get("role") == "assistant"
+            and (model := _model(message))
+        ):
+            return model
+    return None
+
+
+def _ancestral_effort(
+    entry: dict[str, Any], entry_by_id: dict[str, dict[str, Any]]
+) -> str | None:
+    for ancestor in _ancestors(entry, entry_by_id):
+        if ancestor.get("type") == "thinking_level_change":
+            value = ancestor.get("thinkingLevel")
+            return value if value in THINKING_LEVELS else None
+    return None
+
+
+def _ancestors(
+    entry: dict[str, Any], entry_by_id: dict[str, dict[str, Any]]
+) -> list[dict[str, Any]]:
+    result: list[dict[str, Any]] = []
+    seen: set[str] = set()
+    parent_id = _label(entry.get("parentId"), 512)
+    while parent_id and parent_id not in seen:
+        seen.add(parent_id)
+        parent = entry_by_id.get(parent_id)
+        if parent is None:
+            break
+        result.append(parent)
+        parent_id = _label(parent.get("parentId"), 512)
+    return result
+
+
+def _usage(value: object) -> dict[str, int]:
+    usage = _mapping(value)
+    uncached = _counter(usage.get("input"))
+    cached = _counter(usage.get("cacheRead"))
+    cache_write = _counter(usage.get("cacheWrite"))
+    output = _counter(usage.get("output"))
+    reasoning = min(output, _counter(usage.get("reasoning")))
+    input_tokens = _sum(uncached, cached, cache_write)
+    attributed = _sum(input_tokens, output)
+    total = max(attributed, _counter(usage.get("totalTokens")))
+    return {
+        "input_tokens": input_tokens,
+        "cached_input_tokens": cached,
+        "cache_write_input_tokens": cache_write,
+        "output_tokens": output,
+        "reasoning_output_tokens": reasoning,
+        "total_tokens": total,
+        "uncached_input_tokens": uncached,
+        "visible_output_tokens": output - reasoning,
+        "unattributed_tokens": max(0, total - attributed),
+    }
+
+
+def _model(message: dict[str, Any]) -> str | None:
+    provider = _label(message.get("provider"), 127)
+    identifier = _label(message.get("model"), 127)
+    if provider and identifier:
+        return f"{provider}/{identifier}"
+    return identifier
+
+
+def _model_change(entry: dict[str, Any]) -> str | None:
+    provider = _label(entry.get("provider"), 127)
+    identifier = _label(entry.get("modelId"), 127)
+    if provider and identifier:
+        return f"{provider}/{identifier}"
+    return identifier
+
+
+def _project(cwd: str | None, mappings: list[tuple[str, str]]) -> tuple[str, str]:
+    if cwd:
+        normalized = cwd.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.4 → cli_consumption-0.0.5}/src/cli_consumption/cli.py

@@ -8,7 +8,12 @@ from typing import Annotated
 import typer
 
 from cli_consumption import __version__
-from cli_consumption.adapters import ClaudeAdapter, CodexAdapter, OpenCodeAdapter
+from cli_consumption.adapters import (
+    ClaudeAdapter,
+    CodexAdapter,
+    OpenCodeAdapter,
+    PiAdapter,
+)
 from cli_consumption.api import create_app
 from cli_consumption.dashboard import generate_dashboard
 from cli_consumption.exporting import export_csv
@@ -50,7 +55,8 @@ def providers() -> None:
     typer.echo("codex    supported")
     typer.echo("claude   supported")
     typer.echo("opencode supported")
-    for provider in ("kilo", "pi"):
+    typer.echo("pi       supported")
+    for provider in ("kilo",):
         typer.echo(f"{provider:<8} planned")
 
 
@@ -230,6 +236,7 @@ def _collect_snapshots(
             ".local/share/opencode",
             "opencode.db",
         ),
+        "pi": (PiAdapter, ".pi/agent", "sessions"),
     }
     if provider != "all" and provider not in adapters:
         raise typer.BadParameter(

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

@@ -25,6 +25,7 @@ def test_provider_status_is_explicit() -> None:
     assert "codex    supported" in result.stdout
     assert "claude   supported" in result.stdout
     assert "opencode supported" in result.stdout
+    assert "pi       supported" in result.stdout
 
 
 def test_version_and_unsupported_provider_are_explicit(tmp_path: Path) -> None:
@@ -113,6 +114,35 @@ def test_collects_opencode(tmp_path: Path) -> None:
     assert "1 written" in result.stdout
 
 
+def test_collects_pi(tmp_path: Path) -> None:
+    home = tmp_path / "pi"
+    path = home / "sessions" / "--project--" / "session.jsonl"
+    path.parent.mkdir(parents=True)
+    path.write_text(
+        '{"type":"session","version":3,"id":"session-cli",'
+        '"timestamp":"2026-08-25T10:00:00Z","cwd":"/project"}\n'
+        '{"type":"message","id":"prompt","parentId":null,'
+        '"timestamp":"2026-08-25T10:00:01Z",'
+        '"message":{"role":"user","content":"synthetic"}}\n'
+    )
+    result = runner.invoke(
+        app,
+        [
+            "collect",
+            "--provider",
+            "pi",
+            "--source",
+            f"desktop={home}",
+            "--database",
+            str(tmp_path / "pi.sqlite"),
+        ],
+    )
+
+    assert result.exit_code == 0, result.output
+    assert "Ingestion pi" 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.5/tests/test_pi_adapter.py

@@ -0,0 +1,287 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from cli_consumption.adapters.pi import PiAdapter
+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 session(home: Path, *, extra: bool = False) -> Path:
+    entries: list[dict[str, Any]] = [
+        {
+            "type": "session",
+            "version": 3,
+            "id": "session-1",
+            "timestamp": "2026-08-25T10:00:00Z",
+            "cwd": "/srv/work/acme/service",
+            "parentSession": CANARY,
+        },
+        {
+            "type": "thinking_level_change",
+            "id": "thinking-1",
+            "parentId": None,
+            "timestamp": "2026-08-25T10:00:00.500Z",
+            "thinkingLevel": "high",
+        },
+        {
+            "type": "message",
+            "id": "prompt-1",
+            "parentId": "thinking-1",
+            "timestamp": "2026-08-25T10:00:01Z",
+            "message": {"role": "user", "content": CANARY},
+        },
+        {
+            "type": "message",
+            "id": "assistant-1",
+            "parentId": "prompt-1",
+            "timestamp": "2026-08-25T10:00:02Z",
+            "message": {
+                "role": "assistant",
+                "provider": "anthropic",
+                "model": "claude-sonnet-4-6",
+                "content": [
+                    {"type": "text", "text": CANARY},
+                    {
+                        "type": "toolCall",
+                        "id": "tool-1",
+                        "name": "bash",
+                        "arguments": {"command": CANARY},
+                    },
+                ],
+                "usage": {
+                    "input": 100,
+                    "cacheRead": 40,
+                    "cacheWrite": 10,
+                    "output": 20,
+                    "reasoning": 5,
+                    "totalTokens": 170,
+                    "cost": {"total": 1, "secret": CANARY},
+                },
+                "stopReason": "toolUse",
+                "errorMessage": CANARY,
+            },
+        },
+        {
+            "type": "message",
+            "id": "result-1",
+            "parentId": "assistant-1",
+            "timestamp": "2026-08-25T10:00:03Z",
+            "message": {
+                "role": "toolResult",
+                "toolCallId": "tool-1",
+                "toolName": "bash",
+                "content": [{"type": "text", "text": CANARY}],
+                "details": {"output": CANARY},
+                "isError": False,
+            },
+        },
+        {
+            "type": "message",
+            "id": "assistant-2",
+            "parentId": "result-1",
+            "timestamp": "2026-08-25T10:00:04Z",
+            "message": {
+                "role": "assistant",
+                "provider": "anthropic",
+                "model": "claude-sonnet-4-6",
+                "content": [{"type": "text", "text": CANARY}],
+                "usage": {
+                    "input": 5,
+                    "cacheRead": 100,
+                    "cacheWrite": 0,
+                    "output": 10,
+                    "totalTokens": 115,
+                },
+                "stopReason": "stop",
+            },
+        },
+        {
+            "type": "compaction",
+            "id": "compaction-1",
+            "parentId": "assistant-2",
+            "timestamp": "2026-08-25T10:00:05Z",
+            "summary": CANARY,
+            "tokensBefore": 50000,
+            "details": {"readFiles": [CANARY]},
+            "usage": {
+                "input": 10,
+                "cacheRead": 0,
+                "cacheWrite": 0,
+                "output": 2,
+                "totalTokens": 12,
+            },
+        },
+        {
+            "type": "model_change",
+            "id": "model-1",
+            "parentId": "compaction-1",
+            "timestamp": "2026-08-25T10:00:06Z",
+            "provider": "openai",
+            "modelId": "gpt-5",
+        },
+        {
+            "type": "message",
+            "id": "prompt-2",
+            "parentId": "model-1",
+            "timestamp": "2026-08-25T10:00:10Z",
+            "message": {"role": "user", "content": CANARY},
+        },
+        {
+            "type": "message",
+            "id": "assistant-3",
+            "parentId": "prompt-2",
+            "timestamp": "2026-08-25T10:00:11Z",
+            "message": {
+                "role": "assistant",
+                "provider": "openai",
+                "model": "gpt-5",
+                "content": [{"type": "thinking", "thinking": CANARY}],
+                "usage": {
+                    "input": 2,
+                    "cacheRead": 0,
+                    "cacheWrite": 0,
+                    "output": 1,
+                    "reasoning": 1,
+                    "totalTokens": 3,
+                },
+                "stopReason": "error",
+                "errorMessage": CANARY,
+            },
+        },
+        {
+            "type": "message",
+            "id": "prompt-branch",
+            "parentId": "prompt-1",
+            "timestamp": "2026-08-25T10:00:12Z",
+            "message": {"role": "user", "content": CANARY},
+        },
+        {
+            "type": "message",
+            "id": "assistant-branch",
+            "parentId": "prompt-branch",
+            "timestamp": "2026-08-25T10:00:13Z",
+            "message": {
+                "role": "assistant",
+                "provider": "google",
+                "model": "gemini-2.5-pro",
+                "content": [{"type": "text", "text": CANARY}],
+                "usage": {
+                    "input": 1,
+                    "cacheRead": 0,
+                    "cacheWrite": 0,
+                    "output": 1,
+                    "totalTokens": 2,
+                },
+                "stopReason": "stop",
+            },
+        },
+    ]
+    if extra:
+        entries.append(
+            {
+                "type": "custom",
+                "id": "custom-1",
+                "parentId": "assistant-branch",
+                "timestamp": "2026-08-25T10:00:14Z",
+                "customType": "fixture",
+                "data": {"secret": CANARY},
+            }
+        )
+    path = home / "sessions" / "--srv-work-acme-service--" / "session.jsonl"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        "".join(json.dumps(entry) + "\n" for entry in entries), encoding="utf-8"
+    )
+    return path
+
+
+def test_collects_usage_tools_branches_settings_and_compactions(tmp_path: Path) -> None:
+    home = tmp_path / "pi"
+    session(home)
+
+    snapshot = PiAdapter().collect([("laptop", home)], [("acme", "/srv/work/acme")])
+
+    conversation = snapshot.conversations[0]
+    assert conversation["id"] == "pi:session-1"
+    assert conversation["project"] == "acme"
+    assert conversation["models"] == [
+        "anthropic/claude-sonnet-4-6",
+        "google/gemini-2.5-pro",
+        "openai/gpt-5",
+    ]
+    assert conversation["model_calls"] == 5
+    assert conversation["tool_calls"] == 1
+    assert conversation["input_tokens"] == 268
+    assert conversation["uncached_input_tokens"] == 118
+    assert conversation["cached_input_tokens"] == 140
+    assert conversation["cache_write_input_tokens"] == 10
+    assert conversation["output_tokens"] == 34
+    assert conversation["reasoning_output_tokens"] == 6
+    assert conversation["visible_output_tokens"] == 28
+    assert conversation["total_tokens"] == 302
+    assert [turn["status"] for turn in snapshot.turns] == [
+        "completed",
+        "aborted",
+        "completed",
+    ]
+    assert snapshot.tool_calls[0]["tool_name"] == "bash"
+    assert snapshot.tool_calls[0]["turn_id"] == "pi:session-1:prompt-1"
+    assert snapshot.compaction_events[0]["turn_id"] == "pi:session-1:prompt-1"
+    assert {setting["effort"] for setting in snapshot.turn_settings} == {"high"}
+    assert CANARY not in str(snapshot.to_dict())
+
+
+def test_deduplicates_copies_and_handles_malformed_sessions(tmp_path: Path) -> None:
+    first, second = tmp_path / "first", tmp_path / "second"
+    path = session(first)
+    session(second, extra=True)
+    with path.open("a", encoding="utf-8") as handle:
+        handle.write("not-json\n[]\n")
+    invalid = first / "sessions" / "invalid.jsonl"
+    invalid.write_text(json.dumps({"type": "message", "content": CANARY}) + "\n")
+
+    snapshot = PiAdapter().collect([("desktop", first), ("laptop", second)])
+
+    assert snapshot.duplicate_conversations == 1
+    assert snapshot.malformed_records == 3
+    assert snapshot.conversations[0]["source_machine"] == "laptop"
+    assert snapshot.conversations[0]["event_count"] == 13
+    assert (
+        snapshot.to_dict()
+        == PiAdapter().collect([("desktop", first), ("laptop", second)]).to_dict()
+    )
+
+    with pytest.raises(ValueError, match="Missing Pi sessions directory"):
+        PiAdapter().collect([("machine", tmp_path / "missing")])
+
+
+def test_privacy_canary_is_absent_from_storage_and_exports(tmp_path: Path) -> None:
+    home = tmp_path / "pi"
+    session(home, extra=True)
+    snapshot = PiAdapter().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.4 → cli_consumption-0.0.5}/uv.lock

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