cc-transcript 14.4.0__tar.gz → 14.5.0__tar.gz

{cc_transcript-14.4.0 → cc_transcript-14.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-transcript
-Version: 14.4.0
+Version: 14.5.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{cc_transcript-14.4.0 → cc_transcript-14.5.0}/cc_transcript/_native.pyi

@@ -1,6 +1,7 @@
 # This file is automatically generated by pyo3_stub_gen
 # ruff: noqa: E501, F401, F403, F405
 
+import asyncio
 import builtins
 from cc_transcript import command
 from cc_transcript import ids
@@ -1447,37 +1448,40 @@ class Redirect:
 @typing.final
 class RustCorrectionLog:
     def __new__(cls, path: builtins.str) -> RustCorrectionLog: ...
-    def append(self, ts_ms: builtins.int, session_id: builtins.str, source: builtins.str, anchor_uuid: builtins.str, incorrect_digest: typing.Optional[builtins.str], incorrect_file: builtins.str, incorrect_old: builtins.str, incorrect_new: builtins.str, correction_origin: typing.Optional[builtins.str], correction_file: typing.Optional[builtins.str], correction_old: typing.Optional[builtins.str], correction_new: typing.Optional[builtins.str], correction_commit: typing.Optional[builtins.str], correction_text: typing.Optional[builtins.str], overlap: builtins.float, detail: typing.Any) -> None: ...
-    def for_session(self, session_id: builtins.str) -> list[dict[str, typing.Any]]: ...
-    def for_repo(self, repo: builtins.str) -> list[dict[str, typing.Any]]: ...
-    def since(self, ts_ms: builtins.int, source: typing.Optional[builtins.str] = None) -> list[dict[str, typing.Any]]: ...
-    def for_anchor(self, session_id: builtins.str, anchor_uuid: builtins.str) -> list[dict[str, typing.Any]]: ...
-    def by_digest(self, session_id: builtins.str, incorrect_digest: builtins.str) -> list[dict[str, typing.Any]]: ...
-    def sql(self, statement: builtins.str) -> list[dict[str, typing.Any]]: ...
+    def open(self) -> asyncio.Future[None]: ...
+    def close(self) -> asyncio.Future[None]: ...
+    def append(self, ts_ms: builtins.int, session_id: builtins.str, source: builtins.str, anchor_uuid: builtins.str, incorrect_digest: typing.Optional[builtins.str], incorrect_file: builtins.str, incorrect_old: builtins.str, incorrect_new: builtins.str, correction_origin: typing.Optional[builtins.str], correction_file: typing.Optional[builtins.str], correction_old: typing.Optional[builtins.str], correction_new: typing.Optional[builtins.str], correction_commit: typing.Optional[builtins.str], correction_text: typing.Optional[builtins.str], overlap: builtins.float, detail: typing.Any) -> asyncio.Future[None]: ...
+    def for_session(self, session_id: builtins.str) -> asyncio.Future[list[dict[str, typing.Any]]]: ...
+    def for_repo(self, repo: builtins.str) -> asyncio.Future[list[dict[str, typing.Any]]]: ...
+    def since(self, ts_ms: builtins.int, source: typing.Optional[builtins.str] = None) -> asyncio.Future[list[dict[str, typing.Any]]]: ...
+    def for_anchor(self, session_id: builtins.str, anchor_uuid: builtins.str) -> asyncio.Future[list[dict[str, typing.Any]]]: ...
+    def by_digest(self, session_id: builtins.str, incorrect_digest: builtins.str) -> asyncio.Future[list[dict[str, typing.Any]]]: ...
+    def sql(self, statement: builtins.str) -> asyncio.Future[list[dict[str, typing.Any]]]: ...
 
 @typing.final
 class RustFeedbackStore:
     def __new__(cls, path: builtins.str, extra_ddl: typing.Sequence[builtins.str], event_columns: typing.Sequence[builtins.str], migrations: typing.Sequence[tuple[builtins.str, builtins.str, builtins.str, typing.Optional[builtins.str]]], verdict_table: builtins.str, accepted_column: builtins.str, summary_column: builtins.str, event_filter: typing.Optional[builtins.str], readonly: builtins.bool = False, busy_timeout_ms: typing.Optional[builtins.int] = None) -> RustFeedbackStore: ...
-    def close(self) -> None: ...
-    def sql(self, statement: builtins.str, params: typing.Optional[typing.Sequence[typing.Any]] = None) -> list[dict[str, typing.Any]]: ...
-    def execute(self, statement: builtins.str, params: typing.Optional[typing.Sequence[typing.Any]] = None) -> builtins.int: ...
-    def executemany(self, statement: builtins.str, seq: typing.Sequence[typing.Sequence[typing.Any]]) -> builtins.int: ...
-    def executescript(self, script: builtins.str) -> None: ...
-    def last_insert_rowid(self) -> builtins.int: ...
-    def load_extension(self, path: builtins.str) -> None: ...
-    def begin_immediate(self) -> None: ...
-    def commit(self) -> None: ...
-    def rollback(self) -> None: ...
-    def insert_candidates(self, rows: typing.Sequence[typing.Sequence[typing.Any]], extras: typing.Optional[typing.Sequence[typing.Sequence[typing.Any]]] = None) -> builtins.list[builtins.str]: ...
-    def record_file(self, path: builtins.str, mtime: builtins.float) -> None: ...
-    def file_mtimes(self) -> list[dict[str, typing.Any]]: ...
-    def stats(self) -> tuple[int, int, list[dict[str, typing.Any]]]: ...
-    def recent(self, source_kind: typing.Optional[builtins.str] = None, limit: builtins.int = 20) -> list[dict[str, typing.Any]]: ...
-    def events(self, source_kind: typing.Optional[builtins.str] = None) -> list[dict[str, typing.Any]]: ...
-    def dedup_keys(self) -> builtins.list[builtins.str]: ...
-    def record_verdict(self, dedup_key: builtins.str, role: builtins.str, prompt_version: builtins.int, model: builtins.str, category: builtins.str, accepted: builtins.bool, summary: builtins.str, confidence: builtins.float, rationale: builtins.str, canonical_key: typing.Optional[builtins.str], fidelity: builtins.str, judged_at: builtins.str) -> builtins.bool: ...
-    def unjudged(self, role: builtins.str, prompt_version: builtins.int, refresh_summary: builtins.bool = False, limit: typing.Optional[builtins.int] = None, offset: typing.Optional[builtins.int] = None) -> list[dict[str, typing.Any]]: ...
-    def judged(self, role: builtins.str, prompt_version: builtins.int) -> list[dict[str, typing.Any]]: ...
+    def open(self) -> asyncio.Future[None]: ...
+    def close(self) -> asyncio.Future[None]: ...
+    def sql(self, statement: builtins.str, params: typing.Optional[typing.Sequence[typing.Any]] = None) -> asyncio.Future[list[dict[str, typing.Any]]]: ...
+    def execute(self, statement: builtins.str, params: typing.Optional[typing.Sequence[typing.Any]] = None) -> asyncio.Future[int]: ...
+    def executemany(self, statement: builtins.str, seq: typing.Sequence[typing.Sequence[typing.Any]]) -> asyncio.Future[int]: ...
+    def executescript(self, script: builtins.str) -> asyncio.Future[None]: ...
+    def last_insert_rowid(self) -> asyncio.Future[int]: ...
+    def load_extension(self, path: builtins.str) -> asyncio.Future[None]: ...
+    def begin_immediate(self) -> asyncio.Future[None]: ...
+    def commit(self) -> asyncio.Future[None]: ...
+    def rollback(self) -> asyncio.Future[None]: ...
+    def insert_candidates(self, rows: typing.Sequence[typing.Sequence[typing.Any]], extras: typing.Optional[typing.Sequence[typing.Sequence[typing.Any]]] = None) -> asyncio.Future[list[str]]: ...
+    def record_file(self, path: builtins.str, mtime: builtins.float) -> asyncio.Future[None]: ...
+    def file_mtimes(self) -> asyncio.Future[list[dict[str, typing.Any]]]: ...
+    def stats(self) -> asyncio.Future[tuple[int, int, list[dict[str, typing.Any]]]]: ...
+    def recent(self, source_kind: typing.Optional[builtins.str] = None, limit: builtins.int = 20) -> asyncio.Future[list[dict[str, typing.Any]]]: ...
+    def events(self, source_kind: typing.Optional[builtins.str] = None) -> asyncio.Future[list[dict[str, typing.Any]]]: ...
+    def dedup_keys(self) -> asyncio.Future[list[str]]: ...
+    def record_verdict(self, dedup_key: builtins.str, role: builtins.str, prompt_version: builtins.int, model: builtins.str, category: builtins.str, accepted: builtins.bool, summary: builtins.str, confidence: builtins.float, rationale: builtins.str, canonical_key: typing.Optional[builtins.str], fidelity: builtins.str, judged_at: builtins.str) -> asyncio.Future[bool]: ...
+    def unjudged(self, role: builtins.str, prompt_version: builtins.int, refresh_summary: builtins.bool = False, limit: typing.Optional[builtins.int] = None, offset: typing.Optional[builtins.int] = None) -> asyncio.Future[list[dict[str, typing.Any]]]: ...
+    def judged(self, role: builtins.str, prompt_version: builtins.int) -> asyncio.Future[list[dict[str, typing.Any]]]: ...
 
 @typing.final
 class ServerToolUse:

{cc_transcript-14.4.0 → cc_transcript-14.5.0}/cc_transcript/corrections.py

@@ -26,6 +26,7 @@ from cc_transcript.literals import literal_str
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
+    from types import TracebackType
     from typing import Any
 
     from cc_transcript.ids import EventUuid, SessionId, ToolDigest
@@ -93,16 +94,16 @@ class CorrectionLog:
     the module docstring).
 
     Example:
-        >>> log = CorrectionLog.open()
-        >>> log.append(correction)
-        >>> log.by_digest(session_id, incorrect_digest=digest)
+        >>> async with await CorrectionLog.open() as log:
+        ...     await log.append(correction)
+        ...     await log.by_digest(session_id, incorrect_digest=digest)
     """
 
     def __init__(self, engine: _native.RustCorrectionLog) -> None:
         self._engine = engine
 
     @classmethod
-    def open(cls, path: Path | None = None) -> Self:
+    async def open(cls, path: Path | None = None) -> Self:
         """Opens (creating if needed) the ledger at ``path``.
 
         Args:
@@ -113,17 +114,37 @@ class CorrectionLog:
             The opened log.
         """
         path = path or Path.home() / ".cc-transcript" / "corrections.db"
-        path.parent.mkdir(parents=True, exist_ok=True)
-        return cls(_native.RustCorrectionLog(str(path)))
-
-    def append(self, record: Correction) -> None:
+        engine = _native.RustCorrectionLog(str(path))
+        try:
+            await engine.open()
+        except BaseException:
+            await engine.close()
+            raise
+        return cls(engine)
+
+    async def close(self) -> None:
+        """Closes the underlying connection; a second close is a no-op."""
+        await self._engine.close()
+
+    async def __aenter__(self) -> Self:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        await self.close()
+
+    async def append(self, record: Correction) -> None:
         """Appends ``record`` as a single ``INSERT OR IGNORE``.
 
         Idempotent on the table's UNIQUE key, so re-running a writer writes one
         row; SQLite treats NULL key columns as distinct, so rows whose key
         carries a NULL rely on the writer not repeating the same values.
         """
-        self._engine.append(
+        await self._engine.append(
             record.ts_ms,
             record.session_id,
             record.source,
@@ -142,39 +163,39 @@ class CorrectionLog:
             record.detail,
         )
 
-    def for_session(self, session_id: SessionId) -> tuple[Correction, ...]:
+    async def for_session(self, session_id: SessionId) -> tuple[Correction, ...]:
         """All records for ``session_id``, ordered by timestamp."""
-        return tuple(Correction(**row) for row in self._engine.for_session(session_id))
+        return tuple(Correction(**row) for row in await self._engine.for_session(session_id))
 
-    def for_repo(self, repo: str) -> tuple[Correction, ...]:
+    async def for_repo(self, repo: str) -> tuple[Correction, ...]:
         """All corrections whose ``detail.repo`` is ``repo``, ordered by timestamp.
 
         The repo key producers stamp into ``detail`` so a per-repo consumer (the
         captain-hook reviewer) can pull every correction for its repo at once.
         """
-        return tuple(Correction(**row) for row in self._engine.for_repo(repo))
+        return tuple(Correction(**row) for row in await self._engine.for_repo(repo))
 
-    def since(self, ts_ms: int, *, source: str | None = None) -> tuple[Correction, ...]:
+    async def since(self, ts_ms: int, *, source: str | None = None) -> tuple[Correction, ...]:
         """Corrections with ``ts_ms`` strictly greater than ``ts_ms``, oldest first.
 
         A cursor read for incremental consumers; pass ``source`` to scope to one
         producer.
         """
-        return tuple(Correction(**row) for row in self._engine.since(ts_ms, source))
+        return tuple(Correction(**row) for row in await self._engine.since(ts_ms, source))
 
-    def for_anchor(self, session_id: SessionId, anchor_uuid: EventUuid) -> tuple[Correction, ...]:
+    async def for_anchor(self, session_id: SessionId, anchor_uuid: EventUuid) -> tuple[Correction, ...]:
         """The corrections harvested around one feedback ``anchor_uuid``."""
-        return tuple(Correction(**row) for row in self._engine.for_anchor(session_id, anchor_uuid))
+        return tuple(Correction(**row) for row in await self._engine.for_anchor(session_id, anchor_uuid))
 
-    def by_digest(self, session_id: SessionId, *, incorrect_digest: ToolDigest) -> tuple[Correction, ...]:
+    async def by_digest(self, session_id: SessionId, *, incorrect_digest: ToolDigest) -> tuple[Correction, ...]:
         """Corrections of the tool call with ``incorrect_digest`` in ``session_id``.
 
         The cross-consumer join: pass the ``tool_digest`` a hook recorded in
         the ``decisions`` ledger to learn whether that exact edit was later
         corrected.
         """
-        return tuple(Correction(**row) for row in self._engine.by_digest(session_id, incorrect_digest))
+        return tuple(Correction(**row) for row in await self._engine.by_digest(session_id, incorrect_digest))
 
-    def sql(self, statement: str) -> list[dict[str, Any]]:
+    async def sql(self, statement: str) -> list[dict[str, Any]]:
         """Runs one raw SQL ``statement`` — the escape hatch behind ``corrections sql``."""
-        return self._engine.sql(statement)
+        return await self._engine.sql(statement)

{cc_transcript-14.4.0 → cc_transcript-14.5.0}/cc_transcript/decisions.py

@@ -14,7 +14,7 @@ import sqlite3
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Literal
 
-from cc_transcript.ledger import SyncLedger
+from cc_transcript.ledger import AsyncLedger
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
@@ -87,7 +87,7 @@ class Decision:
     detail: Mapping[str, Any] = field(default_factory=dict)
 
 
-class DecisionLog(SyncLedger[Decision]):
+class DecisionLog(AsyncLedger[Decision]):
     """The ``decisions`` ledger at ``~/.cc-transcript/decisions.db``.
 
     Opened in WAL mode with a busy timeout because cc-review's Go daemon
@@ -95,9 +95,10 @@ class DecisionLog(SyncLedger[Decision]):
     auto-dropped. Requires a local disk — WAL does not work over NFS.
 
     Example:
-        >>> log = DecisionLog.open()
-        >>> log.append(decision)
-        >>> log.attribute_tool(session_id, tool_digest=digest, near_ts_ms=ts)
+        >>> log = await DecisionLog.open()
+        >>> async with log:
+        ...     await log.append(decision)
+        ...     await log.attribute_tool(session_id, tool_digest=digest, near_ts_ms=ts)
     """
 
     DDL = DECISIONS_DDL
@@ -134,7 +135,7 @@ class DecisionLog(SyncLedger[Decision]):
             detail=json.loads(row["detail_json"]),
         )
 
-    def attribute_tool(
+    async def attribute_tool(
         self, session_id: SessionId, *, tool_digest: ToolDigest, near_ts_ms: int, window_ms: int = 300_000
     ) -> Decision | None:
         """The nearest decision preceding ``near_ts_ms`` with this digest.
@@ -148,14 +149,17 @@ class DecisionLog(SyncLedger[Decision]):
             The matching decision, or None when no digest-equal row lies in
             ``[near_ts_ms - window_ms, near_ts_ms]``.
         """
-        row = self.conn.execute(
-            "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()
+        conn = self._actor.conn
+        row = await self._actor.run(
+            lambda: conn.execute(
+                "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()
+        )
         return self.row_to_record(row) if row else None
 
-    def attribute_nearest(
+    async def attribute_nearest(
         self,
         session_id: SessionId,
         *,
@@ -175,10 +179,13 @@ class DecisionLog(SyncLedger[Decision]):
             The nearest matching decision, or None when none lies in
             ``[near_ts_ms - window_ms, near_ts_ms + window_ms]``.
         """
+        conn = self._actor.conn
         kind_clause, kind_params = ("AND kind = ? ", (kind,)) if kind is not None else ("", ())
-        row = self.conn.execute(
-            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()
+        row = await self._actor.run(
+            lambda: conn.execute(
+                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()
+        )
         return self.row_to_record(row) if row else None

{cc_transcript-14.4.0 → cc_transcript-14.5.0}/cc_transcript/evidence.py

@@ -199,7 +199,7 @@ def run_git(repo: Path, *args: str) -> str | None:
     return proc.stdout if proc.returncode == 0 else None
 
 
-def record_harvest(
+async def record_harvest(
     log: CorrectionLog,
     activity: SessionActivity,
     anchor: EventRef,
@@ -219,7 +219,7 @@ def record_harvest(
     """
     rows = [correction for pair in pairs if (correction := lower_pair(activity, anchor, pair, source=source))]
     for row in rows:
-        log.append(row)
+        await log.append(row)
     return len(rows)
 
 

{cc_transcript-14.4.0 → cc_transcript-14.5.0}/cc_transcript/extract/correct.py

@@ -163,7 +163,7 @@ async def extract_correction(
     already has a row, so re-runs and overlapping producers never duplicate.
     Returns the appended correction, or None when nothing is harvested or picked.
     """
-    if log.for_anchor(anchor.session_id, anchor.event_uuid):
+    if await log.for_anchor(anchor.session_id, anchor.event_uuid):
         return None
     pairs = await asyncio.to_thread(harvest_pairs, activity, anchor, repo=repo)
     if not pairs or (turn := activity.turn_of(anchor)) is None:
@@ -173,5 +173,5 @@ async def extract_correction(
         return None
     if repo is not None:
         row = replace(row, detail={"repo": str(repo)})
-    log.append(row)
+    await log.append(row)
     return row

{cc_transcript-14.4.0 → cc_transcript-14.5.0}/cc_transcript/heartbeats.py

@@ -12,15 +12,15 @@ most one row per ``(session, event)``, so the table stays small however hot the
 
 from __future__ import annotations
 
-import sqlite3
 from dataclasses import dataclass
-from pathlib import Path
 from typing import TYPE_CHECKING, Self
 
 from cc_transcript.decisions import DecisionLog
-from cc_transcript.ledger import open_sqlite
+from cc_transcript.ledger import ConnectionActor, open_sqlite
 
 if TYPE_CHECKING:
+    from pathlib import Path
+
     from cc_transcript.ids import SessionId
 
 HEARTBEATS_DDL = """\
@@ -63,30 +63,42 @@ class HeartbeatLog:
     most one row per event. Requires a local disk — WAL does not work over NFS.
 
     Example:
-        >>> log = HeartbeatLog.open()
-        >>> log.beat(session_id, "PreToolUse", ts_ms)
-        >>> log.for_session(session_id)
+        >>> log = await HeartbeatLog.open()
+        >>> async with log:
+        ...     await log.beat(session_id, "PreToolUse", ts_ms)
+        ...     await log.for_session(session_id)
     """
 
-    def __init__(self, conn: sqlite3.Connection) -> None:
-        self.conn = conn
+    def __init__(self, actor: ConnectionActor) -> None:
+        self._actor = actor
 
     @classmethod
-    def open(cls, path: Path | None = None) -> Self:
+    async def open(cls, path: Path | None = None) -> Self:
         """Opens (creating if needed) the heartbeat table at ``path`` (defaults to ``decisions.db``)."""
-        return cls(open_sqlite(path, filename=DecisionLog.FILENAME, ddl=HEARTBEATS_DDL))
+        actor = ConnectionActor()
+        await actor.start(lambda: open_sqlite(path, filename=DecisionLog.FILENAME, ddl=HEARTBEATS_DDL))
+        return cls(actor)
 
-    def beat(self, session_id: SessionId, event: str, ts_ms: int) -> None:
+    async def beat(self, session_id: SessionId, event: str, ts_ms: int) -> None:
         """Records one dispatch of ``event`` in ``session_id`` at ``ts_ms`` (upsert; ``count += 1``)."""
-        self.conn.execute(
-            "INSERT INTO dispatch_heartbeats (session_id, event, first_ts_ms, last_ts_ms, count) "
-            "VALUES (?, ?, ?, ?, 1) "
-            "ON CONFLICT (session_id, event) DO UPDATE SET last_ts_ms = excluded.last_ts_ms, count = count + 1",
-            (session_id, event, ts_ms, ts_ms),
+        conn = self._actor.conn
+        await self._actor.run(
+            lambda: conn.execute(
+                "INSERT INTO dispatch_heartbeats (session_id, event, first_ts_ms, last_ts_ms, count) "
+                "VALUES (?, ?, ?, ?, 1) "
+                "ON CONFLICT (session_id, event) DO UPDATE SET last_ts_ms = excluded.last_ts_ms, count = count + 1",
+                (session_id, event, ts_ms, ts_ms),
+            )
         )
 
-    def for_session(self, session_id: SessionId) -> tuple[Heartbeat, ...]:
+    async def for_session(self, session_id: SessionId) -> tuple[Heartbeat, ...]:
         """Every ``(session, event)`` beat for ``session_id``, ordered by first dispatch."""
+        conn = self._actor.conn
+        rows = await self._actor.run(
+            lambda: conn.execute(
+                "SELECT * FROM dispatch_heartbeats WHERE session_id = ? ORDER BY first_ts_ms, event", (session_id,)
+            ).fetchall()
+        )
         return tuple(
             Heartbeat(
                 session_id=row["session_id"],
@@ -95,7 +107,15 @@ class HeartbeatLog:
                 last_ts_ms=row["last_ts_ms"],
                 count=row["count"],
             )
-            for row in self.conn.execute(
-                "SELECT * FROM dispatch_heartbeats WHERE session_id = ? ORDER BY first_ts_ms, event", (session_id,)
-            )
+            for row in rows
         )
+
+    async def close(self) -> None:
+        """Closes the underlying connection; a second call is a no-op."""
+        await self._actor.close()
+
+    async def __aenter__(self) -> Self:
+        return self
+
+    async def __aexit__(self, *exc: object) -> None:
+        await self.close()

{cc_transcript-14.4.0 → cc_transcript-14.5.0}/cc_transcript/judge/similar.py

@@ -16,6 +16,7 @@ fails loud with an :class:`ImportError` naming it.
 
 from __future__ import annotations
 
+import asyncio
 from functools import cache
 from importlib.util import find_spec
 from typing import TYPE_CHECKING, NamedTuple
@@ -125,7 +126,7 @@ def default_embedder() -> Embedder:
     return embed
 
 
-def prepare_connection(store: FeedbackStore) -> None:
+async def prepare_connection(store: FeedbackStore) -> None:
     """Loads the sqlite-vec extension and creates the companion tables, once per store.
 
     The schema-creating ``executescript`` implicitly commits the connection, so
@@ -137,8 +138,8 @@ def prepare_connection(store: FeedbackStore) -> None:
 
     if store._vec_prepared:
         return
-    store.load_extension(sqlite_vec.loadable_path())
-    store.executescript(VECTOR_SCHEMA)
+    await store.load_extension(sqlite_vec.loadable_path())
+    await store.executescript(VECTOR_SCHEMA)
     store._vec_prepared = True
 
 
@@ -148,7 +149,7 @@ def serialize_vector(vector: np.ndarray) -> bytes:
     return sqlite_vec.serialize_float32(vector.tolist())
 
 
-def embed_evidence(store: FeedbackStore, *, dedup_key: DedupKey, canonical_key: str, summary: str) -> Evidence:
+async def embed_evidence(store: FeedbackStore, *, dedup_key: DedupKey, canonical_key: str, summary: str) -> Evidence:
     """Prepares the vector store and embeds a judged event's feedback for upsert.
 
     Fetches the event's feedback text from ``feedback_events`` and embeds it
@@ -174,12 +175,12 @@ def embed_evidence(store: FeedbackStore, *, dedup_key: DedupKey, canonical_key:
         ImportError: When the ``cc-transcript[judge]`` extra is not installed.
     """
     require_judge_extra()
-    prepare_connection(store)
-    rows = store.sql("SELECT text FROM feedback_events WHERE dedup_key = ?", [dedup_key])
+    await prepare_connection(store)
+    rows = await store.sql("SELECT text FROM feedback_events WHERE dedup_key = ?", [dedup_key])
     assert rows, "verdict dedup keys always resolve to a stored feedback event"
     text = str(rows[0]["text"])
-    embedder = default_embedder()
-    vector = embedder(f"{text}\n{summary}")
+    embedder = await asyncio.to_thread(default_embedder)
+    vector = await asyncio.to_thread(embedder, f"{text}\n{summary}")
     return Evidence(serialize_vector(vector), text, canonical_key)
 
 
@@ -187,7 +188,7 @@ def evidence_vector_id(dedup_key: DedupKey, role: str, prompt_version: int) -> s
     return f"{dedup_key}::{role}::{prompt_version}"
 
 
-def clear_evidence(store: FeedbackStore, *, dedup_key: DedupKey, role: str, prompt_version: int) -> None:
+async def clear_evidence(store: FeedbackStore, *, dedup_key: DedupKey, role: str, prompt_version: int) -> None:
     """Deletes any evidence vector for one verdict identity, on the caller's transaction.
 
     Both the delete pair :func:`record_evidence` runs before it re-inserts, and
@@ -203,11 +204,11 @@ def clear_evidence(store: FeedbackStore, *, dedup_key: DedupKey, role: str, prom
         prompt_version: The prompt version that produced the verdict.
     """
     vector_id = evidence_vector_id(dedup_key, role, prompt_version)
-    store.execute("DELETE FROM verdict_vectors WHERE vector_id = ?", [vector_id])
-    store.execute("DELETE FROM verdict_evidence WHERE vector_id = ?", [vector_id])
+    await store.execute("DELETE FROM verdict_vectors WHERE vector_id = ?", [vector_id])
+    await store.execute("DELETE FROM verdict_evidence WHERE vector_id = ?", [vector_id])
 
 
-def record_evidence(
+async def record_evidence(
     store: FeedbackStore, *, dedup_key: DedupKey, role: str, prompt_version: int, evidence: Evidence
 ) -> None:
     """Upserts a judged event's evidence vector inside the caller's open transaction.
@@ -226,17 +227,17 @@ def record_evidence(
         prompt_version: The prompt version that produced the verdict.
         evidence: The embedded feedback from :func:`embed_evidence`.
     """
-    clear_evidence(store, dedup_key=dedup_key, role=role, prompt_version=prompt_version)
+    await clear_evidence(store, dedup_key=dedup_key, role=role, prompt_version=prompt_version)
     vector_id = evidence_vector_id(dedup_key, role, prompt_version)
-    store.execute("INSERT INTO verdict_vectors(vector_id, embedding) VALUES (?, ?)", [vector_id, evidence.vector])
-    store.execute(
+    await store.execute("INSERT INTO verdict_vectors(vector_id, embedding) VALUES (?, ?)", [vector_id, evidence.vector])
+    await store.execute(
         "INSERT INTO verdict_evidence(vector_id, dedup_key, role, prompt_version, canonical_key, evidence_text) "
         "VALUES (?, ?, ?, ?, ?, ?)",
         [vector_id, dedup_key, role, prompt_version, evidence.canonical_key, evidence.text],
     )
 
 
-def prepare_evidence_removal(store: FeedbackStore) -> bool:
+async def prepare_evidence_removal(store: FeedbackStore) -> bool:
     """Readies the vec companion so an in-transaction :func:`clear_evidence` can reach it.
 
     Returns False — skip the removal — whenever no evidence could exist: ``sqlite_vec``
@@ -257,13 +258,13 @@ def prepare_evidence_removal(store: FeedbackStore) -> bool:
         return True
     if find_spec("sqlite_vec") is None:
         return False
-    if not store.sql("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'verdict_evidence'"):
+    if not await store.sql("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'verdict_evidence'"):
         return False
-    prepare_connection(store)
+    await prepare_connection(store)
     return True
 
 
-def suggest_canonical_keys(store: FeedbackStore, text: str, *, prompt_version: int, k: int = 5) -> list[Suggestion]:
+async def suggest_canonical_keys(store: FeedbackStore, text: str, *, prompt_version: int, k: int = 5) -> list[Suggestion]:
     """Ranks stored canonical keys by evidence similarity to ``text``.
 
     Embeds ``text`` and scans every evidence vector recorded at ``prompt_version``,
@@ -284,11 +285,11 @@ def suggest_canonical_keys(store: FeedbackStore, text: str, *, prompt_version: i
         ImportError: When the ``cc-transcript[judge]`` extra is not installed.
     """
     require_judge_extra()
-    prepare_connection(store)
-    embedder = default_embedder()
-    query = serialize_vector(embedder(text))
+    await prepare_connection(store)
+    embedder = await asyncio.to_thread(default_embedder)
+    query = serialize_vector(await asyncio.to_thread(embedder, text))
     ranked: dict[str, list[tuple[float, str]]] = {}
-    for row in store.sql(
+    for row in await store.sql(
         "SELECT e.canonical_key AS ck, e.evidence_text AS ev, vec_distance_cosine(v.embedding, ?) AS dist "
         "FROM verdict_vectors v JOIN verdict_evidence e ON e.vector_id = v.vector_id "
         "WHERE e.prompt_version = ? ORDER BY dist",
@@ -302,7 +303,7 @@ def suggest_canonical_keys(store: FeedbackStore, text: str, *, prompt_version: i
     )[:k]
 
 
-def near_duplicate_keys(store: FeedbackStore, *, prompt_version: int, threshold: float) -> list[KeyOverlap]:
+async def near_duplicate_keys(store: FeedbackStore, *, prompt_version: int, threshold: float) -> list[KeyOverlap]:
     """Finds distinct canonical keys whose evidence centroids nearly coincide.
 
     Groups the evidence vectors recorded at ``prompt_version`` by canonical key,
@@ -326,9 +327,9 @@ def near_duplicate_keys(store: FeedbackStore, *, prompt_version: int, threshold:
     require_judge_extra()
     import numpy as np
 
-    prepare_connection(store)
+    await prepare_connection(store)
     groups: dict[str, list[np.ndarray]] = {}
-    for row in store.sql(
+    for row in await store.sql(
         "SELECT e.canonical_key AS ck, v.embedding AS emb "
         "FROM verdict_vectors v JOIN verdict_evidence e ON e.vector_id = v.vector_id "
         "WHERE e.prompt_version = ?",