cc-transcript 14.8.0__tar.gz → 14.10.0__tar.gz

{cc_transcript-14.8.0 → cc_transcript-14.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-transcript
-Version: 14.8.0
+Version: 14.10.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -120,6 +120,14 @@ print(len(transcript.events), "events after the noise drop")
 
 `discover()` lists every transcript on disk newest first, `stream` fans a whole corpus across the parse pool, and `resolve` finds one session by UUID. `parse` also reads OpenAI Codex CLI rollouts — hand it a path from `~/.codex/sessions` and the same typed events come back. The [getting-started guide](https://yasyf.github.io/cc-transcript/docs/getting-started/index.html) builds this out to a composed filter and a sentiment score.
 
+## JSON output schema
+
+`show --json` and `grep --json` emit JSONL, with one object per event. Each event
+uses the envelope `{i, kind, meta, model, text, blocks, stop_reason, usage}`;
+fields that do not apply to its kind are omitted. Every object in `blocks` has
+a `type` discriminator such as `text`, `thinking`, `tool_use`, `tool_result`,
+or `fallback`.
+
 ## More in the docs
 
 - [The Python library](https://yasyf.github.io/cc-transcript/docs/getting-started/index.html) turns a transcript into typed lazy views, a composed filter, and a score in a dozen lines.

{cc_transcript-14.8.0 → cc_transcript-14.10.0}/README.md

@@ -84,6 +84,14 @@ print(len(transcript.events), "events after the noise drop")
 
 `discover()` lists every transcript on disk newest first, `stream` fans a whole corpus across the parse pool, and `resolve` finds one session by UUID. `parse` also reads OpenAI Codex CLI rollouts — hand it a path from `~/.codex/sessions` and the same typed events come back. The [getting-started guide](https://yasyf.github.io/cc-transcript/docs/getting-started/index.html) builds this out to a composed filter and a sentiment score.
 
+## JSON output schema
+
+`show --json` and `grep --json` emit JSONL, with one object per event. Each event
+uses the envelope `{i, kind, meta, model, text, blocks, stop_reason, usage}`;
+fields that do not apply to its kind are omitted. Every object in `blocks` has
+a `type` discriminator such as `text`, `thinking`, `tool_use`, `tool_result`,
+or `fallback`.
+
 ## More in the docs
 
 - [The Python library](https://yasyf.github.io/cc-transcript/docs/getting-started/index.html) turns a transcript into typed lazy views, a composed filter, and a score in a dozen lines.

{cc_transcript-14.8.0 → cc_transcript-14.10.0}/cc_transcript/__init__.py

@@ -109,6 +109,7 @@ EXPORTS: dict[str, str] = {
             "CcVersion",
             "CompactBoundary",
             "ContentBlock",
+            "DeferredToolsDelta",
             "EntryMeta",
             "EventList",
             "FallbackBlock",
@@ -235,7 +236,15 @@ EXPORTS: dict[str, str] = {
         ),
         "cc_transcript.render": ("Budget", "render_session", "render_tool_call", "render_turn"),
         "cc_transcript.notifications": ("Notifications",),
-        "cc_transcript.query": ("FileRef", "Session", "SubagentIndex", "SubagentSession", "ToolCallQuery"),
+        "cc_transcript.query": (
+            "DeepSession",
+            "DeepView",
+            "FileRef",
+            "Session",
+            "SubagentIndex",
+            "SubagentSession",
+            "ToolCallQuery",
+        ),
         "cc_transcript.decisions": ("DECISIONS_DDL", "Action", "Decision", "DecisionLog"),
         "cc_transcript.disktruth": (
             "AttributionRange",

{cc_transcript-14.8.0 → cc_transcript-14.10.0}/cc_transcript/__init__.pyi

@@ -147,6 +147,7 @@ from cc_transcript.models import (
     CcVersion as CcVersion,
     CompactBoundary as CompactBoundary,
     ContentBlock as ContentBlock,
+    DeferredToolsDelta as DeferredToolsDelta,
     EntryMeta as EntryMeta,
     EventList as EventList,
     FallbackBlock as FallbackBlock,
@@ -203,6 +204,8 @@ from cc_transcript.parser import (
 )
 
 from cc_transcript.query import (
+    DeepSession as DeepSession,
+    DeepView as DeepView,
     FileRef as FileRef,
     Session as Session,
     SubagentIndex as SubagentIndex,
@@ -335,6 +338,9 @@ __all__ = [
     "DECISIONS_DDL",
     "Decision",
     "DecisionLog",
+    "DeepSession",
+    "DeepView",
+    "DeferredToolsDelta",
     "DiskTruth",
     "Edit",
     "EditCall",

{cc_transcript-14.8.0 → cc_transcript-14.10.0}/cc_transcript/_native.pyi

@@ -28,6 +28,7 @@ __all__ = [
     "CommandLine",
     "CommandLineQuery",
     "CompactBoundary",
+    "DeferredToolsDelta",
     "EditCall",
     "EditResult",
     "EditSpan",
@@ -588,6 +589,27 @@ class CompactBoundary:
     @property
     def precomputed(self) -> typing.Optional[builtins.bool]: ...
 
+@typing.final
+class DeferredToolsDelta(OtherAttachment):
+    r"""
+    Tools added to and removed from the deferred tool inventory.
+
+    Attributes:
+        added_count: Number of added tools.
+        removed_count: Number of removed tools.
+        added_names: Added tool names, in transcript order.
+        removed_names: Removed tool names, in transcript order.
+    """
+    __match_args__: typing.ClassVar[tuple[str, ...]]
+    @property
+    def added_count(self) -> builtins.int: ...
+    @property
+    def removed_count(self) -> builtins.int: ...
+    @property
+    def added_names(self) -> tuple[str, ...]: ...
+    @property
+    def removed_names(self) -> tuple[str, ...]: ...
+
 @typing.final
 class EditCall(ToolCallBase):
     r"""
@@ -1163,7 +1185,6 @@ class Occurrence:
         One shell-word spelling of ``text`` that survives every enclosing layer, or None.
         """
 
-@typing.final
 class OtherAttachment:
     r"""
     Any attachment whose type has no typed detail, carried verbatim.

{cc_transcript-14.8.0 → cc_transcript-14.10.0}/cc_transcript/facts.py

@@ -33,6 +33,7 @@ class ToolFact:
         ts: The timestamp of the assistant entry that made the call, or None.
         session_id: The Claude session the call belongs to.
         path: The transcript file the call was lifted from.
+        cwd: The working directory recorded on the originating event, or None.
         tool_use_id: The tool-use block id — the join key back to the event stream.
         tool: The tool name exactly as invoked.
         command_prefixes: The permission-style prefixes of each Bash command
@@ -42,6 +43,8 @@ class ToolFact:
         mcp_tool: The MCP tool segment for an ``mcp__server__tool`` call, else None.
         mcp_access: Whether the MCP tool reads or writes, else None.
         file_path: The file the call targets, when it targets one.
+        file_paths: Every file the call touches, apply_patch multi-file included;
+            ``file_path`` mirrors the first entry.
         is_error: Whether the call's result reported a failure.
         denied: Whether the result is a user rejection of the tool use.
         denial_kind: The structured tool-denial kind (``user-rejected`` for a human
@@ -53,6 +56,7 @@ class ToolFact:
     ts: datetime | None
     session_id: SessionId
     path: Path
+    cwd: str | None
     tool_use_id: ToolUseId
     tool: str
     command_prefixes: tuple[str, ...]
@@ -61,6 +65,7 @@ class ToolFact:
     mcp_tool: str | None
     mcp_access: Literal["read", "write"] | None
     file_path: str | None
+    file_paths: tuple[str, ...]
     is_error: bool
     denied: bool
     denial_kind: str | None
@@ -73,6 +78,7 @@ def rehydrate_fact(fact: Mapping[str, Any], path: Path) -> ToolFact:
         ts=datetime.fromisoformat(fact["ts"]),
         session_id=SessionId(fact["session_id"]),
         path=path,
+        cwd=fact["cwd"],
         tool_use_id=ToolUseId(fact["tool_use_id"]),
         tool=fact["tool"],
         command_prefixes=tuple(fact["command_prefixes"]),
@@ -81,6 +87,7 @@ def rehydrate_fact(fact: Mapping[str, Any], path: Path) -> ToolFact:
         mcp_tool=fact["mcp_tool"],
         mcp_access=fact["mcp_access"],
         file_path=fact["file_path"],
+        file_paths=tuple(fact["file_paths"]),
         is_error=fact["is_error"],
         denied=fact["denied"],
         denial_kind=fact["denial_kind"],

{cc_transcript-14.8.0 → cc_transcript-14.10.0}/cc_transcript/models.py

@@ -17,6 +17,7 @@ from cc_transcript._native import AttachmentEvent as AttachmentEvent
 from cc_transcript._native import Attribution as Attribution
 from cc_transcript._native import CacheCreation as CacheCreation
 from cc_transcript._native import CompactBoundary as CompactBoundary
+from cc_transcript._native import DeferredToolsDelta as DeferredToolsDelta
 from cc_transcript._native import EntryMeta as EntryMeta
 from cc_transcript._native import EventList as EventList
 from cc_transcript._native import FallbackBlock as FallbackBlock
@@ -121,6 +122,7 @@ AttachmentDetail = (
     | HookAdditionalContext
     | AsyncHookResponse
     | QueuedCommand
+    | DeferredToolsDelta
     | OtherAttachment
 )
 

{cc_transcript-14.8.0 → cc_transcript-14.10.0}/cc_transcript/query.py

@@ -14,13 +14,14 @@ import re
 from collections.abc import Mapping
 from dataclasses import dataclass
 from fnmatch import fnmatch
+from functools import cached_property
 from pathlib import PurePath
 from typing import TYPE_CHECKING, ClassVar
 
 from cc_transcript.activity import SessionActivity, Turn, event_stamps, native_user_classifier
 from cc_transcript.discovery import TranscriptExpiredError, resolve, subagent_paths, subagent_transcripts
 from cc_transcript.filterspec import event_meta, session_id_of
-from cc_transcript.ids import SessionId
+from cc_transcript.ids import SessionId, ToolUseId
 from cc_transcript.models import AssistantEvent, SystemEvent, ToolResultBlock, UserEvent
 from cc_transcript.notifications import Notifications
 from cc_transcript.parser import parse
@@ -41,7 +42,7 @@ if TYPE_CHECKING:
 
     from cc_transcript.activity import ToolUse, UserClassifier
     from cc_transcript.command import CommandLine
-    from cc_transcript.ids import EventUuid, ToolUseId
+    from cc_transcript.ids import EventUuid
     from cc_transcript.models import TranscriptEvent
 
 
@@ -246,6 +247,9 @@ class Session:
         turns: The turns in the window.
         path: The transcript file the session was loaded from, when known —
             required for sidechain (subagent) lookups.
+        attachments: External transcript files (e.g. codex rollouts) registered
+            with this session; :meth:`walk` and :attr:`deep` fold them in at
+            depth 1. Empty for a session loaded straight from disk.
 
     Example:
         >>> session.prior().after(tool="Write", file=str(fp)).has_tool("ExitPlanMode")
@@ -253,11 +257,14 @@ class Session:
 
     turns: tuple[Turn, ...]
     path: Path | None = None
+    attachments: tuple[Path, ...] = ()
 
     @classmethod
-    def from_activity(cls, activity: SessionActivity, *, path: Path | None = None) -> Session:
+    def from_activity(
+        cls, activity: SessionActivity, *, path: Path | None = None, attachments: tuple[Path, ...] = ()
+    ) -> Session:
         """Views ``activity``'s full turn range as a session."""
-        return cls(activity.turns, path)
+        return cls(activity.turns, path, attachments)
 
     @classmethod
     def from_path(cls, path: Path, *, user_classifier: UserClassifier = native_user_classifier) -> Session:
@@ -326,6 +333,25 @@ class Session:
             )
         )
 
+    def walk(self) -> Iterator[DeepSession]:
+        """Every transcript reachable from this session, lazily and depth-first.
+
+        Yields each descendant sidechain (subagent/teammate) transcript at every
+        depth in DFS path order, then each registered attachment at depth 1 —
+        never this session itself. A resolved-path seen-set (seeded with
+        :attr:`path`) dedupes: the first occurrence of a path wins, so a
+        tree-discovered sidechain outranks an equal attachment, and symlink
+        cycles terminate. An unreadable transcript is skipped but its children
+        are still walked; a structurally malformed line raises, as
+        :attr:`subagents` does.
+        """
+        return deep_sessions(self)
+
+    @property
+    def deep(self) -> DeepView:
+        """The recursive union view over this session and every transcript it reaches."""
+        return DeepView(self)
+
     def after(self, *, tool: str, file: str | None = None) -> Session:
         """The window strictly after the last call matching ``tool``.
 
@@ -369,7 +395,7 @@ class Session:
     @property
     def current_turn(self) -> Session:
         """The one-turn view of the window's last turn."""
-        return Session(self.turns[-1:], self.path)
+        return Session(self.turns[-1:], self.path, self.attachments)
 
     @property
     def user_text(self) -> str:
@@ -394,7 +420,7 @@ class Session:
     def has_tool(self, name: str, *, subagents: bool = True) -> bool:
         """Whether any call in the window matches the pipe spec ``name``."""
         return self.tool_calls.named(name).any() or (
-            subagents and any(sub.has_tool(name) for sub in sidechain_sessions(self.path))
+            subagents and any(deep.session.has_tool(name, subagents=False) for deep in self.walk())
         )
 
     def has_command(self, *argv: str, subagents: bool = True) -> bool:
@@ -405,19 +431,19 @@ class Session:
         ``sudo git push -f`` and ``cd x && git push`` but not ``echo "git push"``.
         """
         return any(cmd.runs(*argv) for line in self.command_lines() for cmd in line) or (
-            subagents and any(sub.has_command(*argv) for sub in sidechain_sessions(self.path))
+            subagents and any(deep.session.has_command(*argv, subagents=False) for deep in self.walk())
         )
 
     def has_edit_to(self, *globs: str, subagents: bool = True) -> bool:
         """Whether any edit-shaped call in the window targets a file matching any glob."""
         return any(file.matches(*globs) for file in self.edited_files) or (
-            subagents and any(sub.has_edit_to(*globs) for sub in sidechain_sessions(self.path))
+            subagents and any(deep.session.has_edit_to(*globs, subagents=False) for deep in self.walk())
         )
 
     def has_read(self, pattern: str, *, subagents: bool = True) -> bool:
         """Whether any Read in the window targets a path containing ``pattern``."""
         return any(pattern in str(file) for file in self.tool_calls.named("Read").files()) or (
-            subagents and any(sub.has_read(pattern) for sub in sidechain_sessions(self.path))
+            subagents and any(deep.session.has_read(pattern, subagents=False) for deep in self.walk())
         )
 
     def has_skill(self, *names: str, subagents: bool = True) -> bool:
@@ -425,7 +451,7 @@ class Session:
         return any(
             isinstance(call := use.call, SkillCall) and call.skill in names
             for use in self.tool_calls.named("Skill")
-        ) or (subagents and any(sub.has_skill(*names) for sub in sidechain_sessions(self.path)))
+        ) or (subagents and any(deep.session.has_skill(*names, subagents=False) for deep in self.walk()))
 
     def has_override(self, token: str, *, invalidated_by: Sequence[str] = ("Edit", "Write")) -> bool:
         """Whether ``token`` appears in the window without a later invalidating call.
@@ -530,6 +556,69 @@ class SubagentIndex:
         return bool(self.items)
 
 
+@dataclass(frozen=True, slots=True)
+class DeepSession:
+    """One transcript reached by :meth:`Session.walk`.
+
+    Attributes:
+        session: The whole-session view of the reached transcript.
+        path: The transcript file it was loaded from.
+        provider: Its source provider, ``"claude"`` or ``"codex"``.
+        depth: Distance from the root; ``1`` is a direct sidechain or attachment.
+        spawned_by: The dispatching tool-use id parsed from an ``agent-<id>``
+            sidechain stem, or None for an attachment.
+    """
+
+    session: Session
+    path: Path
+    provider: str
+    depth: int
+    spawned_by: ToolUseId | None
+
+
+@dataclass(frozen=True)  # non-slots: the cached_property below needs __dict__
+class DeepView:
+    """The recursive union of a session and every transcript reachable from it.
+
+    Sidechain (subagent/teammate) transcripts at every depth and registered
+    attachments contribute their tool calls and events to one window-spanning
+    view. The root axis respects the session's window; descendants and
+    attachments are window-invariant, mirroring how ``has_tool`` already scans
+    the whole sidechain tree.
+
+    Example:
+        >>> session.deep.tool_calls.named("Edit|Write").files()
+    """
+
+    root: Session
+
+    @cached_property
+    def sessions(self) -> tuple[DeepSession, ...]:
+        """Every reached :class:`DeepSession`, materialized once: DFS, then attachments."""
+        return tuple(self.root.walk())
+
+    @property
+    def tool_calls(self) -> ToolCallQuery:
+        """The root window's calls, then every descendant's and attachment's calls.
+
+        Positional, not chronological: root-window order, then DFS path order,
+        then attachment registration order — so :meth:`ToolCallQuery.first` and
+        :meth:`ToolCallQuery.last` read positionally.
+        """
+        return ToolCallQuery(
+            self.root.tool_calls.all_items
+            + tuple(use for deep in self.sessions for use in deep.session.tool_calls.all_items)
+        )
+
+    @property
+    def events(self) -> tuple[TranscriptEvent, ...]:
+        """Every event across the root window and every reached transcript, in walk order."""
+        return self.root.events + tuple(event for deep in self.sessions for event in deep.session.events)
+
+    def __iter__(self) -> Iterator[DeepSession]:
+        return iter(self.sessions)
+
+
 def windowed(session: Session, start: int, stop: int) -> Session:
     turns: list[Turn] = []
     base = 0
@@ -539,10 +628,47 @@ def windowed(session: Session, start: int, stop: int) -> Session:
         if lo < hi:
             turns.append(turn if (lo, hi) == (0, size) else trim_turn(turn, lo, hi))
         base += size
-    return Session(tuple(turns), session.path)
+    return Session(tuple(turns), session.path, session.attachments)
 
 
 def sidechain_sessions(path: Path | None) -> tuple[Session, ...]:
     if path is None:
         return ()
     return tuple(Session.from_path(entry) for entry in subagent_paths(path))
+
+
+def deep_sessions(root: Session) -> Iterator[DeepSession]:
+    seen: set[Path] = {root.path.resolve()} if root.path is not None else set()
+    if root.path is not None:
+        yield from descend_sidechains(root.path, 1, seen)
+    for attachment in root.attachments:
+        yield from visit_transcript(attachment, 1, None, seen)
+
+
+def descend_sidechains(parent: Path, depth: int, seen: set[Path]) -> Iterator[DeepSession]:
+    for child in subagent_paths(parent):
+        yield from visit_transcript(child, depth, ToolUseId(child.stem.removeprefix("agent-")), seen)
+
+
+def visit_transcript(path: Path, depth: int, spawned_by: ToolUseId | None, seen: set[Path]) -> Iterator[DeepSession]:
+    if (resolved := path.resolve()) in seen:
+        return
+    seen.add(resolved)
+    if (deep := load_deep_session(path, depth, spawned_by)) is not None:
+        yield deep
+    yield from descend_sidechains(path, depth + 1, seen)
+
+
+def load_deep_session(path: Path, depth: int, spawned_by: ToolUseId | None) -> DeepSession | None:
+    try:
+        transcript = parse(path)
+    except OSError:
+        return None
+    session_id = session_id_of(transcript.events) or SessionId(path.stem)
+    return DeepSession(
+        session=Session.from_activity(SessionActivity.from_events(session_id, transcript.events), path=path),
+        path=path,
+        provider=transcript.provider,
+        depth=depth,
+        spawned_by=spawned_by,
+    )

{cc_transcript-14.8.0 → cc_transcript-14.10.0}/cc_transcript/render.py

@@ -40,7 +40,7 @@ def render_tool_call(call: ToolCall | FallbackCall, *, budget: Budget) -> str:
     The single tool-input renderer: Edit renders the path plus ``- old`` /
     ``+ new`` lines, MultiEdit renders every span under an ``edit i/n``
     marker, Write renders the path plus content, Bash renders the command,
-    and everything else renders a compact ``name(primary-arg)`` line.
+    and everything else renders the tool name with its full compact-JSON input.
 
     Example:
         >>> render_tool_call(parse_tool_call("Bash", {"command": "ls"}), budget=Budget())

{cc_transcript-14.8.0 → cc_transcript-14.10.0}/cc_transcript/tools.py

@@ -74,6 +74,7 @@ if TYPE_CHECKING:
 
 TOOL_ALIASES: dict[str, str] = {
     "Bash": "Execute",
+    "Edit": "apply_patch",
     "Write": "Create",
     "Agent": "Task",
     "WebFetch": "FetchUrl",

{cc_transcript-14.8.0 → cc_transcript-14.10.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cc-transcript"
-version = "14.8.0" # informational — releases stamp the version from the git tag
+version = "14.10.0" # informational — releases stamp the version from the git tag
 description = "Grep every Claude Code session you've ever run."
 readme = "README.md"
 license = "PolyForm-Noncommercial-1.0.0"