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

{cli_consumption-0.0.7 → cli_consumption-0.0.8}/.agents/skills/yolo/SKILL.md

@@ -10,9 +10,11 @@ Run each phase in order from the repository root. The implicit pull request is t
 ## 1. Publish
 
 1. Read all repository instructions and the product specification referenced by `AGENTS.md`.
-2. Load and follow `$yeet-github` in full to inspect, validate, commit, push, and open a draft pull request, except do not request its approval before pushing or publishing: the explicit `$yolo` invocation already provides that approval.
-3. Retain the exact source and target branches, pushed SHA, pull-request number, and URL.
-4. Stop after any failure or ambiguous external result. Never merge or clean up after a partial failure.
+2. Read `.agents/local-environment.md` when present and follow its GitHub authentication instructions.
+3. Load and follow `$yeet-github` in full to inspect, validate, commit, push, and open a draft pull request, except do not request its approval before pushing or publishing: the explicit `$yolo` invocation already provides that approval.
+4. Use `gh` directly for GitHub API and pull-request operations. When Git transport is unavoidable and the remote is HTTPS, authenticate it explicitly through the current `gh` session, for example `git -c credential.helper='!gh auth git-credential' push -u origin <source-branch>`; never rely on ambient HTTPS Git credentials.
+5. Retain the exact source and target branches, pushed SHA, pull-request number, and URL.
+6. Stop after any failure or ambiguous external result. Never merge or clean up after a partial failure.
 
 ## 2. Merge
 
@@ -29,10 +31,10 @@ Run each phase in order from the repository root. The implicit pull request is t
 
 1. Reconfirm the merged state and capture the merge commit SHA.
 2. Refuse cleanup if new tracked, staged, or untracked work appeared after the source commit.
-3. Run `git fetch --prune origin`.
+3. Fetch with the authentication method required by `.agents/local-environment.md`; for an HTTPS GitHub remote, use `git -c credential.helper='!gh auth git-credential' fetch --prune origin`.
 4. Switch to the target branch and update it only by fast-forward with `git switch <target-branch>` and `git pull --ff-only origin <target-branch>`.
 5. Delete the exact local source branch if it remains. `git branch -D <source-branch>` is allowed only after verified squash merge.
-6. If the exact unprotected remote source branch remains, delete it with `git push origin --delete <source-branch>` without requesting additional approval.
+6. If the exact unprotected remote source branch remains, delete it without requesting additional approval. For an HTTPS GitHub remote, use `git -c credential.helper='!gh auth git-credential' push origin --delete <source-branch>`.
 7. Run `git status --short --branch` and report the final state.
 
 ## Guardrails

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cli-consumption
-Version: 0.0.7
+Version: 0.0.8
 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, Gemini CLI, Kilo Code, Pi, OpenCode, and the core Claude Code local transcript
-format are supported.
+Codex, Aider, 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.
@@ -126,6 +126,14 @@ Select Gemini CLI to read `~/.gemini/tmp/*/chats/` instead:
 uv run cli-consumption collect --provider gemini --database usage.sqlite
 ```
 
+Select Aider to read a local analytics log configured at
+`~/.aider/analytics.jsonl` instead:
+
+```bash
+export AIDER_ANALYTICS_LOG="$HOME/.aider/analytics.jsonl"
+uv run cli-consumption collect --provider aider --database usage.sqlite
+```
+
 Use `all` to detect and collect every supported provider present on the machine:
 
 ```bash
@@ -198,6 +206,14 @@ uv run cli-consumption collect --provider gemini \
   --source laptop=/data/gemini/laptop
 ```
 
+Copied Aider sources point to a directory containing `analytics.jsonl`:
+
+```bash
+uv run cli-consumption collect --provider aider \
+  --source desktop=/data/aider/desktop \
+  --source laptop=/data/aider/laptop
+```
+
 ## SQLite and PostgreSQL
 
 A file path selects SQLite. A SQLAlchemy URL selects PostgreSQL:

{cli_consumption-0.0.7 → cli_consumption-0.0.8}/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, Gemini CLI, Kilo Code, Pi, OpenCode, and the core Claude Code local transcript
-format are supported.
+Codex, Aider, 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.
@@ -98,6 +98,14 @@ Select Gemini CLI to read `~/.gemini/tmp/*/chats/` instead:
 uv run cli-consumption collect --provider gemini --database usage.sqlite
 ```
 
+Select Aider to read a local analytics log configured at
+`~/.aider/analytics.jsonl` instead:
+
+```bash
+export AIDER_ANALYTICS_LOG="$HOME/.aider/analytics.jsonl"
+uv run cli-consumption collect --provider aider --database usage.sqlite
+```
+
 Use `all` to detect and collect every supported provider present on the machine:
 
 ```bash
@@ -170,6 +178,14 @@ uv run cli-consumption collect --provider gemini \
   --source laptop=/data/gemini/laptop
 ```
 
+Copied Aider sources point to a directory containing `analytics.jsonl`:
+
+```bash
+uv run cli-consumption collect --provider aider \
+  --source desktop=/data/aider/desktop \
+  --source laptop=/data/aider/laptop
+```
+
 ## SQLite and PostgreSQL
 
 A file path selects SQLite. A SQLAlchemy URL selects PostgreSQL:

{cli_consumption-0.0.7 → cli_consumption-0.0.8}/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,
-  Gemini CLI, Kilo Code, OpenCode, and Pi expose the core dimensions available in
+  work-item intervals. Codex exposes the complete analytics contract; Aider, Claude
+  Code, 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

{cli_consumption-0.0.7 → cli_consumption-0.0.8}/docs/provider-support.md

@@ -2,6 +2,7 @@
 
 | Provider | Status | Initial source |
 | --- | --- | --- |
+| Aider | Supported (core) | Opt-in local analytics JSONL |
 | 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 |
@@ -98,6 +99,22 @@ session directories automatically, context-window sizes, costs, branch relations
 or provider-reported durations. Pi's JSONL schema can change without notice, and its
 local token events are not billing data.
 
+Aider reads an explicitly configured local analytics log named `analytics.jsonl` (for
+example, `AIDER_ANALYTICS_LOG=~/.aider/analytics.jsonl`). It groups events from
+`launched` through `exit`, extracts message-send attempts, model identifiers, and
+prompt/completion/total token counters, and discards the analytics user UUID, costs,
+exception text, command events, edit formats, system properties, and arbitrary event
+properties. Conversation identifiers are stable hashes of the transient UUID and
+launch time; the UUID itself is never emitted.
+
+Aider analytics do not expose prompts or responses, but logging is not enabled at a
+fixed location by default. The adapter cannot attribute projects, tool calls, cached
+or reasoning tokens, compactions, context windows, or provider-reported durations.
+Turns represent Aider message-send attempts because the log has no durable user-turn
+identifier. Unknown custom model names may already be represented as
+`provider/REDACTED` by Aider. Its analytics event schema can change without notice,
+and 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.7 → cli_consumption-0.0.8}/pyproject.toml

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

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

@@ -1,3 +1,4 @@
+from cli_consumption.adapters.aider import AiderAdapter
 from cli_consumption.adapters.claude import ClaudeAdapter
 from cli_consumption.adapters.codex import CodexAdapter
 from cli_consumption.adapters.gemini import GeminiAdapter
@@ -6,6 +7,7 @@ from cli_consumption.adapters.opencode import OpenCodeAdapter
 from cli_consumption.adapters.pi import PiAdapter
 
 __all__ = [
+    "AiderAdapter",
     "ClaudeAdapter",
     "CodexAdapter",
     "GeminiAdapter",

cli_consumption-0.0.8/src/cli_consumption/adapters/aider.py

@@ -0,0 +1,347 @@
+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
+    external_id: str
+    events: list[dict[str, Any]]
+    digest: str
+
+
+class AiderAdapter:
+    """Read Aider analytics logs while discarding arbitrary event properties."""
+
+    name = "aider"
+
+    def collect(
+        self,
+        sources: list[tuple[str, Path]],
+        project_mappings: list[tuple[str, str]] | None = None,
+    ) -> Snapshot:
+        del project_mappings  # Aider analytics do not record a project path.
+        selected: dict[str, _Candidate] = {}
+        duplicates = malformed = 0
+        for machine, home in sources:
+            path = home / "analytics.jsonl"
+            if not path.is_file():
+                raise ValueError(f"Missing Aider analytics log: {path}")
+            sessions, invalid = _read_sessions(path)
+            malformed += invalid
+            for external_id, events, digest in sessions:
+                candidate = _Candidate(machine, external_id, events, 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):
+            self._normalize(snapshot, candidate)
+        return snapshot
+
+    def _normalize(self, snapshot: Snapshot, source: _Candidate) -> None:
+        conversation_id = f"aider:{source.external_id}"
+        timestamps = [
+            timestamp
+            for event in source.events
+            if (timestamp := _timestamp(event.get("time"))) is not None
+        ]
+        turns: list[dict[str, Any]] = []
+        turn_models: list[set[str]] = []
+        active: int | None = None
+        calls: list[tuple[int | None, datetime | None, str, dict[str, int]]] = []
+
+        for event in source.events:
+            name = event.get("event")
+            timestamp = _timestamp(event.get("time"))
+            if name == "message_send_starting":
+                if active is not None:
+                    _finish_turn(turns[active], timestamp, "aborted")
+                active = len(turns)
+                turns.append(_new_turn(conversation_id, active + 1, timestamp))
+                turn_models.append(set())
+                continue
+            if name == "message_send_exception":
+                if active is not None:
+                    _finish_turn(turns[active], timestamp, "aborted")
+                    active = None
+                continue
+            if name == "exit":
+                if active is not None:
+                    _finish_turn(turns[active], timestamp, "aborted")
+                    active = None
+                continue
+            if name != "message_send":
+                continue
+
+            properties = event.get("properties")
+            properties = properties if isinstance(properties, dict) else {}
+            model = _label(properties.get("main_model"), 255) or "unknown"
+            tokens = _usage(properties)
+            calls.append((active, timestamp, model, tokens))
+            if active is not None:
+                _finish_turn(turns[active], timestamp, "completed")
+                turn_models[active].add(model)
+                active = None
+
+        ended_at = max(timestamps, default=None)
+        if active is not None:
+            _finish_turn(turns[active], ended_at, "in-progress")
+
+        totals = empty_tokens()
+        models: set[str] = set()
+        for sequence, (turn_index, timestamp, model, tokens) in enumerate(calls, 1):
+            models.add(model)
+            _add_tokens(totals, tokens)
+            turn = turns[turn_index] if turn_index is not None else None
+            if turn is not None:
+                turn["model_calls"] += 1
+                _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 index, turn in enumerate(turns):
+            snapshot.turns.append(turn)
+            observed_models = turn_models[index]
+            snapshot.turn_settings.append(
+                {
+                    "id": f"{conversation_id}:settings:{index + 1}",
+                    "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-analytics-jsonl",
+                "models": sorted(models),
+                "iterations": len(turns),
+                "model_calls": len(calls),
+                "tool_calls": 0,
+                "compactions": 0,
+                "event_count": len(source.events),
+                "content_hash": source.digest,
+                **totals,
+            }
+        )
+
+
+def _read_sessions(
+    path: Path,
+) -> tuple[list[tuple[str, list[dict[str, Any]], str]], int]:
+    sessions: list[tuple[str, list[dict[str, Any]], str]] = []
+    active: list[dict[str, Any]] | None = None
+    malformed = 0
+    ordinals: dict[tuple[str, int], int] = {}
+    with path.open("rb") as handle:
+        for line in handle:
+            if not line.strip():
+                continue
+            try:
+                event = json.loads(line)
+            except (json.JSONDecodeError, UnicodeDecodeError):
+                malformed += 1
+                continue
+            if not isinstance(event, dict) or not isinstance(event.get("event"), str):
+                malformed += 1
+                continue
+            if _epoch(event.get("time")) is None:
+                malformed += 1
+                continue
+            if event["event"] == "launched":
+                if active:
+                    sessions.append(_session(active, ordinals))
+                active = [event]
+                continue
+            if active is None:
+                continue
+            active.append(event)
+            if event["event"] == "exit":
+                sessions.append(_session(active, ordinals))
+                active = None
+    if active:
+        sessions.append(_session(active, ordinals))
+    return sessions, malformed
+
+
+def _session(
+    events: list[dict[str, Any]], ordinals: dict[tuple[str, int], int]
+) -> tuple[str, list[dict[str, Any]], str]:
+    launched = events[0]
+    user_id = launched.get("user_id")
+    user_id = user_id if isinstance(user_id, str) else "anonymous"
+    started = _epoch(launched.get("time")) or 0
+    key = (user_id, started)
+    ordinal = ordinals.get(key, 0) + 1
+    ordinals[key] = ordinal
+    stable = hashlib.sha256(f"{user_id}\0{started}\0{ordinal}".encode()).hexdigest()[
+        :32
+    ]
+    approved = [
+        {
+            "event": event.get("event"),
+            "time": _epoch(event.get("time")),
+            "properties": _approved_properties(event),
+        }
+        for event in events
+    ]
+    digest = hashlib.sha256(
+        json.dumps(approved, sort_keys=True, separators=(",", ":")).encode()
+    ).hexdigest()
+    return stable, events, digest
+
+
+def _approved_properties(event: dict[str, Any]) -> dict[str, Any]:
+    if event.get("event") != "message_send":
+        return {}
+    properties = event.get("properties")
+    if not isinstance(properties, dict):
+        return {}
+    return {
+        key: properties.get(key)
+        for key in ("main_model", "prompt_tokens", "completion_tokens", "total_tokens")
+    }
+
+
+def _new_turn(
+    conversation_id: str, sequence: int, timestamp: datetime | None
+) -> dict[str, Any]:
+    return {
+        "id": f"{conversation_id}:turn:{sequence}",
+        "conversation_id": conversation_id,
+        "external_id": f"turn-{sequence}",
+        "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(),
+    }
+
+
+def _finish_turn(turn: dict[str, Any], timestamp: datetime | None, status: str) -> None:
+    turn["ended_at"] = _iso(timestamp)
+    turn["status"] = status
+
+
+def _usage(properties: dict[str, Any]) -> dict[str, int]:
+    input_tokens = _counter(properties.get("prompt_tokens"))
+    output_tokens = _counter(properties.get("completion_tokens"))
+    attributed = _sum(input_tokens, output_tokens)
+    total = max(attributed, _counter(properties.get("total_tokens")))
+    return {
+        "input_tokens": input_tokens,
+        "uncached_input_tokens": input_tokens,
+        "cached_input_tokens": 0,
+        "cache_write_input_tokens": 0,
+        "output_tokens": output_tokens,
+        "reasoning_output_tokens": 0,
+        "visible_output_tokens": output_tokens,
+        "total_tokens": total,
+        "unattributed_tokens": total - attributed,
+    }
+
+
+def _counter(value: object) -> int:
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return 0
+    if not math.isfinite(value) or value < 0 or value > MAX_BIGINT:
+        return 0
+    return int(value)
+
+
+def _sum(*values: int) -> int:
+    return min(MAX_BIGINT, sum(values))
+
+
+def _add_tokens(target: dict[str, Any], values: dict[str, int]) -> None:
+    for key, value in values.items():
+        target[key] = _sum(int(target[key]), value)
+
+
+def _epoch(value: object) -> int | None:
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return None
+    if not math.isfinite(value) or value < 0 or value > 253_402_300_799:
+        return None
+    return int(value)
+
+
+def _timestamp(value: object) -> datetime | None:
+    epoch = _epoch(value)
+    return datetime.fromtimestamp(epoch, tz=UTC) if epoch is not None else None
+
+
+def _iso(value: datetime | None) -> str | None:
+    return value.isoformat().replace("+00:00", "Z") if value else None
+
+
+def _label(value: object, limit: int) -> str | None:
+    if (
+        not isinstance(value, str)
+        or len(value) > limit
+        or not SAFE_LABEL.fullmatch(value)
+    ):
+        return None
+    return value
+
+
+def _rank(candidate: _Candidate) -> tuple[int, int, str, str]:
+    ended = max(
+        (_epoch(event.get("time")) or 0 for event in candidate.events), default=0
+    )
+    return len(candidate.events), ended, candidate.digest, candidate.machine

{cli_consumption-0.0.7 → cli_consumption-0.0.8}/src/cli_consumption/cli.py

@@ -9,6 +9,7 @@ import typer
 
 from cli_consumption import __version__
 from cli_consumption.adapters import (
+    AiderAdapter,
     ClaudeAdapter,
     CodexAdapter,
     GeminiAdapter,
@@ -54,6 +55,7 @@ def main(
 def providers() -> None:
     """Show implemented and planned CLI adapters."""
     typer.echo("all      auto-detect supported providers")
+    typer.echo("aider    supported")
     typer.echo("codex    supported")
     typer.echo("gemini   supported")
     typer.echo("claude   supported")
@@ -231,6 +233,7 @@ def _collect_snapshots(
 ) -> list[Snapshot]:
     provider = "claude" if provider == "claude-code" else provider
     adapters = {
+        "aider": (AiderAdapter, ".aider", "analytics.jsonl"),
         "codex": (CodexAdapter, ".codex", "sessions"),
         "gemini": (GeminiAdapter, ".gemini", "tmp"),
         "claude": (ClaudeAdapter, ".claude", "projects"),

cli_consumption-0.0.8/tests/test_aider_adapter.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from cli_consumption.adapters.aider import AiderAdapter
+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,
+)
+from cli_consumption.sync import send_snapshot
+
+CANARY = "aider privacy canary secret"
+USER_ID = "11111111-2222-4333-8444-555555555555"
+
+
+def analytics(home: Path, *, complete: bool = True) -> Path:
+    events: list[dict[str, Any]] = [
+        {
+            "event": "launched",
+            "properties": {"system_prompt": CANARY},
+            "user_id": USER_ID,
+            "time": 1_777_300_000,
+        },
+        {
+            "event": "repo",
+            "properties": {"path": f"/private/{CANARY}", "num_files": 42},
+            "user_id": USER_ID,
+            "time": 1_777_300_001,
+        },
+        {
+            "event": "message_send_starting",
+            "properties": {"prompt": CANARY},
+            "user_id": USER_ID,
+            "time": 1_777_300_002,
+        },
+        {
+            "event": "message_send",
+            "properties": {
+                "main_model": "anthropic/claude-sonnet-4-6",
+                "weak_model": CANARY,
+                "editor_model": CANARY,
+                "edit_format": "diff",
+                "prompt_tokens": 100,
+                "completion_tokens": 20,
+                "total_tokens": 125,
+                "cost": 1.25,
+                "total_cost": 2.5,
+                "secret": CANARY,
+            },
+            "user_id": USER_ID,
+            "time": 1_777_300_004,
+        },
+        {
+            "event": "command_run",
+            "properties": {"command": CANARY, "output": CANARY},
+            "user_id": USER_ID,
+            "time": 1_777_300_005,
+        },
+        {
+            "event": "message_send_starting",
+            "properties": {},
+            "user_id": USER_ID,
+            "time": 1_777_300_006,
+        },
+        {
+            "event": "message_send_exception",
+            "properties": {"exception": CANARY, "traceback": CANARY},
+            "user_id": USER_ID,
+            "time": 1_777_300_007,
+        },
+    ]
+    if complete:
+        events.append(
+            {
+                "event": "exit",
+                "properties": {"reason": CANARY},
+                "user_id": USER_ID,
+                "time": 1_777_300_010,
+            }
+        )
+    path = home / "analytics.jsonl"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        "".join(json.dumps(event) + "\n" for event in events), encoding="utf-8"
+    )
+    return path
+
+
+def test_collects_sessions_models_tokens_and_attempts(tmp_path: Path) -> None:
+    home = tmp_path / "aider"
+    analytics(home)
+
+    snapshot = AiderAdapter().collect(
+        [("laptop", home)], [("must-not-map", "/private")]
+    )
+
+    conversation = snapshot.conversations[0]
+    assert conversation["id"].startswith("aider:")
+    assert USER_ID not in conversation["id"]
+    assert conversation["project"] == "outside-project"
+    assert conversation["models"] == ["anthropic/claude-sonnet-4-6"]
+    assert conversation["model_calls"] == 1
+    assert conversation["tool_calls"] == 0
+    assert conversation["input_tokens"] == 100
+    assert conversation["uncached_input_tokens"] == 100
+    assert conversation["output_tokens"] == 20
+    assert conversation["visible_output_tokens"] == 20
+    assert conversation["total_tokens"] == 125
+    assert conversation["unattributed_tokens"] == 5
+    assert [turn["status"] for turn in snapshot.turns] == ["completed", "aborted"]
+    assert all(turn["duration_ms"] is None for turn in snapshot.turns)
+    assert snapshot.model_calls[0]["turn_id"] == snapshot.turns[0]["id"]
+    assert CANARY not in str(snapshot.to_dict())
+    assert USER_ID not in str(snapshot.to_dict())
+
+
+def test_deduplicates_copies_and_handles_malformed_events(tmp_path: Path) -> None:
+    first, second = tmp_path / "first", tmp_path / "second"
+    analytics(first, complete=False)
+    path = analytics(second)
+    with path.open("a", encoding="utf-8") as handle:
+        handle.write("not-json\n[]\n")
+        handle.write('{"event":"bad","time":-1,"properties":{"secret":"')
+        handle.write(CANARY + '"}}\n')
+
+    snapshot = AiderAdapter().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"] == 8
+    assert CANARY not in str(snapshot.to_dict())
+    assert (
+        snapshot.to_dict()
+        == AiderAdapter().collect([("desktop", first), ("laptop", second)]).to_dict()
+    )
+
+    with pytest.raises(ValueError, match="Missing Aider analytics log"):
+        AiderAdapter().collect([("machine", tmp_path / "missing")])
+
+
+def test_privacy_canary_is_absent_from_surfaces(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    home = tmp_path / "aider"
+    analytics(home)
+    snapshot = AiderAdapter().collect([("machine", home)])
+    observed: dict[str, Any] = {}
+
+    class Response:
+        def raise_for_status(self) -> None:
+            pass
+
+        def json(self) -> dict[str, int | str]:
+            return {"run_id": "run-1", "written": 1, "skipped": 0}
+
+    def fake_post(url: str, **kwargs: Any) -> Response:
+        observed.update(url=url, **kwargs)
+        return Response()
+
+    monkeypatch.setattr("cli_consumption.sync.httpx.post", fake_post)
+    send_snapshot(snapshot, "https://collector.test")
+    assert CANARY not in json.dumps(observed["json"])
+    assert USER_ID not in json.dumps(observed["json"])
+
+    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)
+        assert USER_ID 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 all(USER_ID not in path.read_text() for path in paths)
+        assert CANARY not in dashboard.read_text()
+        assert USER_ID not in dashboard.read_text()
+    finally:
+        engine.dispose()

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

@@ -22,6 +22,7 @@ def test_provider_status_is_explicit() -> None:
     result = runner.invoke(app, ["providers"])
     assert result.exit_code == 0
     assert "all      auto-detect" in result.stdout
+    assert "aider    supported" in result.stdout
     assert "codex    supported" in result.stdout
     assert "gemini   supported" in result.stdout
     assert "claude   supported" in result.stdout
@@ -97,6 +98,34 @@ def test_collects_kilo_code(tmp_path: Path) -> None:
     assert "1 written" in result.stdout
 
 
+def test_collects_aider(tmp_path: Path) -> None:
+    home = tmp_path / "aider"
+    home.mkdir()
+    (home / "analytics.jsonl").write_text(
+        '{"event":"launched","properties":{},"user_id":"synthetic",'
+        '"time":1777300000}\n'
+        '{"event":"exit","properties":{},"user_id":"synthetic",'
+        '"time":1777300001}\n'
+    )
+
+    result = runner.invoke(
+        app,
+        [
+            "collect",
+            "--provider",
+            "aider",
+            "--source",
+            f"desktop={home}",
+            "--database",
+            str(tmp_path / "aider.sqlite"),
+        ],
+    )
+
+    assert result.exit_code == 0, result.output
+    assert "Ingestion aider" in result.stdout
+    assert "1 written" in result.stdout
+
+
 def test_collects_claude_code(tmp_path: Path) -> None:
     home = tmp_path / "claude"
     path = home / "projects" / "project" / "session.jsonl"

{cli_consumption-0.0.7 → cli_consumption-0.0.8}/uv.lock

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