cc-transcript 6.0.0__tar.gz → 7.0.1__tar.gz

{cc_transcript-6.0.0 → cc_transcript-7.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-transcript
-Version: 6.0.0
+Version: 7.0.1
 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.4.0 ; extra == 'llm'
+Requires-Dist: spawnllm>=0.5.1,<0.6 ; extra == 'llm'
 Requires-Dist: spacy>=3.8 ; extra == 'sentiment'
 Requires-Dist: afinn>=0.1 ; extra == 'sentiment'
 Provides-Extra: dev

{cc_transcript-6.0.0 → cc_transcript-7.0.1}/cc_transcript/extract/correct.py

@@ -25,7 +25,6 @@ import anyio.to_thread
 from pydantic import BaseModel
 
 from cc_transcript.evidence import GitFix, harvest_pairs, lower_pair
-from cc_transcript.judge.llm import run_structured_on
 from cc_transcript.render import Budget, hunk_lines
 
 if TYPE_CHECKING:
@@ -138,10 +137,12 @@ def usable_backend() -> LlmBackend | None:
 async def choose_pair(
     pairs: Sequence[CandidatePair], *, feedback: str, anchor_turn: int, tier: TModel, backend: LlmBackend | None
 ) -> CandidatePair | None:
+    from spawnllm import extract
+
     if backend is None:
         return max(pairs, key=lambda pair: pair.overlap)
-    pick = await run_structured_on(
-        backend, build_pick_prompt(feedback, pairs, anchor_turn=anchor_turn), response_model=CorrectionPick, tier=tier
+    pick = await extract(
+        build_pick_prompt(feedback, pairs, anchor_turn=anchor_turn), CorrectionPick, backend=backend, model=tier
     )
     return pairs[pick.candidate - 1] if pick.candidate is not None and 1 <= pick.candidate <= len(pairs) else None
 

{cc_transcript-6.0.0 → cc_transcript-7.0.1}/cc_transcript/judge/__init__.py

@@ -12,7 +12,7 @@ prompts, the verdict model, and any SQL views over the verdict table.
 
 from __future__ import annotations
 
-from cc_transcript.judge.llm import resolved_model, run_structured, run_structured_on, structured_judge
+from cc_transcript.judge.llm import default_backend, resolved_model, structured_judge
 from cc_transcript.judge.verdicts import (
     AuditEstimate,
     AuditSample,

cc_transcript-7.0.1/cc_transcript/judge/llm.py

@@ -0,0 +1,62 @@
+"""Headless structured completions via spawnllm's first ready CLI backend.
+
+The structured call comes from the shared ``spawnllm`` library;
+:func:`spawnllm.extract` resolves a backend, runs the spawn, and validates the
+response into the model. 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
+
+from functools import cache
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+
+    from pydantic import BaseModel
+    from spawnllm import LlmBackend, TModel
+
+LLM_TIMEOUT = 180
+
+
+@cache
+def default_backend() -> LlmBackend:
+    """The first installed, authenticated spawnllm backend, cached per process.
+
+    Raises:
+        spawnllm.BackendUnavailable: When no backend is installed and authenticated.
+    """
+    from spawnllm import select_backend
+
+    return select_backend()
+
+
+def resolved_model(tier: TModel) -> str:
+    """The concrete model name the active backend runs for an abstract tier.
+
+    The verdict store keys on this string; it reflects whichever backend
+    :func:`spawnllm.select_backend` resolves, so a judged corpus stays coherent
+    within one backend environment.
+    """
+    return default_backend().models[tier]
+
+
+def structured_judge[M: BaseModel](
+    response_model: type[M], *, tier: TModel, timeout: int = LLM_TIMEOUT
+) -> Callable[[str], Awaitable[M]]:
+    """Returns a prompt-to-verdict callable that plugs into :func:`run_verdicts`.
+
+    Each call runs one structured completion on the cached default backend via
+    :func:`spawnllm.extract`, which validates the response into ``response_model``.
+
+    Example:
+        >>> judge = structured_judge(Verdict, tier="medium")
+        >>> await run_verdicts(rows, prompt_for, judge, persist, concurrency=8)
+    """
+    from spawnllm import extract
+
+    return lambda prompt: extract(prompt, response_model, backend=default_backend(), model=tier, timeout=timeout)

{cc_transcript-6.0.0 → cc_transcript-7.0.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cc-transcript"
-version = "6.0.0"
+version = "7.0.1"
 description = "The Claude Code session-activity platform: a superset JSONL parser (Rust fast path, Python reference), typed tool calls with a cross-language content digest, turns/edits/evidence over one spine, context windows with labeled fidelity, unified decision and correction ledgers, LLM judging, and a transcript-investigation CLI."
 readme = "README.md"
 license = "PolyForm-Noncommercial-1.0.0"
@@ -46,7 +46,7 @@ sentiment = [
     "spacy>=3.8",
     "afinn>=0.1",
 ]
-llm = ["spawnllm>=0.4.0"]
+llm = ["spawnllm>=0.5.1,<0.6"]
 
 [project.scripts]
 cc-transcript = "cc_transcript.cli:cli"

cc_transcript-6.0.0/cc_transcript/judge/llm.py

@@ -1,99 +0,0 @@
-"""Headless structured completions via spawnllm's first ready CLI backend.
-
-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
-
-from functools import cache
-from typing import TYPE_CHECKING, cast
-
-if TYPE_CHECKING:
-    from collections.abc import Awaitable, Callable
-
-    from pydantic import BaseModel
-    from spawnllm import LlmBackend, TModel
-
-LLM_TIMEOUT = 180
-
-
-@cache
-def default_backend() -> LlmBackend:
-    """The first installed, authenticated spawnllm backend, cached per process.
-
-    Raises:
-        spawnllm.BackendUnavailable: When no backend is installed and authenticated.
-    """
-    from spawnllm import select_backend
-
-    return select_backend()
-
-
-def resolved_model(tier: TModel) -> str:
-    """The concrete model name the active backend runs for an abstract tier.
-
-    The verdict store keys on this string; it reflects whichever backend
-    :func:`spawnllm.select_backend` resolves, so a judged corpus stays coherent
-    within one backend environment.
-    """
-    return default_backend().models[tier]
-
-
-async def run_structured_on[M: BaseModel](
-    backend: LlmBackend, prompt: str, *, response_model: type[M], tier: TModel, timeout: int = LLM_TIMEOUT
-) -> M:
-    """Runs one structured completion on an explicit ``backend``.
-
-    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.TimeoutExpired: If the backend CLI outlives ``timeout``.
-        pydantic.ValidationError: If the response does not match the schema.
-    """
-    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,
-    )
-    return cast(M, backend.parse_response(rr.stdout, response_model))
-
-
-async def run_structured[M: BaseModel](
-    prompt: str, *, response_model: type[M], tier: TModel, timeout: int = LLM_TIMEOUT
-) -> M:
-    """Runs one structured completion on the first ready backend.
-
-    The prompt is delivered to the CLI and the response forced into
-    ``response_model``'s JSON schema. Backend selection is cached per process.
-
-    Raises:
-        spawnllm.BackendUnavailable: If no backend is installed and authenticated.
-        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)
-
-
-def structured_judge[M: BaseModel](
-    response_model: type[M], *, tier: TModel, timeout: int = LLM_TIMEOUT
-) -> Callable[[str], Awaitable[M]]:
-    """Returns a prompt-to-verdict callable that plugs into :func:`run_verdicts`.
-
-    Example:
-        >>> judge = structured_judge(Verdict, tier="medium")
-        >>> await run_verdicts(rows, prompt_for, judge, persist, concurrency=8)
-    """
-    return lambda prompt: run_structured(prompt, response_model=response_model, tier=tier, timeout=timeout)