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

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

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

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

@@ -87,6 +87,7 @@ EXPORTS: dict[str, str] = {
             "CommandLineQuery",
             "Occurrence",
             "Redirect",
+            "Word",
             "command_prefixes",
             "parse_command_line",
         ),

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

@@ -33,6 +33,7 @@ from cc_transcript.command import (
     CommandLineQuery as CommandLineQuery,
     Occurrence as Occurrence,
     Redirect as Redirect,
+    Word as Word,
     command_prefixes as command_prefixes,
     parse_command_line as parse_command_line,
 )
@@ -421,6 +422,7 @@ __all__ = [
     "UserEvent",
     "WatchEvent",
     "Watcher",
+    "Word",
     "WorkflowCall",
     "WriteCall",
     "WriteResult",

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

@@ -95,6 +95,7 @@ __all__ = [
     "Usage",
     "UserEvent",
     "WatchTailer",
+    "Word",
     "WorkflowCall",
     "WriteCall",
     "WriteResult",
@@ -411,6 +412,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 +476,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 +1098,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:
@@ -2063,6 +2097,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"""
@@ -2162,7 +2217,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.5.0 → cc_transcript-14.6.0}/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.0}/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.0}/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.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"

{cc_transcript-14.5.0 → cc_transcript-14.6.0}/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),

cc_transcript-14.6.0/rust/crates/core/src/codex/discovery.rs

@@ -0,0 +1,192 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use chrono::NaiveDateTime;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RolloutFile {
+    pub path: PathBuf,
+    pub session_id: String,
+    pub compressed: bool,
+}
+
+pub fn sessions_root(root: Option<&Path>) -> PathBuf {
+    root.map(Path::to_path_buf).unwrap_or_else(|| {
+        std::env::home_dir()
+            .expect("a home directory resolves via HOME or the pwd database")
+            .join(".codex")
+            .join("sessions")
+    })
+}
+
+pub fn discover(root: &Path) -> Vec<RolloutFile> {
+    if !root.exists() {
+        return Vec::new();
+    }
+    let mut found = Vec::new();
+    walk(root, &mut |path| {
+        let Some((stamp, session_id, compressed)) = parse_file_name(path) else {
+            return;
+        };
+        found.push((
+            stamp,
+            RolloutFile {
+                path: path.to_path_buf(),
+                session_id,
+                compressed,
+            },
+        ));
+    });
+    found.sort_by(|a, b| b.0.cmp(&a.0).then_with(|| a.1.path.cmp(&b.1.path)));
+    found.into_iter().map(|(_, rollout)| rollout).collect()
+}
+
+pub fn resolve(session_id: &str, root: &Path) -> Option<PathBuf> {
+    let found = discover(root);
+    found
+        .iter()
+        .find(|rollout| rollout.session_id == session_id && !rollout.compressed)
+        .or_else(|| {
+            found
+                .iter()
+                .find(|rollout| rollout.session_id == session_id)
+        })
+        .map(|rollout| rollout.path.clone())
+}
+
+fn walk(dir: &Path, visit: &mut impl FnMut(&Path)) {
+    let Ok(entries) = fs::read_dir(dir) else {
+        return;
+    };
+    for entry in entries.flatten() {
+        let Ok(file_type) = entry.file_type() else {
+            continue;
+        };
+        let path = entry.path();
+        if file_type.is_dir() {
+            walk(&path, visit);
+        } else {
+            visit(&path);
+        }
+    }
+}
+
+fn parse_file_name(path: &Path) -> Option<(String, String, bool)> {
+    let name = path.file_name()?.to_str()?;
+    let (stem, compressed) = match name.strip_suffix(".jsonl.zst") {
+        Some(stem) => (stem, true),
+        None => (name.strip_suffix(".jsonl")?, false),
+    };
+    let body = stem.strip_prefix("rollout-")?;
+    let split = body.len().checked_sub(37)?;
+    if body.as_bytes().get(split) != Some(&b'-') {
+        return None;
+    }
+    let stamp = body.get(..split)?;
+    let session_id = body.get(split + 1..)?;
+    NaiveDateTime::parse_from_str(stamp, "%Y-%m-%dT%H-%M-%S").ok()?;
+    if !is_uuid_v7(session_id) {
+        return None;
+    }
+    Some((stamp.to_string(), session_id.to_string(), compressed))
+}
+
+fn is_uuid_v7(value: &str) -> bool {
+    if value.len() != 36 {
+        return false;
+    }
+    value.bytes().enumerate().all(|(index, byte)| match index {
+        8 | 13 | 18 | 23 => byte == b'-',
+        14 => byte == b'7',
+        19 => matches!(byte, b'8' | b'9' | b'a' | b'b' | b'A' | b'B'),
+        _ => byte.is_ascii_hexdigit(),
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs::File;
+
+    fn touch(root: &Path, rel: &str) -> PathBuf {
+        let path = root.join(rel);
+        fs::create_dir_all(path.parent().unwrap()).unwrap();
+        File::create(&path).unwrap();
+        path
+    }
+
+    #[test]
+    fn discovers_and_resolves_rollouts() {
+        let root = std::env::temp_dir().join(format!(
+            "codex-discovery-{}-{:?}",
+            std::process::id(),
+            std::thread::current().id()
+        ));
+        fs::remove_dir_all(&root).ok();
+        let oldest = touch(
+            &root,
+            "2025/12/31/rollout-2025-12-31T23-59-59-019b7000-0000-7000-8000-000000000001.jsonl",
+        );
+        let twin = touch(
+            &root,
+            "2026/01/01/rollout-2026-01-01T00-00-01-019b7000-0000-7000-8000-000000000002.jsonl",
+        );
+        let twin_zst = touch(
+            &root,
+            "2026/01/03/rollout-2026-01-03T09-00-00-019b7000-0000-7000-8000-000000000002.jsonl.zst",
+        );
+        let newest = touch(
+            &root,
+            "2026/01/02/rollout-2026-01-02T03-04-05-019b7000-0000-7000-8000-000000000003.jsonl",
+        );
+        touch(&root, "2026/01/02/notes.jsonl");
+        touch(
+            &root,
+            "2026/01/02/rollout-2026-01-02T03-04-06-not-a-uuid.jsonl",
+        );
+
+        let found = discover(&sessions_root(Some(&root)));
+        assert_eq!(
+            found,
+            [
+                RolloutFile {
+                    path: twin_zst.clone(),
+                    session_id: "019b7000-0000-7000-8000-000000000002".into(),
+                    compressed: true,
+                },
+                RolloutFile {
+                    path: newest,
+                    session_id: "019b7000-0000-7000-8000-000000000003".into(),
+                    compressed: false,
+                },
+                RolloutFile {
+                    path: twin.clone(),
+                    session_id: "019b7000-0000-7000-8000-000000000002".into(),
+                    compressed: false,
+                },
+                RolloutFile {
+                    path: oldest.clone(),
+                    session_id: "019b7000-0000-7000-8000-000000000001".into(),
+                    compressed: false,
+                },
+            ]
+        );
+        assert_eq!(
+            resolve("019b7000-0000-7000-8000-000000000002", &root),
+            Some(twin.clone())
+        );
+        fs::remove_file(twin).unwrap();
+        assert_eq!(
+            resolve("019b7000-0000-7000-8000-000000000002", &root),
+            Some(twin_zst)
+        );
+        assert_eq!(
+            resolve("019b7000-0000-7000-8000-000000000001", &root),
+            Some(oldest)
+        );
+        assert_eq!(resolve("019b7000-0000-7000-8000-000000000099", &root), None);
+        assert_eq!(sessions_root(Some(&root)), root);
+        assert!(sessions_root(None).ends_with(".codex/sessions"));
+        fs::remove_dir_all(&root).ok();
+    }
+}

{cc_transcript-14.5.0 → cc_transcript-14.6.0}/rust/crates/core/src/codex/mod.rs

@@ -1,10 +1,14 @@
+pub mod discovery;
 pub mod lower;
 pub mod parse;
+pub mod probe;
 pub mod protocol;
 pub mod types;
 
+pub use discovery::{discover, resolve, sessions_root, RolloutFile};
 pub use lower::{lower, CodexLowering, CodexUsageAggregate};
 pub use parse::parse_codex_bytes;
+pub use probe::{codex_session_activity, session_probe, CodexProbe, Lifecycle};
 pub use protocol::{injection_wrapper, mcp_tool_name, output_exit_code, INJECTION_WRAPPERS};
 pub use types::{
     CodexEntry, CodexItem, CodexOther, CodexSession, Compacted, EventMsg, ResponseItem,