Add ANSI escape code sanitization and content-block array rendering

- Add strip_ansi() function to remove ANSI escape sequences from terminal output
- Add is_content_block_array() to detect JSON arrays of content blocks
- Add render_content_block_array() to properly render content blocks in tool results
- Tool results containing ANSI codes now display cleanly without escape sequences
- Tool results containing JSON arrays of content blocks now render as markdown text
  instead of raw JSON

This fixes two critical UX issues where terminal output was unreadable due to
visible ANSI codes, and tool replies showed raw JSON instead of rendered content.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: ShlomoStept

pyproject.toml

@@ -32,6 +32,7 @@ build-backend = "uv_build"
 
 [dependency-groups]
 dev = [
+    "black>=24.0.0",
     "pytest>=9.0.2",
     "pytest-httpx>=0.35.0",
     "syrupy>=5.0.0",

src/claude_code_transcripts/__init__.py

@@ -48,6 +48,79 @@ def get_template(name):
     300  # Characters - text blocks longer than this are shown in index
 )
 
+# Regex to strip ANSI escape sequences from terminal output
+ANSI_ESCAPE_PATTERN = re.compile(r"\x1b\[[0-9;]*[a-zA-Z]")
+
+
+def strip_ansi(text):
+    """Strip ANSI escape sequences from terminal output.
+
+    Args:
+        text: String that may contain ANSI escape codes.
+
+    Returns:
+        The text with all ANSI escape sequences removed.
+    """
+    if not text:
+        return text
+    return ANSI_ESCAPE_PATTERN.sub("", text)
+
+
+def is_content_block_array(text):
+    """Check if a string is a JSON array of content blocks.
+
+    Args:
+        text: String to check.
+
+    Returns:
+        True if the string is a valid JSON array of content blocks.
+    """
+    if not text or not isinstance(text, str):
+        return False
+    text = text.strip()
+    if not (text.startswith("[") and text.endswith("]")):
+        return False
+    try:
+        parsed = json.loads(text)
+        if not isinstance(parsed, list):
+            return False
+        # Check if items look like content blocks
+        for item in parsed:
+            if isinstance(item, dict) and "type" in item:
+                return True
+        return False
+    except (json.JSONDecodeError, TypeError):
+        return False
+
+
+def render_content_block_array(blocks):
+    """Render an array of content blocks.
+
+    Args:
+        blocks: List of content block dicts.
+
+    Returns:
+        HTML string with all blocks rendered.
+    """
+    parts = []
+    for block in blocks:
+        if not isinstance(block, dict):
+            continue
+        block_type = block.get("type", "")
+        if block_type == "text":
+            text = block.get("text", "")
+            # Render as markdown
+            parts.append(render_markdown_text(text))
+        elif block_type == "thinking":
+            thinking = block.get("thinking", "")
+            parts.append(render_markdown_text(thinking))
+        else:
+            # For other types, just show as formatted text
+            text = block.get("text", block.get("content", ""))
+            if text:
+                parts.append(f"<pre>{html.escape(str(text))}</pre>")
+    return "".join(parts) if parts else None
+
 
 def extract_text_from_content(content):
     """Extract plain text from message content.
@@ -711,32 +784,47 @@ def render_content_block(block):
 
         # Check for git commits and render with styled cards
         if isinstance(content, str):
-            commits_found = list(COMMIT_PATTERN.finditer(content))
-            if commits_found:
-                # Build commit cards + remaining content
-                parts = []
-                last_end = 0
-                for match in commits_found:
-                    # Add any content before this commit
-                    before = content[last_end : match.start()].strip()
-                    if before:
-                        parts.append(f"<pre>{html.escape(before)}</pre>")
-
-                    commit_hash = match.group(1)
-                    commit_msg = match.group(2)
-                    parts.append(
-                        _macros.commit_card(commit_hash, commit_msg, _github_repo)
-                    )
-                    last_end = match.end()
-
-                # Add any remaining content after last commit
-                after = content[last_end:].strip()
-                if after:
-                    parts.append(f"<pre>{html.escape(after)}</pre>")
-
-                content_html = "".join(parts)
+            # First, check if content is a JSON array of content blocks
+            if is_content_block_array(content):
+                try:
+                    parsed_blocks = json.loads(content)
+                    rendered = render_content_block_array(parsed_blocks)
+                    if rendered:
+                        content_html = rendered
+                    else:
+                        content_html = format_json(content)
+                except (json.JSONDecodeError, TypeError):
+                    content_html = format_json(content)
             else:
-                content_html = f"<pre>{html.escape(content)}</pre>"
+                # Strip ANSI escape sequences from terminal output
+                content = strip_ansi(content)
+
+                commits_found = list(COMMIT_PATTERN.finditer(content))
+                if commits_found:
+                    # Build commit cards + remaining content
+                    parts = []
+                    last_end = 0
+                    for match in commits_found:
+                        # Add any content before this commit
+                        before = content[last_end : match.start()].strip()
+                        if before:
+                            parts.append(f"<pre>{html.escape(before)}</pre>")
+
+                        commit_hash = match.group(1)
+                        commit_msg = match.group(2)
+                        parts.append(
+                            _macros.commit_card(commit_hash, commit_msg, _github_repo)
+                        )
+                        last_end = match.end()
+
+                    # Add any remaining content after last commit
+                    after = content[last_end:].strip()
+                    if after:
+                        parts.append(f"<pre>{html.escape(after)}</pre>")
+
+                    content_html = "".join(parts)
+                else:
+                    content_html = f"<pre>{html.escape(content)}</pre>"
         elif isinstance(content, list) or is_json_like(content):
             content_html = format_json(content)
         else:

tests/__snapshots__/test_generate_html/TestRenderContentBlock.test_tool_result_content_block_array.html

@@ -0,0 +1,3 @@
+<div class="tool-result"><div class="truncatable"><div class="truncatable-content"><p>Here is the file content:</p>
+<p>Line 1
+Line 2</p></div><button class="expand-btn">Show more</button></div></div>

tests/__snapshots__/test_generate_html/TestRenderContentBlock.test_tool_result_with_ansi_codes.html

@@ -0,0 +1,2 @@
+<div class="tool-result"><div class="truncatable"><div class="truncatable-content"><pre>Tests passed: ✓ All 5 tests passed
+Error: None</pre></div><button class="expand-btn">Show more</button></div></div>

tests/test_generate_html.py

@@ -302,6 +302,39 @@ def test_tool_result_with_commit(self, snapshot_html):
         finally:
             claude_code_transcripts._github_repo = old_repo
 
+    def test_tool_result_with_ansi_codes(self, snapshot_html):
+        """Test that ANSI escape codes are stripped from tool results."""
+        block = {
+            "type": "tool_result",
+            "content": "\x1b[38;2;166;172;186mTests passed:\x1b[0m \x1b[32m✓\x1b[0m All 5 tests passed\n\x1b[1;31mError:\x1b[0m None",
+            "is_error": False,
+        }
+        result = render_content_block(block)
+        # ANSI codes should be stripped
+        assert "\x1b[" not in result
+        assert "[38;2;" not in result
+        assert "[32m" not in result
+        assert "[0m" not in result
+        # Content should still be present
+        assert "Tests passed:" in result
+        assert "All 5 tests passed" in result
+        assert result == snapshot_html
+
+    def test_tool_result_content_block_array(self, snapshot_html):
+        """Test that tool_result with content-block array is rendered properly."""
+        block = {
+            "type": "tool_result",
+            "content": '[{"type": "text", "text": "Here is the file content:\\n\\nLine 1\\nLine 2"}]',
+            "is_error": False,
+        }
+        result = render_content_block(block)
+        # Should render as text, not raw JSON
+        assert "Here is the file content" in result
+        assert "Line 1" in result
+        # Should not show raw JSON structure
+        assert '"type": "text"' not in result
+        assert result == snapshot_html
+
 
 class TestAnalyzeConversation:
     """Tests for conversation analysis."""