cc-transcript 14.20.1__tar.gz → 14.22.0__tar.gz

{cc_transcript-14.20.1 → cc_transcript-14.22.0}/PKG-INFO

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

{cc_transcript-14.20.1 → cc_transcript-14.22.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.20.1 → cc_transcript-14.22.0}/cc_transcript/render.py

@@ -61,20 +61,39 @@ 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, assistant prose, and every tool call, in order.
+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``.
+    :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, as ``result:``,
+            or ``failed:`` when the call errored, clipped to ``budget.turn_chars``.
     """
     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.20.1 → cc_transcript-14.22.0}/pyproject.toml

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

@@ -1,7 +1,7 @@
 //! The one renderer, ported from `cc_transcript/render.py` — every cut happens here,
 //! under a [`Budget`]. Parity notes on the individual helpers.
 
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 
 use chrono::{DateTime, FixedOffset};
 use sonic_rs::{JsonContainerTrait, JsonType, JsonValueTrait, Value};
@@ -14,13 +14,16 @@ use crate::facts::{McpServerSummary, ToolFact};
 use crate::filter::{entry_text, event_kind};
 use crate::ids::encode_string;
 use crate::pystr;
-use crate::toolcall::{parse_tool_call, ToolCall};
+use crate::toolcall::{
+    parse_tool_call, parse_tool_result, AskUserQuestionResult, ToolCall, ToolResult,
+};
 use crate::types::{
     joined_text, ApiError, AssistantEntry, AttachmentDetail, Attribution, CacheCreation,
     CompactBoundary, ContentBlock, Entry, EntryMeta, HookInfo, ModelRefusalFallback,
     PreservedMessages, PreservedSegment, ServerToolUse, StopHookSummary, SystemDetail,
     ToolResultBlock, TurnDuration, Usage, UserEntry,
 };
+use crate::value::{field, field_str};
 
 const SIZE_UNITS: [&str; 5] = ["B", "KB", "MB", "GB", "TB"];
 const BLANK_TIME: &str = "        ";
@@ -435,14 +438,15 @@ 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, and the user's AskUserQuestion answers, in order (render.py
-/// render_turn). Prose clips to `budget.turn_chars`; each tool call and answer
+/// render_turn). With `tool_results`, each other result follows its call. 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 {
+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 questions: HashSet<&str> = HashSet::new();
+    let mut calls: HashMap<&str, &str> = HashMap::new();
     for &event in &turn.events {
         match event {
             Entry::Assistant(assistant) => {
@@ -452,9 +456,7 @@ pub fn render_turn(turn: &Turn, budget: &Budget) -> String {
                             parts.push(format!("assistant: {}", clip(text, budget.turn_chars)));
                         }
                         ContentBlock::ToolUse(tool_use) => {
-                            if tool_use.name == ASK_USER_QUESTION {
-                                questions.insert(&tool_use.id);
-                            }
+                            calls.insert(&tool_use.id, &tool_use.name);
                             parts.push(render_tool_call(
                                 &parse_tool_call(&tool_use.name, &tool_use.input),
                                 budget,
@@ -465,17 +467,13 @@ pub fn render_turn(turn: &Turn, budget: &Budget) -> String {
                 }
             }
             Entry::User(user) => {
-                parts.extend(user.blocks().iter().filter_map(|block| match block {
-                    ContentBlock::ToolResult(result)
-                        if !result.is_error && questions.contains(result.tool_use_id.as_str()) =>
-                    {
-                        Some(format!(
-                            "user answered: {}",
-                            clip(&result.content, budget.tool_chars)
-                        ))
+                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, tool_results));
+                        }
                     }
-                    _ => None,
-                }));
+                }
             }
             Entry::Attachment(attachment) => {
                 if let Some(prompt) = human_queued_prompt(&attachment.detail) {
@@ -488,6 +486,86 @@ pub fn render_turn(turn: &Turn, budget: &Budget) -> String {
     parts.join("\n")
 }
 
+fn result_lines(
+    name: &str,
+    result: &ToolResultBlock,
+    budget: &Budget,
+    tool_results: bool,
+) -> Vec<String> {
+    if result.is_error {
+        if !tool_results {
+            return Vec::new();
+        }
+        return vec![format!(
+            "failed: {}",
+            clip(&result.content, budget.turn_chars)
+        )];
+    }
+    if name == ASK_USER_QUESTION {
+        if let Some(ToolResult::AskUserQuestion(answer)) = result
+            .tool_use_result
+            .as_ref()
+            .map(|payload| parse_tool_result(name, payload))
+        {
+            return answer_lines(&answer, budget);
+        }
+        return vec![format!(
+            "user answered: {}",
+            clip(&result.content, budget.tool_chars)
+        )];
+    }
+    if !tool_results || pystr::strip(&result.content).is_empty() {
+        return Vec::new();
+    }
+    vec![format!(
+        "result: {}",
+        clip(&result.content, budget.turn_chars)
+    )]
+}
+
+fn answer_lines(answer: &AskUserQuestionResult, budget: &Budget) -> Vec<String> {
+    let mut lines = Vec::new();
+    for (question, label) in &answer.answers {
+        let option = chosen_option(&answer.raw, question, label);
+        let annotation = answer
+            .annotations
+            .iter()
+            .find_map(|(asked, annotation)| (asked == question).then_some(annotation));
+        lines.push(format!(
+            "user answered: {} -> {}",
+            clip(question, budget.turn_chars),
+            clip(label, budget.turn_chars)
+        ));
+        if let Some(description) = option.and_then(|option| field_str(option, "description")) {
+            lines.push(format!(
+                "  option: {}",
+                clip(description, budget.turn_chars)
+            ));
+        }
+        let preview = annotation
+            .and_then(|annotation| annotation.preview.as_deref())
+            .or_else(|| option.and_then(|option| field_str(option, "preview")));
+        if let Some(preview) = preview {
+            lines.push(format!("  preview: {}", clip(preview, budget.tool_chars)));
+        }
+        if let Some(notes) = annotation.and_then(|annotation| annotation.notes.as_deref()) {
+            lines.push(format!("  notes: {}", clip(notes, budget.turn_chars)));
+        }
+    }
+    lines
+}
+
+fn chosen_option<'a>(payload: &'a Value, question: &str, label: &str) -> Option<&'a Value> {
+    field(payload, "questions")?
+        .as_array()?
+        .iter()
+        .find(|asked| field_str(asked, "question") == Some(question))
+        .and_then(|asked| field(asked, "options"))
+        .and_then(JsonContainerTrait::as_array)?
+        .iter()
+        .find(|option| field_str(option, "label") == Some(label))
+}
+
 pub(crate) fn human_queued_prompt(detail: &AttachmentDetail) -> Option<&str> {
     match detail {
         AttachmentDetail::QueuedCommand(queued)

{cc_transcript-14.20.1 → cc_transcript-14.22.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,
     ))
 }