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

{cc_transcript-4.1.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.1.0 → cc_transcript-5.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-transcript
-Version: 4.1.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.1.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.1.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.1.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.1.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.1.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.1.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.1.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,

cc_transcript-5.0.0/cc_transcript/mining/formats.py

@@ -0,0 +1,172 @@
+"""Generic infrastructure for parsing structured code-review messages.
+
+The concrete review formats are app policy; an app injects its own
+:class:`ReviewFormat` sequence into :func:`extract_all`.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import re
+    from collections.abc import Callable, Iterator, Mapping, Sequence
+    from typing import Any
+
+FINDING_KEYS: tuple[str, ...] = ("findings", "bugs", "improvements", "issues", "items", "verdicts")
+
+
+@dataclass(frozen=True, slots=True)
+class ReviewComment:
+    """A single inline review comment parsed from a code-review message.
+
+    Attributes:
+        file: The file the comment targets, when cited.
+        line_start: The first line the comment targets, when cited.
+        line_end: The last line the comment targets, when a range is cited.
+        comment: The comment's text.
+    """
+
+    file: str | None
+    line_start: int | None
+    line_end: int | None
+    comment: str
+
+
+@dataclass(frozen=True, slots=True)
+class ReviewFormat:
+    """A named code-review text format with a detector and extractor.
+
+    Attributes:
+        name: The format's identifier.
+        pattern: A pattern that matches when the format is present in a text.
+        extract: Parses a matching text into its review comments.
+    """
+
+    name: str
+    pattern: re.Pattern[str]
+    extract: Callable[[str], tuple[ReviewComment, ...]]
+
+
+def extract_all(text: str, formats: Sequence[ReviewFormat]) -> Iterator[tuple[ReviewFormat, ReviewComment]]:
+    """Yields every ``(format, comment)`` extracted by any matching format.
+
+    Args:
+        text: The raw review message text.
+        formats: The review formats to try, in order.
+
+    Yields:
+        One pair per extracted comment, across all formats whose pattern matches.
+    """
+    return (
+        (fmt, comment)
+        for fmt in formats
+        if fmt.pattern.search(text)
+        for comment in fmt.extract(text)
+    )
+
+
+@dataclass(frozen=True, slots=True)
+class StructuredFormat:
+    """A named JSON code-review format keyed by caller-supplied field aliases.
+
+    The aliases let an app map its own finding schema onto :class:`ReviewComment`
+    without hardcoding key names here. Each alias tuple is tried in order against
+    every finding object.
+
+    Attributes:
+        name: The format's identifier.
+        file_keys: Aliases for the cited file path.
+        line_keys: Aliases for the cited line (int, ``"96"``, or ``"24-51"``).
+        comment_keys: Aliases for the comment text.
+        fix_keys: Aliases for a suggested fix appended to the comment, when present.
+        finding_keys: Extra aliases for the finding array, beyond the defaults.
+    """
+
+    name: str
+    file_keys: tuple[str, ...] = ("file", "path", "file_path")
+    line_keys: tuple[str, ...] = ("line", "line_start", "lines")
+    comment_keys: tuple[str, ...] = ("comment", "message", "text", "description")
+    fix_keys: tuple[str, ...] = field(default=())
+    finding_keys: tuple[str, ...] = field(default=())
+
+    def extract(self, payload: Any) -> tuple[ReviewComment, ...]:
+        return tuple(
+            review_comment(obj, self.file_keys, self.line_keys, self.comment_keys, self.fix_keys)
+            for obj in findings(payload, FINDING_KEYS + self.finding_keys)
+            if isinstance(obj, dict)
+            if first(obj, self.comment_keys) is not None
+        )
+
+
+def first(obj: Mapping[str, Any], keys: tuple[str, ...]) -> Any:
+    return next((obj[key] for key in keys if key in obj and obj[key] is not None), None)
+
+
+def line_bounds(value: Any) -> tuple[int | None, int | None]:
+    match value:
+        case int():
+            return value, value
+        case str() if "-" in value:
+            start, _, end = value.partition("-")
+            return int(start.strip()), int(end.strip())
+        case str() if value.strip().isdigit():
+            return (n := int(value.strip())), n
+        case _:
+            return None, None
+
+
+def review_comment(
+    obj: Mapping[str, Any],
+    file_keys: tuple[str, ...],
+    line_keys: tuple[str, ...],
+    comment_keys: tuple[str, ...],
+    fix_keys: tuple[str, ...] = (),
+) -> ReviewComment:
+    start, end = line_bounds(first(obj, line_keys))
+    return ReviewComment(
+        file=(file := first(obj, file_keys)) and str(file),
+        line_start=start,
+        line_end=end,
+        comment=" ".join(str(part) for part in (first(obj, comment_keys), first(obj, fix_keys)) if part is not None),
+    )
+
+
+def findings(payload: Any, keys: tuple[str, ...]) -> Iterator[Any]:
+    match payload:
+        case list():
+            yield from payload
+        case dict():
+            if (nested := first(payload, keys)) is not None and isinstance(nested, list):
+                yield from nested
+            elif isinstance(result := payload.get("result"), dict):
+                yield from findings(result, keys)
+            else:
+                yield from (
+                    item
+                    for key, value in payload.items()
+                    if key.startswith("confirmed")
+                    if isinstance(value, list)
+                    for item in value
+                )
+
+
+def extract_structured(
+    text: str, structured_formats: Sequence[StructuredFormat]
+) -> Iterator[tuple[StructuredFormat, ReviewComment]]:
+    """Yields every ``(format, comment)`` JSON-parsed from a finding payload.
+
+    Args:
+        text: The raw message text, expected to be a JSON document.
+        structured_formats: The structured formats to apply, in order.
+
+    Yields:
+        One pair per finding, across all formats. Non-JSON text yields nothing.
+    """
+    try:
+        payload = json.loads(text)
+    except (ValueError, TypeError):
+        return
+    yield from ((fmt, comment) for fmt in structured_formats for comment in fmt.extract(payload))