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

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

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

{cc_transcript-14.5.0 → cc_transcript-14.6.1}/cc_transcript/__init__.py

@@ -87,6 +87,7 @@ EXPORTS: dict[str, str] = {
             "CommandLineQuery",
             "Occurrence",
             "Redirect",
+            "Word",
             "command_prefixes",
             "parse_command_line",
         ),
@@ -180,6 +181,13 @@ EXPORTS: dict[str, str] = {
             "resolve",
             "subagent_paths",
         ),
+        "cc_transcript.codex": (
+            "CodexPendingItem",
+            "CodexRollout",
+            "CodexSessionInfo",
+            "CodexUsage",
+            "Lifecycle",
+        ),
         "cc_transcript.activity": (
             "Edit",
             "SessionActivity",

{cc_transcript-14.5.0 → cc_transcript-14.6.1}/cc_transcript/__init__.pyi

@@ -27,12 +27,21 @@ from cc_transcript.builders import (
     keep_only as keep_only,
 )
 
+from cc_transcript.codex import (
+    CodexPendingItem as CodexPendingItem,
+    CodexRollout as CodexRollout,
+    CodexSessionInfo as CodexSessionInfo,
+    CodexUsage as CodexUsage,
+    Lifecycle as Lifecycle,
+)
+
 from cc_transcript.command import (
     Command as Command,
     CommandLine as CommandLine,
     CommandLineQuery as CommandLineQuery,
     Occurrence as Occurrence,
     Redirect as Redirect,
+    Word as Word,
     command_prefixes as command_prefixes,
     parse_command_line as parse_command_line,
 )
@@ -301,6 +310,10 @@ __all__ = [
     "CacheCreation",
     "CandidatePair",
     "CcVersion",
+    "CodexPendingItem",
+    "CodexRollout",
+    "CodexSessionInfo",
+    "CodexUsage",
     "Command",
     "CommandLine",
     "CommandLineQuery",
@@ -341,6 +354,7 @@ __all__ = [
     "HydratedWindow",
     "InitInfo",
     "JUNK_USER_MESSAGE_RE",
+    "Lifecycle",
     "McpServer",
     "ModeEvent",
     "ModelPricing",
@@ -421,6 +435,7 @@ __all__ = [
     "UserEvent",
     "WatchEvent",
     "Watcher",
+    "Word",
     "WorkflowCall",
     "WriteCall",
     "WriteResult",

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

@@ -95,6 +95,7 @@ __all__ = [
     "Usage",
     "UserEvent",
     "WatchTailer",
+    "Word",
     "WorkflowCall",
     "WriteCall",
     "WriteResult",
@@ -103,6 +104,9 @@ __all__ = [
     "activity_lift_from_events",
     "bucket_events_from_events",
     "cli_main",
+    "codex_discover",
+    "codex_resolve",
+    "codex_session_info",
     "command_parse",
     "command_prefixes",
     "context_capture_window",
@@ -411,6 +415,11 @@ class Command:
     @property
     def span(self) -> typing.Optional[tuple[builtins.int, builtins.int]]: ...
     @property
+    def words(self) -> tuple[Word, ...]:
+        r"""
+        The structural words: ``words[0]`` is the executable, ``words[1:]`` parallel ``args``.
+        """
+    @property
     def argv(self) -> tuple[str, ...]: ...
     @property
     def program(self) -> builtins.str: ...
@@ -470,6 +479,11 @@ class CommandLine:
     def parse(cls, raw: builtins.str) -> CommandLine: ...
     @staticmethod
     def dequote(text: builtins.str) -> builtins.str: ...
+    @staticmethod
+    def quote(text: builtins.str) -> builtins.str:
+        r"""
+        Quote ``text`` as one POSIX-sh word, with Python ``shlex.quote`` semantics.
+        """
     def splice(self, replacements: typing.Mapping[builtins.int, builtins.str]) -> builtins.str: ...
     def rewrite_occurrences(self, to: collections.abc.Callable[[Occurrence], str | None]) -> typing.Optional[builtins.str]: ...
     def __iter__(self) -> collections.abc.Iterator[Command]: ...
@@ -1087,7 +1101,30 @@ class Occurrence:
     def next_op(self) -> typing.Optional[builtins.str]: ...
     @property
     def piped(self) -> builtins.bool: ...
+    @property
+    def nesting(self) -> builtins.int:
+        r"""
+        Substitution/payload hops below top level; 0 for a top-level command.
+        """
+    @property
+    def host(self) -> Occurrence | None:
+        r"""
+        The occurrence hosting this nested part, or None at top level.
+        """
+    @property
+    def quote_contexts(self) -> tuple[str, ...]:
+        r"""
+        Enclosing payload quote layers outermost-first: ``"'"``, ``'"'``, or ``""`` (bare).
+        """
     def __new__(cls, line: CommandLine, index: builtins.int) -> Occurrence: ...
+    def embeddable(self, text: builtins.str) -> builtins.bool:
+        r"""
+        Whether splicing ``text`` at this occurrence survives every enclosing quote layer.
+        """
+    def quote_for(self, text: builtins.str) -> typing.Optional[builtins.str]:
+        r"""
+        One shell-word spelling of ``text`` that survives every enclosing layer, or None.
+        """
 
 @typing.final
 class OtherAttachment:
@@ -1907,15 +1944,14 @@ class Transcript:
     The parsed events of a single transcript file, backed by the native parse
     output; ``events`` materializes lazy views on access.
 
-    One parse owns one ``Arc<Vec<Entry>>`` that every event and nested view shares,
-    so retaining any single view keeps that whole parse's entries alive; keeping one
-    event from each of several parses retains all of their entries. The live
-    :class:`~watch.WatchEvent` stream is exempt — its tailer builds a
-    one-entry Arc per yielded event, so a held watch event pins only itself.
+    One parse owns one ``Arc<Vec<Entry>>`` shared by every view, so retaining any
+    view keeps the whole parse's entries alive; the live
+    :class:`~watch.WatchEvent` stream is exempt (one-entry Arc each).
 
     Attributes:
         path: The transcript's path on disk; None for a bytes parse.
         mtime: The transcript's modification time when parsed.
+        provider: The transcript's source provider: "claude" or "codex".
         events: The parsed events, in file order.
     """
     @property
@@ -1923,6 +1959,8 @@ class Transcript:
     @property
     def mtime(self) -> builtins.float: ...
     @property
+    def provider(self) -> typing.Literal["claude", "codex"]: ...
+    @property
     def events(self) -> EventList: ...
 
 @typing.final
@@ -2063,6 +2101,27 @@ class WatchTailer:
         size, mtime, session_id, seen}}}`, the Python `TailState` projection.
         """
 
+@typing.final
+class Word:
+    r"""
+    One structural word of a parsed command (``Command.words``).
+    Attributes:
+        raw: verbatim source text.
+        value: literal with quotes/escapes removed; None when an expansion taints it.
+        span: byte span in the owning ``CommandLine.raw``; None without verbatim source.
+        expandable: bash would glob/brace/tilde-expand despite the literal value.
+    """
+    __match_args__: typing.ClassVar[tuple[str, ...]]
+    @property
+    def raw(self) -> builtins.str: ...
+    @property
+    def value(self) -> typing.Optional[builtins.str]: ...
+    @property
+    def span(self) -> typing.Optional[tuple[builtins.int, builtins.int]]: ...
+    @property
+    def expandable(self) -> builtins.bool: ...
+    def __new__(cls, raw: builtins.str, value: typing.Optional[builtins.str] = None, span: typing.Optional[tuple[builtins.int, builtins.int]] = None, expandable: builtins.bool = False) -> Word: ...
+
 @typing.final
 class WorkflowCall(ToolCallBase):
     r"""
@@ -2138,6 +2197,12 @@ def cli_main() -> builtins.int:
     run, and the exit code returned verbatim for the wrapper's `sys.exit`.
     """
 
+def codex_discover(root: typing.Optional[builtins.str | os.PathLike | pathlib.Path] = None) -> builtins.list[tuple[pathlib.Path, builtins.str, builtins.bool]]: ...
+
+def codex_resolve(session_id: builtins.str, root: typing.Optional[builtins.str | os.PathLike | pathlib.Path] = None) -> typing.Optional[pathlib.Path]: ...
+
+def codex_session_info(path: builtins.str) -> dict[str, typing.Any]: ...
+
 def command_parse(command: builtins.str) -> dict[str, typing.Any]: ...
 
 def command_prefixes(commands: typing.Sequence[builtins.str]) -> builtins.list[builtins.list[builtins.str]]: ...
@@ -2162,7 +2227,7 @@ def discovery_subagent_paths(path: builtins.str | os.PathLike | pathlib.Path) ->
 
 def discovery_subagent_transcripts(path: builtins.str | os.PathLike | pathlib.Path) -> dict[str, pathlib.Path]: ...
 
-def embedded_literals() -> dict[str, str | float | list[str]]: ...
+def embedded_literals() -> dict[str, str | float | int | list[str]]: ...
 
 def expand_tool_names(spec: builtins.str) -> frozenset[str]:
     r"""

cc_transcript-14.6.1/cc_transcript/codex.py

@@ -0,0 +1,212 @@
+"""The codex session surface: discovery, resolution, and per-rollout session info.
+
+A sync facade over the native codex functions, mirroring
+:mod:`cc_transcript.discovery` for the ``~/.codex/sessions`` tree. The sessions-root
+default is a facade concern; the native side scans exactly the root it is handed.
+
+There is no parse function here: :func:`cc_transcript.parse` is already
+provider-transparent — it sniffs a codex rollout, lowers it into the native event
+model, and yields the same :class:`~cc_transcript.models.Transcript` view a Claude
+transcript produces, with ``provider == "codex"``. This module adds only the codex
+identity, lifecycle, and token-usage surface that the lowered event stream drops.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING, Literal
+
+if TYPE_CHECKING:
+    from cc_transcript.ids import SessionId
+
+SESSIONS_ROOT = Path.home() / ".codex" / "sessions"
+
+Lifecycle = Literal["uninitialized", "no_instrumentation", "open", "completed", "aborted"]
+"""A codex rollout's turn-lifecycle state.
+
+``uninitialized`` — no content at all; ``no_instrumentation`` — content but no
+``task_started``/``task_complete`` brackets; ``open`` — the latest turn is still
+running; ``completed`` — the latest turn finished; ``aborted`` — the latest turn was
+interrupted.
+"""
+
+
+@dataclass(frozen=True, slots=True)
+class CodexRollout:
+    """A rollout found in the codex sessions tree.
+
+    Attributes:
+        path: The rollout's path.
+        session_id: The session id encoded in the rollout filename.
+        compressed: Whether the rollout is a ``.jsonl.zst`` file.
+    """
+
+    path: Path
+    session_id: str
+    compressed: bool
+
+
+@dataclass(frozen=True, slots=True)
+class CodexUsage:
+    """Session-level token totals lowered from a codex rollout.
+
+    The totals are the last observed cumulative ``total_token_usage`` fields — codex
+    ``token_count`` events carry running totals, not per-turn deltas — so this is the
+    session's final accounting, not a sum.
+
+    Attributes:
+        input_tokens: Total input tokens, or None when never reported.
+        cached_input_tokens: Cached input tokens, or None when never reported.
+        output_tokens: Output tokens, or None when never reported.
+        reasoning_output_tokens: Reasoning output tokens, or None when never reported.
+        total_tokens: Total tokens, or None when never reported.
+        model_context_window: The model's context window, or None when never reported.
+        token_count_events: The number of ``token_count`` events observed.
+    """
+
+    input_tokens: int | None
+    cached_input_tokens: int | None
+    output_tokens: int | None
+    reasoning_output_tokens: int | None
+    total_tokens: int | None
+    model_context_window: int | None
+    token_count_events: int
+
+
+@dataclass(frozen=True, slots=True)
+class CodexPendingItem:
+    """A dangling tool call in the rollout's open turn.
+
+    Attributes:
+        tool_use_id: The call's ``call_id``.
+        name: The tool's name, such as ``exec``.
+        kind: How the call contributes to the verdict; always ``mid_tool`` for codex.
+    """
+
+    tool_use_id: str | None
+    name: str
+    kind: str
+
+
+@dataclass(frozen=True, slots=True)
+class CodexSessionInfo:
+    """The identity, lifecycle, and usage of one codex rollout.
+
+    Attributes:
+        rollout_thread_id: This rollout's own thread id (the session-meta ``id``).
+        session_id: The logical session id; a forked rollout inherits its origin's.
+        parent_thread_id: The spawning thread's id for a subagent rollout, else None.
+        forked_from_id: The origin thread's id when this rollout is a fork, else None.
+        cwd: The working directory recorded in the session meta.
+        originator: What launched the session, such as ``codex_exec``.
+        cli_version: The codex CLI version that wrote the rollout.
+        model_provider: The model provider, such as ``openai``.
+        lifecycle: The latest turn's lifecycle state.
+        turn_id: The latest turn's id, or None before any turn brackets.
+        pending: The dangling tool calls in an open turn, in document order.
+        last_event_epoch: The latest envelope timestamp as epoch seconds, or None.
+        usage: The session token totals, or None when no ``token_count`` event occurred.
+    """
+
+    rollout_thread_id: str | None
+    session_id: str | None
+    parent_thread_id: str | None
+    forked_from_id: str | None
+    cwd: str | None
+    originator: str | None
+    cli_version: str | None
+    model_provider: str | None
+    lifecycle: Lifecycle
+    turn_id: str | None
+    pending: tuple[CodexPendingItem, ...]
+    last_event_epoch: int | None
+    usage: CodexUsage | None
+
+
+def sessions_root(root: Path | None = None) -> Path:
+    """The codex sessions root, defaulting to ``~/.codex/sessions``.
+
+    Args:
+        root: An explicit root; when None, :data:`SESSIONS_ROOT`.
+
+    Returns:
+        The root that :func:`discover` and :func:`find_transcript` scan.
+    """
+    return root or SESSIONS_ROOT
+
+
+def discover(root: Path | None = None) -> tuple[CodexRollout, ...]:
+    """Every codex rollout under ``root``, newest first.
+
+    Rollouts live as ``rollout-<timestamp>-<session_id>.jsonl`` (or ``.jsonl.zst``)
+    files under the date-sharded sessions tree. Each result preserves its path,
+    session id, and compression state.
+
+    Args:
+        root: The sessions root; when None, :func:`sessions_root`.
+
+    Returns:
+        The rollouts, newest first; ``()`` when the root does not exist.
+
+    Example:
+        >>> for rollout in discover():
+        ...     print(rollout.session_id, rollout.path)
+    """
+    from cc_transcript import _native
+
+    return tuple(CodexRollout(*rollout) for rollout in _native.codex_discover(sessions_root(root)))
+
+
+def find_transcript(session_id: SessionId, root: Path | None = None) -> Path | None:
+    """Locates ``session_id``'s rollout under the codex sessions tree.
+
+    Only uncompressed ``.jsonl`` rollouts resolve. Compressed rollouts appear in
+    ``discover()`` but do not resolve until zstd support lands. The newest wins among
+    same-id uncompressed rollouts.
+
+    Args:
+        session_id: The codex session id, as it appears in the rollout filename.
+        root: The sessions root; when None, :func:`sessions_root`.
+
+    Returns:
+        The rollout path, or None when no rollout carries that session id.
+    """
+    from cc_transcript import _native
+
+    return _native.codex_resolve(session_id, sessions_root(root))
+
+
+def session_info(path: Path) -> CodexSessionInfo:
+    """The identity, lifecycle, and token usage of the rollout at ``path``.
+
+    The native extension reads and folds the rollout in one pass, returning the
+    session identity, the turn lifecycle, any dangling calls, and the token totals.
+
+    Args:
+        path: The ``.jsonl`` rollout to inspect.
+
+    Returns:
+        The rollout's session info.
+    """
+    from cc_transcript import _native
+
+    payload = _native.codex_session_info(str(path))
+    identity = payload["identity"]
+    lifecycle = payload["lifecycle"]
+    usage = payload["usage"]
+    return CodexSessionInfo(
+        rollout_thread_id=identity["rollout_thread_id"],
+        session_id=identity["session_id"],
+        parent_thread_id=identity["parent_thread_id"],
+        forked_from_id=identity["forked_from_id"],
+        cwd=identity["cwd"],
+        originator=identity["originator"],
+        cli_version=identity["cli_version"],
+        model_provider=identity["model_provider"],
+        lifecycle=lifecycle["state"],
+        turn_id=lifecycle["turn_id"],
+        pending=tuple(CodexPendingItem(**item) for item in payload["pending"]),
+        last_event_epoch=payload["last_event_epoch"],
+        usage=CodexUsage(**usage) if usage is not None else None,
+    )

{cc_transcript-14.5.0 → cc_transcript-14.6.1}/cc_transcript/command.py

@@ -18,6 +18,10 @@ from cc_transcript._native import CommandLine as CommandLine
 from cc_transcript._native import CommandLineQuery as CommandLineQuery
 from cc_transcript._native import Occurrence as Occurrence
 from cc_transcript._native import Redirect as Redirect
+from cc_transcript._native import Word as Word
+from cc_transcript.literals import literal_int
+
+PAYLOAD_DEPTH_LIMIT: int = literal_int("command.PAYLOAD_DEPTH_LIMIT")
 
 parse_command_line = lru_cache(maxsize=4096)(CommandLine.parse)
 

{cc_transcript-14.5.0 → cc_transcript-14.6.1}/cc_transcript/discovery.py

@@ -96,7 +96,8 @@ def resolve(session_id: SessionId, *, root: Path | None = None) -> Path | None:
     A successful lookup is memoized in ``TRANSCRIPT_MEMO`` under
     ``(session_id, resolved root)`` and revalidated on the next hit, so a
     repeated probe skips the recursive scan while a pruned transcript still
-    forces a fresh one.
+    forces a fresh one. When the projects tree yields nothing, the codex
+    sessions tree is tried as a fallback, so a codex session id resolves too.
 
     Returns:
         The newest-mtime real path, or None when no transcript exists.
@@ -105,8 +106,11 @@ def resolve(session_id: SessionId, *, root: Path | None = None) -> Path | None:
     key = (session_id, base.resolve())
     if (cached := TRANSCRIPT_MEMO.get(key)) is not None and cached.exists():
         return cached
-    if (hit := _native.discovery_find_transcript(base, session_id)) is None:
-        return None
+    hit = _native.discovery_find_transcript(base, session_id)
+    if hit is None:
+        from cc_transcript import codex
+
+        return codex.find_transcript(session_id)
     TRANSCRIPT_MEMO[key] = hit
     return hit
 

{cc_transcript-14.5.0 → cc_transcript-14.6.1}/cc_transcript/judge/verdicts.py

@@ -334,6 +334,7 @@ async def run_verdicts[V](
     """
     counts = {"judged": 0, "failed": 0}
     limiter = asyncio.Semaphore(concurrency)
+    persister = asyncio.Lock()
 
     async def worker(row: Mapping[str, object]) -> None:
         async with limiter:
@@ -342,7 +343,11 @@ async def run_verdicts[V](
             except JudgeError:
                 counts["failed"] += 1
                 return
-        await persist(row, verdict)
+        # The store's transaction is exclusive by contract; persists serialize on
+        # this lock so concurrent workers never race record_verdict into a
+        # TransactionConflictError. Judge concurrency is untouched.
+        async with persister:
+            await persist(row, verdict)
         counts["judged"] += 1
 
     async with asyncio.TaskGroup() as tg:

{cc_transcript-14.5.0 → cc_transcript-14.6.1}/cc_transcript/literals.py

@@ -12,7 +12,7 @@ from __future__ import annotations
 
 from cc_transcript import _native
 
-LITERALS: dict[str, str | float | list[str]] = _native.embedded_literals()
+LITERALS: dict[str, str | float | int | list[str]] = _native.embedded_literals()
 
 
 def literal_str(key: str) -> str:
@@ -25,3 +25,9 @@ def literal_float(key: str) -> float:
     value = LITERALS[key]
     assert isinstance(value, float), key
     return value
+
+
+def literal_int(key: str) -> int:
+    value = LITERALS[key]
+    assert isinstance(value, int), key
+    return value

{cc_transcript-14.5.0 → cc_transcript-14.6.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cc-transcript"
-version = "14.5.0" # informational — releases stamp the version from the git tag
+version = "14.6.1" # 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"

{cc_transcript-14.5.0 → cc_transcript-14.6.1}/rust/crates/cli/src/target.rs

@@ -4,7 +4,7 @@
 use std::path::{Path, PathBuf};
 
 use cc_transcript_core::discovery::{find_in, mtime_secs};
-use cc_transcript_core::parse::parse_bytes;
+use cc_transcript_core::gateway::parse_transcript_bytes;
 use cc_transcript_core::render::display_path;
 use cc_transcript_core::types::Entry;
 use rayon::prelude::*;
@@ -108,7 +108,7 @@ pub fn parse_transcripts(targets: &[(PathBuf, f64)]) -> Vec<Parsed> {
         .par_iter()
         .map(|(path, _)| {
             let bytes = std::fs::read(path).ok()?;
-            let entries = parse_bytes(&bytes, |_| true).ok()?;
+            let entries = parse_transcript_bytes(&bytes).ok()?.entries;
             Some(Parsed {
                 path: path.clone(),
                 session_id: session_id_of(&entries),