cc-transcript 4.0.0__tar.gz → 5.0.0__tar.gz

{cc_transcript-4.0.0 → cc_transcript-5.0.0}/Cargo.lock

@@ -66,7 +66,7 @@ dependencies = [
 
 [[package]]
 name = "cc_transcript_parser"
-version = "0.6.0"
+version = "0.7.0"
 dependencies = [
  "chrono",
  "crossbeam-channel",

{cc_transcript-4.0.0 → cc_transcript-5.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-transcript
-Version: 4.0.0
+Version: 5.0.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -16,7 +16,7 @@ Requires-Dist: orjson>=3.10
 Requires-Dist: pytest>=8.0 ; extra == 'dev'
 Requires-Dist: ty>=0.0.44 ; extra == 'dev'
 Requires-Dist: ruff>=0.8 ; extra == 'dev'
-Requires-Dist: spawnllm>=0.2.0 ; extra == 'llm'
+Requires-Dist: spawnllm>=0.4.0 ; extra == 'llm'
 Requires-Dist: spacy>=3.8 ; extra == 'sentiment'
 Requires-Dist: afinn>=0.1 ; extra == 'sentiment'
 Provides-Extra: dev

{cc_transcript-4.0.0 → cc_transcript-5.0.0}/cc_transcript/__init__.py

@@ -57,19 +57,28 @@ EXPORTS: dict[str, str] = {
         ),
         "cc_transcript.models": (
             "AssistantEvent",
+            "CacheCreation",
             "CcVersion",
             "ContentBlock",
             "EntryMeta",
             "FallbackBlock",
+            "InitInfo",
+            "McpServer",
             "ModeEvent",
+            "ModelUsage",
             "OtherBlock",
             "OtherEvent",
+            "Plugin",
+            "PrintMessage",
+            "PrintResult",
+            "ServerToolUse",
             "SystemEvent",
             "TextBlock",
             "ThinkingBlock",
             "ToolResultBlock",
             "ToolUseBlock",
             "TranscriptEvent",
+            "Usage",
             "UserEvent",
         ),
         "cc_transcript.parser": (
@@ -77,6 +86,15 @@ EXPORTS: dict[str, str] = {
             "parse_event",
             "parse_events_async",
             "parse_events_from_bytes",
+            "parse_print_result",
+        ),
+        "cc_transcript.cost": (
+            "PRICING",
+            "CostBreakdown",
+            "ModelPricing",
+            "cost_of",
+            "cost_of_assistant",
+            "resolve_pricing",
         ),
         "cc_transcript.backend": ("Backend", "ParsedTranscript"),
         "cc_transcript.discovery": (
@@ -271,6 +289,24 @@ if TYPE_CHECKING:
     from cc_transcript.corrections import (
         Origin as Origin,
     )
+    from cc_transcript.cost import (
+        PRICING as PRICING,
+    )
+    from cc_transcript.cost import (
+        CostBreakdown as CostBreakdown,
+    )
+    from cc_transcript.cost import (
+        ModelPricing as ModelPricing,
+    )
+    from cc_transcript.cost import (
+        cost_of as cost_of,
+    )
+    from cc_transcript.cost import (
+        cost_of_assistant as cost_of_assistant,
+    )
+    from cc_transcript.cost import (
+        resolve_pricing as resolve_pricing,
+    )
     from cc_transcript.decisions import (
         DECISIONS_DDL as DECISIONS_DDL,
     )
@@ -415,6 +451,9 @@ if TYPE_CHECKING:
     from cc_transcript.models import (
         AssistantEvent as AssistantEvent,
     )
+    from cc_transcript.models import (
+        CacheCreation as CacheCreation,
+    )
     from cc_transcript.models import (
         CcVersion as CcVersion,
     )
@@ -427,15 +466,36 @@ if TYPE_CHECKING:
     from cc_transcript.models import (
         FallbackBlock as FallbackBlock,
     )
+    from cc_transcript.models import (
+        InitInfo as InitInfo,
+    )
+    from cc_transcript.models import (
+        McpServer as McpServer,
+    )
     from cc_transcript.models import (
         ModeEvent as ModeEvent,
     )
+    from cc_transcript.models import (
+        ModelUsage as ModelUsage,
+    )
     from cc_transcript.models import (
         OtherBlock as OtherBlock,
     )
     from cc_transcript.models import (
         OtherEvent as OtherEvent,
     )
+    from cc_transcript.models import (
+        Plugin as Plugin,
+    )
+    from cc_transcript.models import (
+        PrintMessage as PrintMessage,
+    )
+    from cc_transcript.models import (
+        PrintResult as PrintResult,
+    )
+    from cc_transcript.models import (
+        ServerToolUse as ServerToolUse,
+    )
     from cc_transcript.models import (
         SystemEvent as SystemEvent,
     )
@@ -454,6 +514,9 @@ if TYPE_CHECKING:
     from cc_transcript.models import (
         TranscriptEvent as TranscriptEvent,
     )
+    from cc_transcript.models import (
+        Usage as Usage,
+    )
     from cc_transcript.models import (
         UserEvent as UserEvent,
     )
@@ -469,6 +532,9 @@ if TYPE_CHECKING:
     from cc_transcript.parser import (
         parse_events_from_bytes as parse_events_from_bytes,
     )
+    from cc_transcript.parser import (
+        parse_print_result as parse_print_result,
+    )
     from cc_transcript.query import (
         FileRef as FileRef,
     )

{cc_transcript-4.0.0 → cc_transcript-5.0.0}/cc_transcript/__main__.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from cc_transcript.cli import cli
 
 cli()

{cc_transcript-4.0.0 → cc_transcript-5.0.0}/cc_transcript/_parser_rs.pyi

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from cc_transcript.models import TranscriptEvent
+from cc_transcript.models import PrintResult, TranscriptEvent
 
 class ParseStream:
     """A streaming handle over a rayon-parsed batch of transcript files."""
@@ -18,6 +18,9 @@ def stream_parse(paths: list[tuple[str, float]], prefetch: int, spec_json: str |
     are dropped during parsing, before any Python object is built.
     """
 
+def parse_print_result(raw: bytes, /) -> PrintResult:
+    """Parses a 'claude -p --output-format json' result from raw JSON bytes."""
+
 def lexicon_available() -> bool:
     """Whether the UDPipe English model loaded (downloading + caching on first call)."""
 

{cc_transcript-4.0.0 → cc_transcript-5.0.0}/cc_transcript/corrections_cli.py

@@ -11,7 +11,6 @@ from __future__ import annotations
 import json
 import time
 from dataclasses import asdict
-from typing import cast
 
 import click
 import orjson
@@ -54,7 +53,7 @@ def add(
     anchor: str,
     incorrect_file: str,
     ts_ms: int | None,
-    origin: str | None,
+    origin: Origin | None,
     incorrect_old: str,
     incorrect_new: str,
     incorrect_digest: str | None,
@@ -79,7 +78,7 @@ def add(
             incorrect_file=incorrect_file,
             incorrect_old=incorrect_old,
             incorrect_new=incorrect_new,
-            correction_origin=cast("Origin | None", origin),
+            correction_origin=origin,
             correction_file=correction_file,
             correction_old=correction_old,
             correction_new=correction_new,

cc_transcript-5.0.0/cc_transcript/cost.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+    from cc_transcript.models import AssistantEvent, Usage
+
+MTOK = 1_000_000
+
+
+@dataclass(frozen=True, slots=True)
+class ModelPricing:
+    """USD-per-million-token rates for a model family.
+
+    Standard service tier, standard (non-long-context) pricing — current Claude
+    4.x models serve their 1M context at standard rates with no long-context
+    premium. Override via the `pricing` argument to cost_of for other tiers.
+
+    Attributes:
+        input: USD per million uncached input tokens.
+        output: USD per million output tokens.
+        cache_read: USD per million tokens served from the cache.
+        cache_write_5m: USD per million tokens written to the 5-minute cache.
+        cache_write_1h: USD per million tokens written to the 1-hour cache.
+    """
+
+    input: float
+    output: float
+    cache_read: float
+    cache_write_5m: float
+    cache_write_1h: float
+
+
+@dataclass(frozen=True, slots=True)
+class CostBreakdown:
+    """The per-component and total USD cost of a single turn's token usage.
+
+    Attributes:
+        input_cost: USD cost of the uncached input tokens.
+        output_cost: USD cost of the output tokens.
+        cache_read_cost: USD cost of the cache-read tokens.
+        cache_write_cost: USD cost of the cache-creation tokens, summed across TTL buckets.
+        total: The sum of the four component costs.
+    """
+
+    input_cost: float
+    output_cost: float
+    cache_read_cost: float
+    cache_write_cost: float
+    total: float
+
+
+PRICING: Mapping[str, ModelPricing] = {
+    "fable": ModelPricing(input=10.0, output=50.0, cache_read=1.0, cache_write_5m=12.5, cache_write_1h=20.0),
+    "opus": ModelPricing(input=5.0, output=25.0, cache_read=0.5, cache_write_5m=6.25, cache_write_1h=10.0),
+    "sonnet": ModelPricing(input=3.0, output=15.0, cache_read=0.3, cache_write_5m=3.75, cache_write_1h=6.0),
+    "haiku": ModelPricing(input=1.0, output=5.0, cache_read=0.1, cache_write_5m=1.25, cache_write_1h=2.0),
+}
+
+
+def resolve_pricing(model: str, *, pricing: Mapping[str, ModelPricing] = PRICING) -> ModelPricing:
+    """Return the pricing row whose family key is a substring of `model`.
+
+    Family keys are mutually exclusive substrings, so at most one matches —
+    ``"claude-haiku-4-5-20251001"`` resolves to haiku, ``"claude-opus-4-8"`` to
+    opus, and a bare ``"sonnet"`` to sonnet.
+
+    Args:
+        model: The model id to resolve.
+        pricing: The family-keyed pricing table to search.
+
+    Raises:
+        KeyError: If no family key is a substring of `model`.
+
+    Example:
+        >>> resolve_pricing("claude-opus-4-8").input
+        5.0
+    """
+    for family, row in pricing.items():
+        if family in model:
+            return row
+    raise KeyError(f"no pricing for model: {model}")
+
+
+def cost_of(usage: Usage, model: str, *, pricing: Mapping[str, ModelPricing] = PRICING) -> CostBreakdown:
+    """Compute the USD cost of a turn's token usage under a model's rates.
+
+    The cache-creation split prefers the per-TTL ``usage.cache_creation`` when
+    present, falling back to the flat ``usage.cache_creation_input_tokens`` as
+    5-minute writes with no 1-hour share.
+
+    Args:
+        usage: The turn's token usage and cache accounting.
+        model: The model id whose rates apply.
+        pricing: The family-keyed pricing table to resolve against.
+
+    Returns:
+        The per-component and total cost.
+
+    Example:
+        >>> cost_of(usage, "claude-haiku-4-5-20251001").total
+        0.05759
+    """
+    row = resolve_pricing(model, pricing=pricing)
+    write_5m, write_1h = (
+        (usage.cache_creation.ephemeral_5m_input_tokens, usage.cache_creation.ephemeral_1h_input_tokens)
+        if usage.cache_creation is not None
+        else (usage.cache_creation_input_tokens, 0)
+    )
+    input_cost = usage.input_tokens / MTOK * row.input
+    output_cost = usage.output_tokens / MTOK * row.output
+    cache_read_cost = usage.cache_read_input_tokens / MTOK * row.cache_read
+    cache_write_cost = write_5m / MTOK * row.cache_write_5m + write_1h / MTOK * row.cache_write_1h
+    return CostBreakdown(
+        input_cost=input_cost,
+        output_cost=output_cost,
+        cache_read_cost=cache_read_cost,
+        cache_write_cost=cache_write_cost,
+        total=input_cost + output_cost + cache_read_cost + cache_write_cost,
+    )
+
+
+def cost_of_assistant(event: AssistantEvent, *, pricing: Mapping[str, ModelPricing] = PRICING) -> CostBreakdown | None:
+    """Compute the cost of an assistant turn, or None when it carries no usage.
+
+    Args:
+        event: The assistant turn whose usage is priced.
+        pricing: The family-keyed pricing table to resolve against.
+
+    Returns:
+        The cost breakdown, or None when ``event.usage`` is None.
+    """
+    if event.usage is None:
+        return None
+    return cost_of(event.usage, event.model, pricing=pricing)

{cc_transcript-4.0.0 → cc_transcript-5.0.0}/cc_transcript/decisions.py

@@ -1,6 +1,6 @@
 """The unified decision ledger shared by every hook and gate writer.
 
-One SQLite table (``decisions_v1``) records every allow/block/warn/nudge/note
+One SQLite table (``decisions``) records every allow/block/warn/nudge/note
 decision across the family. Python (:class:`DecisionLog`) and cc-review's Go
 daemon write the same file directly, so the DDL below is vendored
 byte-identical into the Go repo and byte-compared in CI. Attribution joins by
@@ -22,7 +22,7 @@ if TYPE_CHECKING:
     from cc_transcript.ids import EventUuid, SessionId, ToolDigest
 
 DECISIONS_DDL = """\
-CREATE TABLE IF NOT EXISTS decisions_v1 (
+CREATE TABLE IF NOT EXISTS decisions (
     id INTEGER PRIMARY KEY,
     ts_ms INTEGER NOT NULL,
     session_id TEXT NOT NULL,
@@ -39,11 +39,11 @@ CREATE TABLE IF NOT EXISTS decisions_v1 (
     UNIQUE (session_id, ts_ms, source, kind, tool_digest)
 );
 
-CREATE INDEX IF NOT EXISTS idx_decisions_v1_session_ts ON decisions_v1 (session_id, ts_ms);
+CREATE INDEX IF NOT EXISTS idx_decisions_session_ts ON decisions (session_id, ts_ms);
 
-CREATE INDEX IF NOT EXISTS idx_decisions_v1_tool_digest ON decisions_v1 (tool_digest);
+CREATE INDEX IF NOT EXISTS idx_decisions_tool_digest ON decisions (tool_digest);
 
-CREATE INDEX IF NOT EXISTS idx_decisions_v1_source_file ON decisions_v1 (source_file);
+CREATE INDEX IF NOT EXISTS idx_decisions_source_file ON decisions (source_file);
 """
 
 Action = Literal["allow", "block", "warn", "nudge", "note"]
@@ -92,7 +92,7 @@ class Decision:
 
 
 class DecisionLog:
-    """The ``decisions_v1`` ledger at ``~/.cc-transcript/decisions.db``.
+    """The ``decisions`` ledger at ``~/.cc-transcript/decisions.db``.
 
     Opened in WAL mode with a busy timeout because cc-review's Go daemon
     writes the same file concurrently. Durable by convention: rows are never
@@ -136,7 +136,7 @@ class DecisionLog:
         re-running the same integer-ms timestamp.
         """
         self.conn.execute(
-            f"INSERT OR IGNORE INTO decisions_v1 ({DECISION_COLUMNS}) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+            f"INSERT OR IGNORE INTO decisions ({DECISION_COLUMNS}) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
             (
                 decision.ts_ms,
                 decision.session_id,
@@ -158,7 +158,7 @@ class DecisionLog:
         return tuple(
             decision_of(row)
             for row in self.conn.execute(
-                "SELECT * FROM decisions_v1 WHERE session_id = ? ORDER BY ts_ms, id", (session_id,)
+                "SELECT * FROM decisions WHERE session_id = ? ORDER BY ts_ms, id", (session_id,)
             )
         )
 
@@ -177,7 +177,7 @@ class DecisionLog:
             ``[near_ts_ms - window_ms, near_ts_ms]``.
         """
         row = self.conn.execute(
-            "SELECT * FROM decisions_v1 WHERE session_id = ? AND tool_digest = ? AND ts_ms BETWEEN ? AND ?"
+            "SELECT * FROM decisions WHERE session_id = ? AND tool_digest = ? AND ts_ms BETWEEN ? AND ?"
             " ORDER BY ts_ms DESC, id DESC LIMIT 1",
             (session_id, tool_digest, near_ts_ms - window_ms, near_ts_ms),
         ).fetchone()
@@ -205,7 +205,7 @@ class DecisionLog:
         """
         kind_clause, kind_params = ("AND kind = ? ", (kind,)) if kind is not None else ("", ())
         row = self.conn.execute(
-            f"SELECT * FROM decisions_v1 WHERE session_id = ? AND event = ? {kind_clause}AND ts_ms BETWEEN ? AND ?"
+            f"SELECT * FROM decisions WHERE session_id = ? AND event = ? {kind_clause}AND ts_ms BETWEEN ? AND ?"
             " ORDER BY ABS(ts_ms - ?), id DESC LIMIT 1",
             (session_id, event, *kind_params, near_ts_ms - window_ms, near_ts_ms + window_ms, near_ts_ms),
         ).fetchone()

{cc_transcript-4.0.0 → cc_transcript-5.0.0}/cc_transcript/extract/correct.py

@@ -167,12 +167,9 @@ async def extract_correction(
     if log.for_anchor(anchor.session_id, anchor.event_uuid):
         return None
     pairs = await anyio.to_thread.run_sync(partial(harvest_pairs, activity, anchor, repo=repo))
-    if not pairs:
+    if not pairs or (turn := activity.turn_of(anchor)) is None:
         return None
-    turn = activity.turn_of(anchor)
-    pick = await choose_pair(
-        pairs, feedback=feedback, anchor_turn=turn.index if turn else 0, tier=tier, backend=backend
-    )
+    pick = await choose_pair(pairs, feedback=feedback, anchor_turn=turn.index, tier=tier, backend=backend)
     if pick is None or (row := lower_pair(activity, anchor, pick, source=source)) is None:
         return None
     if repo is not None:

{cc_transcript-4.0.0 → cc_transcript-5.0.0}/cc_transcript/judge/llm.py

@@ -1,22 +1,18 @@
 """Headless structured completions via spawnllm's first ready CLI backend.
 
-Argv construction and envelope parsing come from the shared ``spawnllm`` library;
-the spawn stays local (``anyio.run_process``). The backend is whichever of
-spawnllm's CLIs is installed and authenticated (:func:`spawnllm.select_backend`),
-using the caller's existing CLI auth — no API key, no pinned provider.
-``spawnllm`` and ``pydantic`` load lazily inside each function, so importing the
-judge package needs no extra installed.
+Run dispatch and envelope parsing come from the shared ``spawnllm`` library;
+:func:`spawnllm.run` drives the spawn and built-in transient retry. The backend
+is whichever of spawnllm's CLIs is installed and authenticated
+(:func:`spawnllm.select_backend`), using the caller's existing CLI auth — no API
+key, no pinned provider. ``spawnllm`` and ``pydantic`` load lazily inside each
+function, so importing the judge package needs no extra installed.
 """
 
 from __future__ import annotations
 
-import os
-import subprocess
 from functools import cache
 from typing import TYPE_CHECKING, cast
 
-import anyio
-
 if TYPE_CHECKING:
     from collections.abc import Awaitable, Callable
 
@@ -55,27 +51,24 @@ async def run_structured_on[M: BaseModel](
 
     A caller that resolves a backend once per pass passes it here, so a large pass
     probes auth once; :func:`run_structured` is the select-and-run convenience.
+    :func:`spawnllm.run` retries transient failures with backoff before returning.
 
     Raises:
-        subprocess.SubprocessError: If the backend CLI exits non-zero or times out.
+        subprocess.TimeoutExpired: If the backend CLI outlives ``timeout``.
         pydantic.ValidationError: If the response does not match the schema.
     """
-    from spawnllm import resolve_schema_path, schema_for
-
-    argv, stdin = backend.invocation(
-        prompt,
-        model=backend.models[tier],
-        schema_path=resolve_schema_path(backend, schema_for(response_model)),
-        agent=False,
+    from spawnllm import RunSpec, run
+
+    rr = await run(
+        RunSpec(
+            prompt=prompt,
+            model=backend.models[tier],
+            schema=backend.schema_for(response_model),
+            timeout=timeout,
+        ),
+        backend=backend,
     )
-    try:
-        with anyio.fail_after(timeout):
-            result = await anyio.run_process(
-                argv, input=stdin.encode() if stdin is not None else None, check=True, env=os.environ | backend.env()
-            )
-    except TimeoutError as exc:
-        raise subprocess.TimeoutExpired(argv, timeout) from exc
-    return cast(response_model, backend.parse_response(result.stdout.decode(), response_model))
+    return cast(M, backend.parse_response(rr.stdout, response_model))
 
 
 async def run_structured[M: BaseModel](
@@ -88,7 +81,7 @@ async def run_structured[M: BaseModel](
 
     Raises:
         spawnllm.BackendUnavailable: If no backend is installed and authenticated.
-        subprocess.SubprocessError: If the backend CLI exits non-zero or times out.
+        subprocess.TimeoutExpired: If the backend CLI outlives ``timeout``.
         pydantic.ValidationError: If the response does not match the schema.
     """
     return await run_structured_on(default_backend(), prompt, response_model=response_model, tier=tier, timeout=timeout)

{cc_transcript-4.0.0 → cc_transcript-5.0.0}/cc_transcript/judge/verdicts.py

@@ -421,7 +421,7 @@ class FlipReport:
 
 async def run_verdicts[V](
     rows: Sequence[Mapping[str, object]],
-    prompt_for: Callable[[Mapping[str, object]], str | Awaitable[str]],
+    prompt_for: Callable[[Mapping[str, object]], Awaitable[str]],
     judge: Callable[[str], Awaitable[V]],
     persist: Callable[[Mapping[str, object], V], Awaitable[None]],
     *,
@@ -436,8 +436,8 @@ async def run_verdicts[V](
 
     Args:
         rows: The rows to judge.
-        prompt_for: Builds one row's prompt; sync, or async for prompts that
-            hydrate their context window first.
+        prompt_for: Builds one row's prompt; async, so prompts may hydrate their
+            context window first.
         judge: Turns one prompt into a verdict payload, e.g. ``structured_judge(...)``.
         persist: Persists one row's verdict, e.g. ``store.record_verdict`` applied.
         concurrency: The maximum number of concurrent judge calls.
@@ -451,11 +451,7 @@ async def run_verdicts[V](
     async def worker(row: Mapping[str, object]) -> None:
         async with limiter:
             try:
-                match prompt_for(row):
-                    case str() as prompt:
-                        verdict = await judge(prompt)
-                    case awaitable:
-                        verdict = await judge(await awaitable)
+                verdict = await judge(await prompt_for(row))
             except Exception:
                 counts["failed"] += 1
                 return

{cc_transcript-4.0.0 → cc_transcript-5.0.0}/cc_transcript/mining/__init__.py

@@ -44,15 +44,25 @@ from cc_transcript.mining.filterspec import (
     keep_candidate,
     only_kinds,
 )
-from cc_transcript.mining.formats import ReviewComment, ReviewFormat, extract_all
+from cc_transcript.mining.formats import (
+    ReviewComment,
+    ReviewFormat,
+    StructuredFormat,
+    extract_all,
+    extract_structured,
+)
 from cc_transcript.mining.signals import (
     DEFAULT_DETECTORS,
     DENIAL_PREFIX,
     EDIT_TOOLS,
     REENTRY_LOOKBACK,
+    SUBAGENT_TOOLS,
     USER_SAID_MARKER,
     USER_SAID_TRAILER,
     MiningSignal,
+    Provenance,
+    ScanText,
+    classify_provenance,
     correction_text,
     denial_results,
     denied_tool_payload,
@@ -69,6 +79,7 @@ from cc_transcript.mining.signals import (
     marker_in,
     nearest_assistant_index,
     next_user_message,
+    review_scan_texts,
 )
 from cc_transcript.mining.sourcekind import (
     INTERRUPT_REJECTION,