cc-transcript 14.0.0__tar.gz → 14.1.1__tar.gz

{cc_transcript-14.0.0 → cc_transcript-14.1.1}/PKG-INFO

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

{cc_transcript-14.0.0 → cc_transcript-14.1.1}/cc_transcript/_native.pyi

@@ -1259,6 +1259,8 @@ class PrintMessage:
         blocks: The structured content blocks of the message.
         uuid: The message's event uuid, when present.
         session_id: The session the message belongs to.
+        id: The API message id, when present (assistant messages carry one).
+        usage: The message's token usage, when present (assistant messages carry one).
     """
     __match_args__: typing.ClassVar[tuple[str, ...]]
     @property
@@ -1273,6 +1275,10 @@ class PrintMessage:
     def uuid(self) -> ids.EventUuid | None: ...
     @property
     def session_id(self) -> ids.SessionId: ...
+    @property
+    def id(self) -> typing.Optional[builtins.str]: ...
+    @property
+    def usage(self) -> typing.Optional[Usage]: ...
 
 @typing.final
 class PrintResult:

{cc_transcript-14.0.0 → cc_transcript-14.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cc-transcript"
-version = "14.0.0"
+version = "14.1.1"
 description = "Grep every Claude Code session you've ever run."
 readme = "README.md"
 license = "PolyForm-Noncommercial-1.0.0"

{cc_transcript-14.0.0 → cc_transcript-14.1.1}/rust/crates/core/src/command.rs

@@ -46,6 +46,10 @@ pub struct Command {
     // Parity: command.py Command.span — byte offsets (start, end), None when a redirect absorbs a
     // trailing word; carries compare=False, repr=False, so it is excluded from PartialEq and Debug.
     pub span: Option<(usize, usize)>,
+    // Native-only provenance for top-level selectors. Substitution commands remain visible in
+    // occurrence APIs; this flag is excluded from PartialEq, Debug, and the PyO3 command surface.
+    #[doc(hidden)]
+    pub substitution: bool,
 }
 
 impl PartialEq for Command {
@@ -145,6 +149,7 @@ impl Command {
             env: self.env.clone(),
             redirects: self.redirects.clone(),
             span: self.span,
+            substitution: self.substitution,
         }
     }
 
@@ -183,10 +188,23 @@ pub struct CommandLine {
 impl CommandLine {
     // Parity: command.py CommandLine.parse — blank/comment-only input yields empty parts.
     pub fn parse(raw: &str) -> CommandLine {
-        let parts = BASH_PARSER.with(|parser| match parser.borrow_mut().parse(raw, None) {
+        let mut parts = BASH_PARSER.with(|parser| match parser.borrow_mut().parse(raw, None) {
             Some(tree) => walk_node(tree.root_node(), raw.as_bytes()),
             None => Vec::new(),
         });
+        // Nested inside an enumerated host's span: visible but span-less, like an absorbed word.
+        let spans: Vec<Option<(usize, usize)>> = parts.iter().map(|(cmd, _)| cmd.span).collect();
+        for (i, (cmd, _)) in parts.iter_mut().enumerate() {
+            let Some((start, end)) = cmd.span else {
+                continue;
+            };
+            let enclosed = spans.iter().enumerate().any(|(j, other)| {
+                j != i && matches!(other, Some((os, oe)) if *os <= start && end <= *oe && (*os, *oe) != (start, end))
+            });
+            if enclosed {
+                cmd.span = None;
+            }
+        }
         CommandLine {
             raw: raw.to_string(),
             parts,
@@ -198,14 +216,19 @@ impl CommandLine {
         self.parts.iter().map(|(cmd, _)| cmd).collect()
     }
 
-    // Parity: command.py CommandLine.primary — the final command, or None.
+    // Parity: command.py CommandLine.primary — the final top-level command, or None.
     pub fn primary(&self) -> Option<&Command> {
-        self.parts.last().map(|(cmd, _)| cmd)
+        self.parts
+            .iter()
+            .rev()
+            .find_map(|(cmd, _)| (!cmd.substitution).then_some(cmd))
     }
 
-    // Parity: command.py CommandLine.head — the first command, or None.
+    // Parity: command.py CommandLine.head — the first top-level command, or None.
     pub fn head(&self) -> Option<&Command> {
-        self.parts.first().map(|(cmd, _)| cmd)
+        self.parts
+            .iter()
+            .find_map(|(cmd, _)| (!cmd.substitution).then_some(cmd))
     }
 
     // Parity: command.py CommandLine.prefixes — each command's prefix, None dropped.
@@ -501,6 +524,7 @@ fn extract_command(node: Node, src: &[u8]) -> Command {
         env,
         redirects,
         span: Some(span),
+        substitution: false,
     }
 }
 
@@ -562,13 +586,19 @@ fn walk_redirected(node: Node, src: &[u8]) -> Vec<(Command, Option<String>)> {
 }
 
 // Parity: command.py CommandLine.walk_node — program/list/pipeline split at their ops,
-// command extracts, redirected_statement unwraps, everything else recurses in order.
+// command extracts, command substitutions mark their recursive commands, redirected_statement
+// unwraps, and everything else recurses in order.
 fn walk_node(node: Node, src: &[u8]) -> Vec<(Command, Option<String>)> {
     match node.kind() {
         "program" => walk_program(node, src),
         "list" => collect_parts(node, src, COMPOUND_OPS),
         "pipeline" => collect_parts(node, src, &["|"]),
-        "command" => vec![(extract_command(node, src), None)],
+        "command" => {
+            let mut parts = vec![(extract_command(node, src), None)];
+            parts.extend(substitution_parts(node, src));
+            parts
+        }
+        "command_substitution" => walk_substitution(node, src),
         "redirected_statement" => walk_redirected(node, src),
         _ => {
             let mut parts = Vec::new();
@@ -581,6 +611,33 @@ fn walk_node(node: Node, src: &[u8]) -> Vec<(Command, Option<String>)> {
     }
 }
 
+fn walk_substitution(node: Node, src: &[u8]) -> Vec<(Command, Option<String>)> {
+    let mut parts = Vec::new();
+    let mut cursor = node.walk();
+    for child in node.children(&mut cursor) {
+        parts.extend(walk_node(child, src));
+    }
+    for (cmd, _) in &mut parts {
+        cmd.substitution = true;
+    }
+    parts
+}
+
+// Word/argument-position `$(…)`/backtick substitutions under a command node, enumerated as parts
+// mirroring assignment position: document order (host first), redirect targets excluded.
+fn substitution_parts(node: Node, src: &[u8]) -> Vec<(Command, Option<String>)> {
+    let mut parts = Vec::new();
+    let mut cursor = node.walk();
+    for child in node.children(&mut cursor) {
+        match child.kind() {
+            "command_substitution" => parts.extend(walk_node(child, src)),
+            "file_redirect" => {}
+            _ => parts.extend(substitution_parts(child, src)),
+        }
+    }
+    parts
+}
+
 // Parity: command.py CommandLine.walk_program — collect_parts over `;`, dropping the heredoc body
 // and delimiter lines that tree-sitter's multi-heredoc ERROR recovery re-parses as sibling commands.
 fn walk_program(node: Node, src: &[u8]) -> Vec<(Command, Option<String>)> {
@@ -1017,6 +1074,108 @@ mod tests {
         assert_eq!(line.parts[0].0.redirects[0].fd, None);
     }
 
+    fn execs(line: &CommandLine) -> Vec<&str> {
+        line.parts
+            .iter()
+            .map(|(cmd, _)| cmd.executable.as_str())
+            .collect()
+    }
+
+    // Both substitution positions get one treatment: the nested command is a first-class part.
+    #[test]
+    fn substitutions_enumerate_in_word_position_like_assignment_position() {
+        assert_eq!(
+            execs(&CommandLine::parse("x=$(ccx repo overview)")),
+            ["ccx"]
+        );
+        let word = CommandLine::parse("echo $(ccx repo overview)");
+        assert_eq!(execs(&word), ["echo", "ccx"]);
+        assert_eq!(word.parts[1].0.args, ["repo", "overview"]);
+        assert_eq!(
+            execs(&CommandLine::parse("echo `ccx repo overview`")),
+            ["echo", "ccx"]
+        );
+        // command_name, quoted, concatenated, and env-prefix-value positions all enumerate.
+        assert_eq!(
+            execs(&CommandLine::parse("$(which python) --version")),
+            ["$(which python)", "which"]
+        );
+        assert_eq!(execs(&CommandLine::parse("echo \"$(a)\"")), ["echo", "a"]);
+        assert_eq!(
+            execs(&CommandLine::parse("tag=v$(git rev-parse HEAD) make")),
+            ["make", "git"]
+        );
+        // Redirect targets stay out, matching statement-level redirects.
+        assert_eq!(execs(&CommandLine::parse("echo hi > $(target)")), ["echo"]);
+    }
+
+    #[test]
+    fn primary_skips_argument_position_substitution() {
+        let line = CommandLine::parse(r#"gh pr list --json number --search "$(cat q.txt)""#);
+        assert_eq!(execs(&line), ["gh", "cat"]);
+        assert_eq!(line.primary().unwrap().executable, "gh");
+    }
+
+    #[test]
+    fn primary_keeps_word_position_host_command() {
+        let line = CommandLine::parse(r#""$(get-cmd)" --flag"#);
+        assert_eq!(execs(&line), ["\"$(get-cmd)\"", "get-cmd"]);
+        assert_eq!(line.primary().unwrap().executable, "\"$(get-cmd)\"");
+    }
+
+    #[test]
+    fn head_skips_leading_assignment_position_substitution() {
+        let line = CommandLine::parse("x=$(get-cmd); host --flag");
+        assert_eq!(execs(&line), ["get-cmd", "host"]);
+        assert_eq!(line.head().unwrap().executable, "host");
+    }
+
+    // Document order: the host command first, then each outermost substitution left to right,
+    // recursing so nested substitutions follow their host.
+    #[test]
+    fn substitutions_enumerate_nested_in_document_order() {
+        assert_eq!(
+            execs(&CommandLine::parse("diff $(sort a) $(b $(c))")),
+            ["diff", "sort", "b", "c"]
+        );
+        assert_eq!(
+            execs(&CommandLine::parse("echo $(a | b; c)")),
+            ["echo", "a", "b", "c"]
+        );
+    }
+
+    // Operator attachment mirrors assignment position: the op hangs off the last enumerated part.
+    #[test]
+    fn substitution_parts_carry_operators_and_spans_like_assignment_position() {
+        let assign = CommandLine::parse("x=$(a) && foo");
+        assert_eq!(execs(&assign), ["a", "foo"]);
+        assert_eq!(assign.parts[0].1.as_deref(), Some("&&"));
+        let word = CommandLine::parse("echo $(a) && foo");
+        assert_eq!(execs(&word), ["echo", "a", "foo"]);
+        assert_eq!(word.parts[0].1, None);
+        assert_eq!(word.parts[1].1.as_deref(), Some("&&"));
+        assert_eq!(word.next_op(1), Some("&&"));
+        assert_eq!(word.prev_op(2), Some("&&"));
+        assert!(!word.piped(0) && !word.piped(1));
+        // Nested inside the host's span: visible but span-less (splice's non-overlap invariant);
+        // assignment position has no host, so its span survives and splices in place.
+        let line = CommandLine::parse("echo $(ccx repo overview)");
+        assert_eq!(line.parts[0].0.span, Some((0, 25)));
+        assert_eq!(line.parts[1].0.span, None);
+        assert!(matches!(
+            line.splice(&BTreeMap::from([(1, "ls".to_string())])),
+            Err(SpliceError::NoSpan { index: 1 })
+        ));
+        let assign_only = CommandLine::parse("x=$(ccx repo overview)");
+        assert_eq!(assign_only.parts[0].0.span, Some((4, 21)));
+        assert_eq!(
+            assign_only
+                .splice(&BTreeMap::from([(0, "ls".to_string())]))
+                .unwrap(),
+            "x=$(ls)"
+        );
+    }
+
     #[test]
     fn rewrite_occurrences_maps_or_none() {
         let line = CommandLine::parse("git push; ls; git pull");

{cc_transcript-14.0.0 → cc_transcript-14.1.1}/rust/crates/core/src/parse.rs

@@ -699,6 +699,8 @@ fn parse_print_message(element: &Value) -> Result<PrintMessage, ParseError> {
     };
     Ok(PrintMessage {
         body,
+        id: field_str(message, "id").map(str::to_string),
+        usage: parse_usage(message)?,
         uuid: field_str(element, "uuid").map(str::to_string),
         session_id: require_str(element, "session_id")?.to_string(),
     })

{cc_transcript-14.0.0 → cc_transcript-14.1.1}/rust/crates/core/src/types.rs

@@ -549,6 +549,8 @@ pub enum PrintBody {
 #[derive(Debug)]
 pub struct PrintMessage {
     pub body: PrintBody,
+    pub id: Option<String>,
+    pub usage: Option<Usage>,
     pub uuid: Option<String>,
     pub session_id: String,
 }

{cc_transcript-14.0.0 → cc_transcript-14.1.1}/rust/crates/py/data/command_prefix_pins.tsv

@@ -34,7 +34,7 @@ process-substitution	diff <(sort a.txt) <(sort b.txt)	diff
 process-substitution-in-pipeline	cat <(git log) | head -3	cat|head
 arithmetic-expansion	echo $((1 + 2))	echo
 arithmetic-assignment-prefix	x=$((COUNT + 1)) make build	make
-backtick-substitution	echo `git rev-parse HEAD`	echo
+backtick-substitution	echo `git rev-parse HEAD`	echo|git rev-parse
 function-definition-body-and-call	foo() { git status; }; foo	git status|foo
 multiline-quoted-string	git commit -m "line1\nline2"	git commit
 newline-separated-commands	git add .\ngit commit -m x	git add|git commit

{cc_transcript-14.0.0 → cc_transcript-14.1.1}/rust/crates/py/src/views/command.rs

@@ -125,6 +125,7 @@ impl CommandView {
                     .map(|rv| rv.r)
                     .collect(),
                 span,
+                substitution: false,
             },
         }
     }

{cc_transcript-14.0.0 → cc_transcript-14.1.1}/rust/crates/py/src/views/print.rs

@@ -264,6 +264,8 @@ view_dunders!(
 ///     blocks: The structured content blocks of the message.
 ///     uuid: The message's event uuid, when present.
 ///     session_id: The session the message belongs to.
+///     id: The API message id, when present (assistant messages carry one).
+///     usage: The message's token usage, when present (assistant messages carry one).
 #[pyo3_stub_gen::derive::gen_stub_pyclass]
 #[pyclass(name = "PrintMessage", module = "cc_transcript.models", frozen)]
 pub(crate) struct PrintMessageView {
@@ -326,12 +328,24 @@ impl PrintMessageView {
     fn session_id(&self, _py: Python<'_>) -> PyResult<String> {
         Ok(self.message().session_id.clone())
     }
+
+    #[getter]
+    fn id(&self, _py: Python<'_>) -> PyResult<Option<String>> {
+        Ok(self.message().id.clone())
+    }
+
+    #[getter]
+    fn usage(&self, _py: Python<'_>) -> PyResult<Option<UsageView>> {
+        Ok(self.message().usage.as_ref().map(|_| UsageView {
+            host: UsageHost::PrintMessage(Arc::clone(&self.p.0), self.msg),
+        }))
+    }
 }
 
 view_dunders!(
     PrintMessageView,
     "PrintMessage",
-    fields = [role, model, text, blocks, uuid, session_id]
+    fields = [role, model, text, blocks, uuid, session_id, id, usage]
 );
 
 /// A parsed 'claude -p --output-format json' result.

{cc_transcript-14.0.0 → cc_transcript-14.1.1}/rust/crates/py/src/views/store.rs

@@ -100,12 +100,13 @@ impl BlockRef {
     }
 }
 
-/// Where a Usage lives: an assistant entry's optional usage, or the aggregate
-/// usage of a ``--print`` result.
+/// Where a Usage lives: an assistant entry's optional usage, the aggregate
+/// usage of a ``--print`` result, or one ``--print`` message's usage.
 #[derive(Clone)]
 pub(crate) enum UsageHost {
     Entry(EventRef),
     Print(Arc<PrintResult>),
+    PrintMessage(Arc<PrintResult>, usize),
 }
 
 impl UsageHost {
@@ -117,6 +118,10 @@ impl UsageHost {
                 .as_ref()
                 .expect("usage view over an assistant entry with usage"),
             UsageHost::Print(pr) => &pr.usage,
+            UsageHost::PrintMessage(pr, msg) => pr.messages[*msg]
+                .usage
+                .as_ref()
+                .expect("usage view over a print message with usage"),
         }
     }
 }