cc-transcript 14.17.0__tar.gz → 14.19.0__tar.gz

{cc_transcript-14.17.0 → cc_transcript-14.19.0}/PKG-INFO

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

{cc_transcript-14.17.0 → cc_transcript-14.19.0}/cc_transcript/__init__.py

@@ -197,6 +197,7 @@ EXPORTS: dict[str, str] = {
             "Lifecycle",
         ),
         "cc_transcript.activity": (
+            "ActivityLift",
             "Edit",
             "SessionActivity",
             "ToolUse",

{cc_transcript-14.17.0 → cc_transcript-14.19.0}/cc_transcript/__init__.pyi

@@ -2,6 +2,7 @@
 # isort: off
 
 from cc_transcript.activity import (
+    ActivityLift as ActivityLift,
     Edit as Edit,
     SessionActivity as SessionActivity,
     ToolUse as ToolUse,
@@ -305,6 +306,7 @@ EXPORTS: dict[str, str]
 __all__ = [
     "ASSISTANTS",
     "Action",
+    "ActivityLift",
     "ApiError",
     "ApplyPatchCall",
     "AskUserQuestionResult",

{cc_transcript-14.17.0 → cc_transcript-14.19.0}/cc_transcript/_native.pyi

@@ -108,6 +108,7 @@ __all__ = [
     "activity_hunk_overlap",
     "activity_lift",
     "activity_lift_from_events",
+    "activity_lift_tail",
     "activity_overlap_between",
     "activity_parse_show_hunks",
     "bucket_events_from_events",
@@ -2295,6 +2296,8 @@ def activity_lift(path: builtins.str, max_events: builtins.int) -> dict[str, typ
 
 def activity_lift_from_events(events: list[models.TranscriptEvent], opener_flags: typing.Optional[typing.Sequence[builtins.bool]] = None) -> list[dict[str, typing.Any]]: ...
 
+def activity_lift_tail(events: list[models.TranscriptEvent], opener_flags: typing.Optional[typing.Sequence[builtins.bool]] = None, open_turn: builtins.bool = False) -> dict[str, typing.Any]: ...
+
 def activity_overlap_between(incorrect: typing.Sequence[tuple[builtins.str, builtins.str]], correction: typing.Sequence[tuple[builtins.str, builtins.str]]) -> builtins.float: ...
 
 def activity_parse_show_hunks(diff: builtins.str) -> builtins.list[tuple[builtins.str, builtins.str]]: ...

{cc_transcript-14.17.0 → cc_transcript-14.19.0}/cc_transcript/activity.py

@@ -13,8 +13,8 @@ products.
 from __future__ import annotations
 
 from collections.abc import Callable
-from dataclasses import dataclass
-from typing import TYPE_CHECKING
+from dataclasses import dataclass, replace
+from typing import TYPE_CHECKING, Any
 
 from cc_transcript import _native
 from cc_transcript.discovery import TranscriptExpiredError, resolve
@@ -25,7 +25,7 @@ from cc_transcript.parser import parse
 from cc_transcript.tools import edits_of, parse_tool_call, parse_tool_result
 
 if TYPE_CHECKING:
-    from collections.abc import Sequence
+    from collections.abc import Mapping, Sequence
     from datetime import datetime
     from pathlib import Path
 
@@ -181,64 +181,10 @@ class SessionActivity:
         turn; everything else folds into the current one. Events before the
         first qualifying prompt form turn 0 with prompt ``""``.
         """
-        evs = list(events)
-        opener_flags = (
-            None
-            if user_classifier is native_user_classifier
-            else [bool(user_classifier(event)) if isinstance(event, UserEvent) else False for event in evs]
+        return cls(
+            session_id=session_id,
+            turns=ActivityLift(session_id, user_classifier=user_classifier).extend(events).turns,
         )
-        tool_blocks = {
-            event_idx: tuple(block for block in event.blocks if isinstance(block, ToolUseBlock))
-            for event_idx, event in enumerate(evs)
-            if isinstance(event, AssistantEvent)
-        }
-        tool_block_positions: dict[int, int] = {}
-        turns: list[Turn] = []
-        for index, skeleton in enumerate(_native.activity_lift_from_events(evs, opener_flags)):
-            tool_uses: list[ToolUse] = []
-            for use in skeleton["tool_uses"]:
-                event_idx = use["event_idx"]
-                event = evs[event_idx]
-                block_position = tool_block_positions.get(event_idx, 0)
-                block = tool_blocks[event_idx][block_position]
-                tool_block_positions[event_idx] = block_position + 1
-                result_event_idx = use["result_event_idx"]
-                if result_event_idx is None:
-                    result = None
-                    result_ts = None
-                else:
-                    result_event = evs[result_event_idx]
-                    result = next(
-                        candidate
-                        for candidate in reversed(result_event.blocks)
-                        if isinstance(candidate, ToolResultBlock) and candidate.tool_use_id == use["tool_use_id"]
-                    )
-                    result_ts = result_event.meta.timestamp
-                call = parse_tool_call(block.name, block.input, on_error="other")
-                tool_uses.append(
-                    ToolUse(
-                        ref=EventRef(session_id, event.meta.uuid, block.id),
-                        call=call,
-                        result=result,
-                        result_ts=result_ts,
-                        edits=edits_of(call),
-                        turn_index=index,
-                        ts=event.meta.timestamp,
-                    )
-                )
-            started_idx = skeleton["started_idx"]
-            ended_idx = skeleton["ended_idx"]
-            turns.append(
-                Turn(
-                    index=index,
-                    prompt=skeleton["prompt"],
-                    started_at=None if started_idx is None else evs[started_idx].meta.timestamp,
-                    ended_at=None if ended_idx is None else evs[ended_idx].meta.timestamp,
-                    events=tuple(evs[skeleton["start"] : skeleton["end"]]),
-                    tool_uses=tuple(tool_uses),
-                )
-            )
-        return cls(session_id=session_id, turns=tuple(turns))
 
     @classmethod
     def from_session(
@@ -326,6 +272,176 @@ class SessionActivity:
         return tuple(same_turn + later)
 
 
+class ActivityLift:
+    """A session's lift that grows with its transcript.
+
+    Each :meth:`extend` folds the events appended since the previous call into
+    the activity lifted so far: closed turns are kept, the open turn grows by
+    the appended events alone, and a tool use whose result arrives in the tail
+    is re-paired wherever it sits. The result always equals
+    :meth:`SessionActivity.from_events` over every event fed so far. A step
+    costs the appended events, the tool uses they re-pair, and copies of the
+    turn tuple and of the open turn's event and tool-use tuples; it never
+    re-derives the session.
+
+    Feed only the events appended since the previous call: nothing checks
+    provenance, so events fed twice lift twice. The contract is append-only:
+    a cursor's transcript is assumed never rewritten behind the events it has
+    been fed, and a transcript rewritten in place, rather than appended to,
+    needs a new cursor. Claude Code and Codex transcripts satisfy it.
+
+    The classifier is read once, at construction, and must be deterministic
+    and event-only: its answer for an event has to stay the same as later
+    events are appended, since turns lifted under it are never revisited.
+
+    Example:
+        >>> lift = ActivityLift(session_id)
+        >>> activity = lift.extend(events)
+        >>> lift.extend(appended) == SessionActivity.from_events(session_id, [*events, *appended])
+        True
+    """
+
+    __slots__ = ("_activity", "_results", "_session_id", "_user_classifier", "_uses")
+
+    def __init__(self, session_id: SessionId, *, user_classifier: UserClassifier = native_user_classifier) -> None:
+        self._session_id = session_id
+        self._user_classifier = user_classifier
+        self._activity = SessionActivity(session_id=session_id, turns=())
+        self._uses: dict[ToolUseId, tuple[tuple[int, int], ...]] = {}
+        self._results: dict[ToolUseId, UserEvent] = {}
+
+    @property
+    def session_id(self) -> SessionId:
+        """The session being lifted."""
+        return self._session_id
+
+    @property
+    def user_classifier(self) -> UserClassifier:
+        """Decides which user events open turns."""
+        return self._user_classifier
+
+    @property
+    def activity(self) -> SessionActivity:
+        """Everything lifted so far."""
+        return self._activity
+
+    def extend(self, events: Sequence[TranscriptEvent]) -> SessionActivity:
+        """Lifts ``events``, appended after everything fed so far, into :attr:`activity`."""
+        tail = list(events)
+        if not tail:
+            return self._activity
+        opener_flags = (
+            None
+            if self._user_classifier is native_user_classifier
+            else [bool(self._user_classifier(event)) if isinstance(event, UserEvent) else False for event in tail]
+        )
+        turns = list(self._activity.turns)
+        lifted = _native.activity_lift_tail(tail, opener_flags, open_turn=bool(turns))
+        first = len(turns) - 1 if lifted["continued"] else len(turns)
+        grown = [
+            lift_turn(self._session_id, first + offset, skeleton, tail, self._results)
+            for offset, skeleton in enumerate(lifted["turns"])
+        ]
+        if lifted["continued"]:
+            turns[-1] = continued(turns[-1], grown[0])
+            turns.extend(grown[1:])
+        else:
+            turns.extend(grown)
+        repairs: dict[int, dict[int, UserEvent]] = {}
+        for tool_use_id, result_idx in lifted["results"]:
+            for turn_index, position in self._uses.get(tool_use_id, ()):
+                repairs.setdefault(turn_index, {})[position] = tail[result_idx]
+            self._results[tool_use_id] = tail[result_idx]
+        for turn_index, at in repairs.items():
+            turns[turn_index] = repaired(turns[turn_index], at)
+        for turn in grown:
+            base = len(turns[turn.index].tool_uses) - len(turn.tool_uses)
+            for position, use in enumerate(turn.tool_uses, base):
+                self._uses[use.ref.tool_use_id] = (*self._uses.get(use.ref.tool_use_id, ()), (turn.index, position))
+        self._activity = SessionActivity(session_id=self._session_id, turns=tuple(turns))
+        return self._activity
+
+
+def lift_turn(
+    session_id: SessionId,
+    index: int,
+    skeleton: dict[str, Any],
+    evs: Sequence[TranscriptEvent],
+    prior_results: Mapping[ToolUseId, UserEvent],
+) -> Turn:
+    events = tuple(evs[skeleton["start"] : skeleton["end"]])
+    calls = [
+        (event, block)
+        for event in events
+        if isinstance(event, AssistantEvent)
+        for block in event.blocks
+        if isinstance(block, ToolUseBlock)
+    ]
+    started_idx = skeleton["started_idx"]
+    ended_idx = skeleton["ended_idx"]
+    return Turn(
+        index=index,
+        prompt=skeleton["prompt"],
+        started_at=None if started_idx is None else evs[started_idx].meta.timestamp,
+        ended_at=None if ended_idx is None else evs[ended_idx].meta.timestamp,
+        events=events,
+        tool_uses=tuple(
+            lift_tool_use(
+                session_id,
+                index,
+                event,
+                block,
+                prior_results.get(block.id) if (result_idx := use["result_event_idx"]) is None else evs[result_idx],
+            )
+            for (event, block), use in zip(calls, skeleton["tool_uses"], strict=True)
+        ),
+    )
+
+
+def lift_tool_use(
+    session_id: SessionId, turn_index: int, event: AssistantEvent, block: ToolUseBlock, result_event: UserEvent | None
+) -> ToolUse:
+    call = parse_tool_call(block.name, block.input, on_error="other")
+    return ToolUse(
+        ref=EventRef(session_id, event.meta.uuid, block.id),
+        call=call,
+        result=None if result_event is None else result_block(result_event, block.id),
+        result_ts=None if result_event is None else result_event.meta.timestamp,
+        edits=edits_of(call),
+        turn_index=turn_index,
+        ts=event.meta.timestamp,
+    )
+
+
+def result_block(event: UserEvent, tool_use_id: ToolUseId) -> ToolResultBlock:
+    return next(
+        candidate
+        for candidate in reversed(event.blocks)
+        if isinstance(candidate, ToolResultBlock) and candidate.tool_use_id == tool_use_id
+    )
+
+
+def continued(turn: Turn, tail: Turn) -> Turn:
+    return replace(
+        turn,
+        started_at=tail.started_at if turn.started_at is None else turn.started_at,
+        ended_at=turn.ended_at if tail.ended_at is None else tail.ended_at,
+        events=turn.events + tail.events,
+        tool_uses=turn.tool_uses + tail.tool_uses,
+    )
+
+
+def repaired(turn: Turn, at: Mapping[int, UserEvent]) -> Turn:
+    uses = list(turn.tool_uses)
+    for position, event in at.items():
+        uses[position] = replace(
+            uses[position],
+            result=result_block(event, uses[position].ref.tool_use_id),
+            result_ts=event.meta.timestamp,
+        )
+    return replace(turn, tool_uses=tuple(uses))
+
+
 def hunk_overlap(a: Hunk, b: Hunk) -> float:
     """The fraction of ``a.new``'s non-empty lines present in ``b.old``.