Refactor content formatting to use dispatcher pattern #67

cboos · 2025-12-18T22:32:49Z

Replace the if/elif type dispatch chain in HtmlRenderer._format_message_content() with a declarative dispatcher pattern in the base Renderer class:

Add _build_dispatcher() method to base Renderer returning type->formatter mapping
Add format_content() method with MRO walking for automatic fallback to parent handlers
HtmlRenderer overrides _build_dispatcher() with all content type formatters
Complex formatters (UserTextContent, ToolResultContentModel) use instance methods
Simple formatters use lambdas with cast() for type safety

Benefits:

Explicit & declarative - all handlers visible in one dict
MRO-aware fallback - handlers for parent classes serve as defaults
Easy subclass customization via {**super()._build_dispatcher(), ...}
Clean separation - dispatch logic in base, handlers in subclass

🤖 Generated with Claude Code

Summary by CodeRabbit

New Features
- Messages now support interleaved content (text, images, IDE notifications) and slash‑command prompts rendered as collapsible markdown.
Refactor
- Rendering pipeline reorganized to chunk mixed content and dispatch formatting more reliably.
Documentation
- Updated docs to describe the new slash‑command content model and mixed-content semantics.
Tests
- Added tests covering chunking behavior and multi-item message formatting.

_{✏️ Tip: You can customize this high-level summary in your review settings.}

Replace the if/elif type dispatch chain in HtmlRenderer._format_message_content() with a declarative dispatcher pattern in the base Renderer class: - Add _build_dispatcher() method to base Renderer returning type->formatter mapping - Add format_content() method with MRO walking for automatic fallback to parent handlers - HtmlRenderer overrides _build_dispatcher() with all content type formatters - Complex formatters (UserTextContent, ToolResultContentModel) use instance methods - Simple formatters use lambdas with cast() for type safety Benefits: - Explicit & declarative - all handlers visible in one dict - MRO-aware fallback - handlers for parent classes serve as defaults - Easy subclass customization via {**super()._build_dispatcher(), ...} - Clean separation - dispatch logic in base, handlers in subclass 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <[email protected]>

coderabbitai · 2025-12-18T22:32:57Z

Walkthrough

Introduces a dispatcher-based formatting and chunked-content model: Renderer gains init, _build_dispatcher, and format_content; message content is split into chunks and parsed into new content-item models (TextContent/ImageContent/UserSlashCommandContent). HtmlRenderer and HTML formatters switched to dispatcher handlers; parser and models updated for interleaved items.

Changes

Cohort / File(s)	Summary
Core renderer & chunking `claude_code_log/renderer.py`	Added `__init__`, `_build_dispatcher`, `format_content`, `ContentChunk` type, `_is_special_item`, `chunk_message_content`; rewrote `_render_messages` to operate on chunks, added per-chunk TemplateMessage creation and new process* helpers (tool_use/result/thinking); removed image-specific old paths.
HTML rendering & dispatcher `claude_code_log/html/renderer.py`	Replaced monolithic if/elif content formatter with `_build_dispatcher` mapping and `format_content` usage; added `_format_tool_result_content`; replaced `_format_message_content` with dispatcher-driven flow and updated `_flatten_preorder`.
HTML assistant/user formatters `claude_code_log/html/assistant_formatters.py`, `claude_code_log/html/user_formatters.py`	Assistant and User formatters updated to iterate `content.items` and render mixed item types (TextContent, ImageContent, IdeNotificationContent); added `format_user_slash_command_content`; image rendering integrated into user/assistant paths.
Content models `claude_code_log/models.py`	Added `TextContent`, `ImageSource`, `ImageContent`, `UserSlashCommandContent`; changed `UserTextContent` and `AssistantTextContent` to `items: list[...]`; updated AssistantMessage.from_anthropic_message to use list conversion.
Parsing & normalization `claude_code_log/parser.py`	parse_* functions updated to produce itemized content models; `parse_user_message_content` gained `is_slash_command` flow returning `UserSlashCommandContent`; `_parse_text_content` simplified to TextContent.model_validate.
Docs `dev-docs/messages.md`	Documented new `UserSlashCommandContent` and updated examples/comments for isMeta/slash-command flow.
Tests `test/test_renderer.py`, `test/test_user_renderer.py`, `test/test_ide_tags.py`	Added chunking tests for `chunk_message_content`; updated tests to construct/assert on itemized content (`items[0].text`, IdeNotificationContent presence) and updated expectations to item-based models.

Estimated code review effort

🎯 5 (Critical) | ⏱️ ~120+ minutes

Reviewers should focus on:
- Correctness and completeness of dispatcher mappings (_build_dispatcher) across all content types.
- Chunking logic in chunk_message_content and its impact on message ordering, token accounting, and ancestry/uuid derivation.
- Model changes: duplicated/overlapping declarations of TextContent/ImageContent and their public exposure (shadowing/duplicate definitions).
- Parser adaptations to ensure all original Anthropic content cases (thinking, tool_use, images) are preserved and not regressions.
- HTML formatter changes for mixed items and image embedding correctness and security (base64 handling, escaping).
- Tests alignment with new semantics and potential gaps for edge cases (empty items, unknown content types).

Possibly related PRs

Code review for #63 #64 — Major refactor with dispatcher-based rendering, chunking and content-item model additions; likely overlapping changes and goals.
Use Pygments to render files and code snippets #39 — Related changes to renderer dispatch and tool result/tool-use formatting paths; likely shares code-level edits with this PR.

Poem

🐰 I hopped through code and hopped some more,
I sorted items, built a map and door,
From tangled ifs to tidy calls,
Chunks and slash‑commands line the halls,
A carrot for tests — hooray, explore! 🥕

Pre-merge checks and finishing touches

✅ Passed checks (3 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title 'Refactor content formatting to use dispatcher pattern' directly matches the main objective of the pull request: replacing if/elif dispatch with a dispatcher pattern.
Docstring Coverage	✅ Passed	Docstring coverage is 95.12% which is sufficient. The required threshold is 80.00%.

✨ Finishing touches

📝 Generate docstrings

🧪 Generate unit tests (beta)

Create PR with unit tests
Post copyable unit tests in a comment
Commit unit tests in branch dev/render-dispatching

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

This refactoring fixes a bug where user images were lost during rendering and simplifies the message processing pipeline. Key changes: - Add chunk_message_content() to split content into special vs regular chunks - UserTextContent and AssistantTextContent now use items lists to preserve content order (text + images interleaved) - Remove ContentBlock from ContentItem union, use only our own types - Simplify parser to not depend on Anthropic SDK types - Simplify _process_regular_message by filtering empty text in chunking - Move TextContent, ImageContent, ImageSource earlier in models.py 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <[email protected]>

Introduce a dedicated content model for slash command expanded prompts (isMeta=True) instead of reusing UserTextContent. This follows the same pattern as CompactedSummaryContent and UserMemoryContent. Changes: - Add UserSlashCommandContent(text: str) model in models.py - Update parse_user_message_content() to accept is_slash_command param - Add format_user_slash_command_content() formatter - Add dispatcher entry for UserSlashCommandContent - Update _process_regular_message to detect content type - Update dev-docs/messages.md to distinguish isMeta vs tags variants 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <[email protected]>

coderabbitai

Actionable comments posted: 2

Caution

Some comments are outside the diff and can’t be posted inline due to platform limitations.

⚠️ Outside diff range comments (1)

claude_code_log/html/user_formatters.py (1)

194-211: Docstring mentions fallback that isn't implemented.

Similar to assistant_formatters.py, the docstring at lines 200-205 describes "Falls back to legacy text-only behavior when items is None" but the code unconditionally iterates content.items. Either update the docstring or add the fallback logic.

🧹 Nitpick comments (4)

claude_code_log/html/user_formatters.py (1)
213-228: Same pattern issue: else branch assumes TextContent without type verification.

Similar to assistant_formatters.py, the else branch at line 224 assumes any non-IdeNotificationContent, non-ImageContent item is TextContent. If an unexpected type is passed, accessing item.text could fail.

Consider adding an explicit type check for robustness.
🔎 Proposed fix
+from ..models import TextContent  # add to imports if not present
     for item in content.items:
         if isinstance(item, IdeNotificationContent):
             notifications = format_ide_notification_content(item)
             parts.extend(notifications)
         elif isinstance(item, ImageContent):
             parts.append(format_image_content(item))
-        else:  # TextContent
+        elif isinstance(item, TextContent):
             # Regular user text as preformatted
             if item.text.strip():
                 parts.append(format_user_text_content(item.text))
+        # Other types silently skipped
claude_code_log/html/renderer.py (1)

128-140: Consider adding a docstring note about the ToolResultContent vs ToolResultContentModel distinction.

The method creates a ToolResultContent from ToolResultContentModel to delegate to format_tool_result_content. A brief comment explaining why this wrapper exists (the model carries rendering context like file_path and tool_name that the raw ToolResultContent lacks) would help future maintainers.
claude_code_log/renderer.py (2)
2148-2151: UUID generation for multi-chunk messages could benefit from a more deterministic approach.

When a message produces multiple chunks, each chunk gets a UUID like {original_uuid}-chunk-{chunk_idx}. This is reasonable, but if the same message is re-rendered, the UUIDs will match, which is good for consistency. However, consider whether the chunk index should be based on position among all chunks or just among chunks of the same type.

2218-2224: UUID generation for tool messages uses tool_use_id or fallback.

Using tool_use_id when available provides meaningful IDs for tool messages. The fallback {msg_uuid}-tool-{len(template_messages)} ensures uniqueness but depends on the current list length, which could be fragile if the processing order changes. Consider using chunk_idx instead for consistency.
🔎 Suggested improvement for more deterministic tool UUIDs
                 # Generate unique UUID for this tool message
                 # Use tool_use_id if available, otherwise fall back to msg UUID + index
                 tool_uuid = (
                     tool_result.tool_use_id
                     if tool_result.tool_use_id
-                    else f"{msg_uuid}-tool-{len(template_messages)}"
+                    else f"{msg_uuid}-tool-{chunk_idx}"
                 )

📜 Review details

Configuration used: defaults

Review profile: CHILL

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between 0de3d6c and 28730e5.

📒 Files selected for processing (10)

claude_code_log/html/assistant_formatters.py (1 hunks)
claude_code_log/html/renderer.py (5 hunks)
claude_code_log/html/user_formatters.py (3 hunks)
claude_code_log/models.py (6 hunks)
claude_code_log/parser.py (6 hunks)
claude_code_log/renderer.py (9 hunks)
dev-docs/messages.md (3 hunks)
test/test_ide_tags.py (3 hunks)
test/test_renderer.py (1 hunks)
test/test_user_renderer.py (3 hunks)

🧰 Additional context used

📓 Path-based instructions (5)

**/*.py