cc-transcript 14.21.0__tar.gz → 14.23.0__tar.gz

{cc_transcript-14.21.0 → cc_transcript-14.23.0}/PKG-INFO

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

{cc_transcript-14.21.0 → cc_transcript-14.23.0}/cc_transcript/_native.pyi

@@ -2500,7 +2500,7 @@ def render_tool_call(name: builtins.str, input_json: builtins.str, turn_chars: b
 
 def render_tool_call_view(call: tools.ToolCall, turn_chars: builtins.int, tool_chars: builtins.int) -> builtins.str: ...
 
-def render_turn_from_events(prompt: builtins.str, events: list[models.TranscriptEvent], turn_chars: builtins.int, tool_chars: builtins.int) -> builtins.str: ...
+def render_turn_from_events(prompt: builtins.str, events: list[models.TranscriptEvent], turn_chars: builtins.int, tool_chars: builtins.int, tool_results: builtins.bool) -> builtins.str: ...
 
 def score_post_process(spec_json: builtins.str, buckets: typing.Sequence[typing.Sequence[builtins.str]], raw: typing.Sequence[builtins.int]) -> builtins.list[builtins.int]: ...
 

{cc_transcript-14.21.0 → cc_transcript-14.23.0}/cc_transcript/render.py

@@ -61,23 +61,41 @@ def prefixed(prefix: str, text: str) -> tuple[str, ...]:
     return tuple(f"{prefix}{line}" for line in text.splitlines()) or (prefix.rstrip(),)
 
 
-def render_turn(turn: Turn, *, budget: Budget) -> str:
-    """Render one turn: the prompt, the user's mid-turn messages, assistant prose, and every tool call with its result, in order.
-
-    Prose chunks and tool results clip to ``budget.turn_chars``; each tool call
-    renders via :func:`render_tool_call` under ``budget.tool_chars``. A result
-    renders as ``result:``, or ``failed:`` when the call errored; an
-    AskUserQuestion answer renders as ``user answered:`` with the chosen option's
-    description, the selected preview and any notes.
+def render_turn(turn: Turn, *, budget: Budget, tool_results: bool = False) -> str:
+    """Render one turn: the prompt, the user's mid-turn messages, assistant prose, and every tool call, in order.
+
+    Prose chunks clip to ``budget.turn_chars``; each tool call renders via
+    :func:`render_tool_call` under ``budget.tool_chars``. An AskUserQuestion answer
+    renders as ``user answered:`` with the chosen option's description, the
+    selected preview and any notes.
+
+    Args:
+        turn: The turn to render.
+        budget: Character budgets for prose and tool calls.
+        tool_results: Render each other tool result after its call: a ``result:``
+            head, or ``failed:`` when the call errored, naming the tool, then the
+            content clipped to ``budget.turn_chars`` on ``> `` lines. Calls batched in
+            one message and their results carry a ``call i/n``/``result i/n`` ordinal.
     """
     return _native.render_turn_from_events(
         turn.prompt,
         list(turn.events),
         budget.turn_chars,
         budget.tool_chars,
+        tool_results,
     )
 
 
-def render_session(activity: SessionActivity, *, budget: Budget) -> str:
-    """Render every turn of a session under ``budget``, separated by blank lines."""
-    return "\n\n".join(rendered for turn in activity.turns if (rendered := render_turn(turn, budget=budget)))
+def render_session(activity: SessionActivity, *, budget: Budget, tool_results: bool = False) -> str:
+    """Render every turn of a session under ``budget``, separated by blank lines.
+
+    Args:
+        activity: The session to render.
+        budget: Character budgets for prose and tool calls.
+        tool_results: Render each tool result after its call; see :func:`render_turn`.
+    """
+    return "\n\n".join(
+        rendered
+        for turn in activity.turns
+        if (rendered := render_turn(turn, budget=budget, tool_results=tool_results))
+    )

{cc_transcript-14.21.0 → cc_transcript-14.23.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cc-transcript"
-version = "14.21.0" # informational — releases stamp the version from the git tag
+version = "14.23.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.21.0 → cc_transcript-14.23.0}/rust/crates/core/src/context.rs

@@ -514,7 +514,7 @@ fn turn_ref(turn: &Turn, budget: &Budget) -> TurnRef {
                 tool_use_id: None,
             })
             .collect(),
-        preview: render_turn(turn, budget),
+        preview: render_turn(turn, budget, false),
         tool_digests: turn_tool_uses(turn)
             .map(|tu| tool_digest(&tu.name, &tu.input).expect("tool input digests"))
             .collect(),

{cc_transcript-14.21.0 → cc_transcript-14.23.0}/rust/crates/core/src/render.rs

@@ -437,29 +437,45 @@ pub fn render_tool_call(call: &ToolCall, budget: &Budget) -> String {
 }
 
 /// Render one turn — the prompt, the user's mid-turn messages, assistant prose,
-/// every tool call with its result, and the user's AskUserQuestion answers, in order
-/// (render.py render_turn). Prose and tool results clip to `budget.turn_chars`; each
-/// tool call and answer preview renders under `budget.tool_chars`.
-pub fn render_turn(turn: &Turn, budget: &Budget) -> String {
+/// every tool call, and the user's AskUserQuestion answers, in order (render.py
+/// render_turn). With `tool_results`, each other result follows its call as a
+/// `result:`/`failed:` head naming the call, its content on `> ` lines, and a
+/// `call i/n`/`result i/n` ordinal on calls batched in one message.
+pub fn render_turn(turn: &Turn, budget: &Budget, tool_results: bool) -> String {
     let mut parts: Vec<String> = Vec::new();
     if !turn.prompt.is_empty() {
         parts.push(format!("user: {}", clip(&turn.prompt, budget.turn_chars)));
     }
-    let mut calls: HashMap<&str, &str> = HashMap::new();
+    let mut calls: HashMap<&str, CallLabel<'_>> = HashMap::new();
     for &event in &turn.events {
         match event {
             Entry::Assistant(assistant) => {
+                let batch = assistant
+                    .blocks
+                    .iter()
+                    .filter(|block| matches!(block, ContentBlock::ToolUse(_)))
+                    .count();
+                let mut ordinal = 0;
                 for block in &assistant.blocks {
                     match block {
                         ContentBlock::Text(text) if !pystr::strip(text).is_empty() => {
                             parts.push(format!("assistant: {}", clip(text, budget.turn_chars)));
                         }
                         ContentBlock::ToolUse(tool_use) => {
-                            calls.insert(&tool_use.id, &tool_use.name);
-                            parts.push(render_tool_call(
+                            ordinal += 1;
+                            let label = CallLabel {
+                                name: &tool_use.name,
+                                ordinal: (tool_results && batch > 1).then_some((ordinal, batch)),
+                            };
+                            let rendered = render_tool_call(
                                 &parse_tool_call(&tool_use.name, &tool_use.input),
                                 budget,
-                            ));
+                            );
+                            parts.push(match label.ordinal {
+                                Some((i, n)) => format!("call {i}/{n}: {rendered}"),
+                                None => rendered,
+                            });
+                            calls.insert(&tool_use.id, label);
                         }
                         _ => {}
                     }
@@ -468,8 +484,8 @@ pub fn render_turn(turn: &Turn, budget: &Budget) -> String {
             Entry::User(user) => {
                 for block in user.blocks() {
                     if let ContentBlock::ToolResult(result) = block {
-                        if let Some(name) = calls.get(result.tool_use_id.as_str()) {
-                            parts.extend(result_lines(name, result, budget));
+                        if let Some(label) = calls.get(result.tool_use_id.as_str()) {
+                            parts.extend(result_lines(label, result, budget, tool_results));
                         }
                     }
                 }
@@ -485,29 +501,57 @@ pub fn render_turn(turn: &Turn, budget: &Budget) -> String {
     parts.join("\n")
 }
 
-fn result_lines(name: &str, result: &ToolResultBlock, budget: &Budget) -> Vec<String> {
+struct CallLabel<'a> {
+    name: &'a str,
+    ordinal: Option<(usize, usize)>,
+}
+
+impl CallLabel<'_> {
+    fn head(&self, verdict: &str) -> String {
+        match self.ordinal {
+            Some((i, n)) => format!("{verdict} {i}/{n}: {}", self.name),
+            None => format!("{verdict}: {}", self.name),
+        }
+    }
+}
+
+fn result_lines(
+    label: &CallLabel<'_>,
+    result: &ToolResultBlock,
+    budget: &Budget,
+    tool_results: bool,
+) -> Vec<String> {
     if result.is_error {
-        return vec![format!(
-            "failed: {}",
-            clip(&result.content, budget.turn_chars)
-        )];
+        if !tool_results {
+            return Vec::new();
+        }
+        return quoted_result(label.head("failed"), &result.content, budget);
     }
-    if name == ASK_USER_QUESTION {
+    if label.name == ASK_USER_QUESTION {
         if let Some(ToolResult::AskUserQuestion(answer)) = result
             .tool_use_result
             .as_ref()
-            .map(|payload| parse_tool_result(name, payload))
+            .map(|payload| parse_tool_result(label.name, payload))
         {
             return answer_lines(&answer, budget);
         }
+        return vec![format!(
+            "user answered: {}",
+            clip(&result.content, budget.tool_chars)
+        )];
     }
-    if pystr::strip(&result.content).is_empty() {
+    if !tool_results {
         return Vec::new();
     }
-    vec![format!(
-        "result: {}",
-        clip(&result.content, budget.turn_chars)
-    )]
+    quoted_result(label.head("result"), &result.content, budget)
+}
+
+fn quoted_result(head: String, content: &str, budget: &Budget) -> Vec<String> {
+    let mut lines = vec![head];
+    if !pystr::strip(content).is_empty() {
+        lines.extend(prefixed("> ", &clip(content, budget.turn_chars)));
+    }
+    lines
 }
 
 fn answer_lines(answer: &AskUserQuestionResult, budget: &Budget) -> Vec<String> {

{cc_transcript-14.21.0 → cc_transcript-14.23.0}/rust/crates/py/src/render.rs

@@ -72,6 +72,7 @@ pub(crate) fn render_turn_from_events(
     events: Vec<Bound<'_, PyAny>>,
     turn_chars: usize,
     tool_chars: usize,
+    tool_results: bool,
 ) -> PyResult<String> {
     let entries = events
         .iter()
@@ -91,6 +92,7 @@ pub(crate) fn render_turn_from_events(
             turn_chars,
             tool_chars,
         },
+        tool_results,
     ))
 }