Strip encrypted thinking signatures and unknown-block JSON dumps from output

The parser used to render any unrecognized content block by JSON-dumping it whole.
This leaked extended-thinking 'signature' fields — multi-kilobyte base64 blobs that
are encrypted attestation data, useless to humans, and noisy to the point of
making exported sessions unreadable.

- thinking blocks with empty body are skipped entirely
- thinking blocks with visible reasoning text are preserved and wrapped in
  italic <thinking> markers so they're distinguishable from the assistant reply
- redacted_thinking blocks are dropped (encrypted-only)
- image blocks render as [image] (no base64)
- unknown future block types render as a short [type] placeholder, not a JSON dump

Adds 5 tests covering the noise-stripping behaviour. 55/55 pass.

Author: sedelev

claude_backup/parser.py

@@ -137,25 +137,44 @@ def extract_session_title(jsonl_path: Path) -> str:
 
 
 def _normalize_content(content) -> str:
-    """Flatten content into a string. Handles list-of-blocks shape too."""
+    """Flatten Claude content blocks into plain text.
+
+    Handles: plain strings, text blocks, tool_use, tool_result, and image blocks.
+    Skips empty extended-thinking blocks (which contain only encrypted signatures —
+    huge base64 blobs that aren't useful to humans). Non-empty thinking text is
+    preserved in italics.
+    """
     if isinstance(content, str):
         return content
     if isinstance(content, list):
         parts: list[str] = []
         for block in content:
             if isinstance(block, str):
                 parts.append(block)
-            elif isinstance(block, dict):
-                if "text" in block and isinstance(block["text"], str):
-                    parts.append(block["text"])
-                elif block.get("type") == "tool_use":
-                    name = block.get("name", "tool")
-                    parts.append(f"[tool_use: {name}]")
-                elif block.get("type") == "tool_result":
-                    inner = block.get("content", "")
-                    parts.append(_normalize_content(inner))
-                else:
-                    parts.append(json.dumps(block, ensure_ascii=False))
+                continue
+            if not isinstance(block, dict):
+                continue
+            block_type = block.get("type")
+            if block_type == "text" and isinstance(block.get("text"), str):
+                parts.append(block["text"])
+            elif "text" in block and isinstance(block["text"], str) and not block_type:
+                parts.append(block["text"])
+            elif block_type == "tool_use":
+                name = block.get("name", "tool")
+                parts.append(f"[tool_use: {name}]")
+            elif block_type == "tool_result":
+                inner = block.get("content", "")
+                parts.append(_normalize_content(inner))
+            elif block_type == "thinking":
+                thought = block.get("thinking", "")
+                if isinstance(thought, str) and thought.strip():
+                    parts.append(f"_<thinking>_\n{thought}\n_</thinking>_")
+            elif block_type == "redacted_thinking":
+                continue
+            elif block_type == "image":
+                parts.append("[image]")
+            elif block_type:
+                parts.append(f"[{block_type}]")
         return "\n".join(p for p in parts if p)
     if content is None:
         return ""

tests/test_parser.py

@@ -106,3 +106,71 @@ def test_session_summary(fake_project_path: Path) -> None:
 def test_message_dataclass_default_raw() -> None:
     m = Message(role="user", content="x")
     assert m.raw == {}
+
+
+def test_thinking_block_with_empty_body_is_skipped(tmp_path: Path) -> None:
+    """Encrypted thinking signatures must never leak into the output."""
+    f = tmp_path / "x.jsonl"
+    f.write_text(
+        '{"role":"assistant","content":['
+        '{"type":"thinking","thinking":"","signature":"EpsMSECRET" }'
+        ',{"type":"text","text":"hello"}'
+        ']}\n'
+    )
+    messages = parse_session(f)
+    assert messages[0].content == "hello"
+    assert "EpsM" not in messages[0].content
+    assert "signature" not in messages[0].content
+
+
+def test_thinking_block_with_visible_text_is_preserved(tmp_path: Path) -> None:
+    f = tmp_path / "x.jsonl"
+    f.write_text(
+        '{"role":"assistant","content":['
+        '{"type":"thinking","thinking":"weighing tradeoffs","signature":"sig"}'
+        ',{"type":"text","text":"answer"}'
+        ']}\n'
+    )
+    messages = parse_session(f)
+    assert "weighing tradeoffs" in messages[0].content
+    assert "answer" in messages[0].content
+    assert "sig" not in messages[0].content
+
+
+def test_redacted_thinking_block_is_skipped(tmp_path: Path) -> None:
+    f = tmp_path / "x.jsonl"
+    f.write_text(
+        '{"role":"assistant","content":['
+        '{"type":"redacted_thinking","data":"opaque-encrypted-blob"}'
+        ',{"type":"text","text":"visible"}'
+        ']}\n'
+    )
+    messages = parse_session(f)
+    assert messages[0].content == "visible"
+    assert "opaque" not in messages[0].content
+
+
+def test_image_block_renders_placeholder(tmp_path: Path) -> None:
+    f = tmp_path / "x.jsonl"
+    f.write_text(
+        '{"role":"user","content":['
+        '{"type":"image","source":{"type":"base64","data":"BASE64HUGE"}}'
+        ',{"type":"text","text":"check this"}'
+        ']}\n'
+    )
+    messages = parse_session(f)
+    assert "[image]" in messages[0].content
+    assert "check this" in messages[0].content
+    assert "BASE64" not in messages[0].content
+
+
+def test_unknown_block_type_renders_short_placeholder(tmp_path: Path) -> None:
+    f = tmp_path / "x.jsonl"
+    f.write_text(
+        '{"role":"assistant","content":['
+        '{"type":"some_future_block","payload":{"big":"data"}}'
+        ']}\n'
+    )
+    messages = parse_session(f)
+    assert messages[0].content == "[some_future_block]"
+    assert "payload" not in messages[0].content