chore: more organization

damassi · damassi · commit 24354b04f001 · 2025-12-14T21:48:38.000-08:00
diff --git a/docs/architecture.md b/docs/architecture.md
@@ -10,7 +10,7 @@ src/agent_chat_cli/
 ├── core/
 │   ├── actions.py             # User action handlers
 │   ├── agent_loop.py          # Claude Agent SDK client wrapper
-│   ├── message_bus.py         # Message routing from agent to UI
+│   ├── renderer.py              # Message routing from agent to UI
 │   ├── ui_state.py            # Centralized UI state management
 │   └── styles.tcss            # Textual CSS styles
 ├── components/
@@ -43,7 +43,7 @@ The application follows a loosely coupled architecture with four main orchestrat
 ┌─────────────────────────────────────────────────────────────┐
 │                     AgentChatCLIApp                         │
 │  ┌───────────┐  ┌───────────┐  ┌─────────┐  ┌───────────┐  │
-│  │  UIState  │  │MessageBus │  │ Actions │  │ AgentLoop │  │
+│  │  UIState  │  │  Renderer   │  │ Actions │  │ AgentLoop │  │
 │  └─────┬─────┘  └─────┬─────┘  └────┬────┘  └─────┬─────┘  │
 │        │              │             │              │        │
 │        └──────────────┴─────────────┴──────────────┘        │
@@ -63,9 +63,9 @@ Centralized management of UI state behaviors. Handles:
 - Tool permission prompt display/hide
 - Interrupt state tracking
 
-This class was introduced in PR #9 to consolidate scattered UI state logic from Actions and MessageBus into a single cohesive module.
+This class was introduced in PR #9 to consolidate scattered UI state logic from Actions and Renderer into a single cohesive module.
 
-**MessageBus** (`core/message_bus.py`)
+**Renderer** (`core/renderer.py`)
 Routes messages from the AgentLoop to appropriate UI components:
 - `STREAM_EVENT`: Streaming text chunks to AgentMessage widgets
 - `ASSISTANT`: Complete assistant responses with tool use blocks
@@ -92,7 +92,7 @@ Manages the Claude Agent SDK client lifecycle:
 1. User types in `UserInput` and presses Enter
 2. `Actions.submit_user_message()` posts to UI and enqueues to `AgentLoop.query_queue`
 3. `AgentLoop` sends query to Claude Agent SDK and streams responses
-4. Responses flow through `MessageBus.handle_agent_message()` to update UI
+4. Responses flow through `Actions.render_message()` to update UI
 5. Tool use triggers permission prompt via `UIState.show_permission_prompt()`
 6. User response flows back through `Actions.respond_to_tool_permission()`
 
diff --git a/src/agent_chat_cli/app.py b/src/agent_chat_cli/app.py
@@ -10,7 +10,7 @@
 from agent_chat_cli.components.tool_permission_prompt import ToolPermissionPrompt
 from agent_chat_cli.components.user_input import UserInput
 from agent_chat_cli.core.agent_loop import AgentLoop
-from agent_chat_cli.core.message_bus import MessageBus
+from agent_chat_cli.core.renderer import Renderer
 from agent_chat_cli.core.actions import Actions
 from agent_chat_cli.core.ui_state import UIState
 from agent_chat_cli.utils.logger import setup_logging
@@ -34,7 +34,7 @@ def __init__(self) -> None:
         super().__init__()
 
         self.ui_state = UIState(app=self)
-        self.message_bus = MessageBus(app=self)
+        self.renderer = Renderer(app=self)
         self.actions = Actions(app=self)
         self.agent_loop = AgentLoop(app=self)
 
diff --git a/src/agent_chat_cli/core/actions.py b/src/agent_chat_cli/core/actions.py
@@ -1,8 +1,5 @@
-import asyncio
 from typing import TYPE_CHECKING
 
-from textual.containers import VerticalScroll
-
 from agent_chat_cli.utils.enums import ControlCommand
 from agent_chat_cli.components.chat_history import ChatHistory
 from agent_chat_cli.components.messages import Message, MessageType
@@ -33,23 +30,19 @@ async def add_message_to_chat(self, type: MessageType, content: str) -> None:
 
         chat_history = self.app.query_one(ChatHistory)
         chat_history.add_message(message)
-        await self._scroll_to_bottom()
-
-    async def _scroll_to_bottom(self) -> None:
-        await asyncio.sleep(0.1)
-        container = self.app.query_one(VerticalScroll)
-        container.scroll_end(animate=False, immediate=True)
 
     async def submit_user_message(self, message: str) -> None:
-        await self.add_message_to_chat(MessageType.USER, message)
+        chat_history = self.app.query_one(ChatHistory)
+        chat_history.add_message(Message.user(message))
         self.app.ui_state.start_thinking()
+        await self.app.ui_state.scroll_to_bottom()
         await self._query(message)
 
     async def post_system_message(self, message: str) -> None:
         await self.add_message_to_chat(MessageType.SYSTEM, message)
 
-    async def handle_agent_message(self, message) -> None:
-        await self.app.message_bus.handle_agent_message(message)
+    async def render_message(self, message) -> None:
+        await self.app.renderer.render_message(message)
 
     async def interrupt(self) -> None:
         permission_prompt = self.app.query_one(ToolPermissionPrompt)
diff --git a/src/agent_chat_cli/core/agent_loop.py b/src/agent_chat_cli/core/agent_loop.py
@@ -92,7 +92,7 @@ async def start(self) -> None:
 
                 await self._handle_message(message)
 
-            await self.app.actions.handle_agent_message(
+            await self.app.actions.render_message(
                 AgentMessage(type=AgentMessageType.RESULT, data=None)
             )
 
@@ -135,7 +135,7 @@ async def _handle_message(self, message: Message) -> None:
                     text_chunk = delta.get("text", "")
 
                     if text_chunk:
-                        await self.app.actions.handle_agent_message(
+                        await self.app.actions.render_message(
                             AgentMessage(
                                 type=AgentMessageType.STREAM_EVENT,
                                 data={"text": text_chunk},
@@ -163,7 +163,7 @@ async def _handle_message(self, message: Message) -> None:
                         )
 
             # Finally, post the agent assistant response
-            await self.app.actions.handle_agent_message(
+            await self.app.actions.render_message(
                 AgentMessage(
                     type=AgentMessageType.ASSISTANT,
                     data={"content": content},
@@ -180,7 +180,7 @@ async def _can_use_tool(
 
         # Handle permission request queue sequentially
         async with self.permission_lock:
-            await self.app.actions.handle_agent_message(
+            await self.app.actions.render_message(
                 AgentMessage(
                     type=AgentMessageType.TOOL_PERMISSION_REQUEST,
                     data={
diff --git a/src/agent_chat_cli/core/renderer.py b/src/agent_chat_cli/core/renderer.py
@@ -1,8 +1,7 @@
-import asyncio
+from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
 from textual.widgets import Markdown
-from textual.containers import VerticalScroll
 
 from agent_chat_cli.components.chat_history import ChatHistory
 from agent_chat_cli.components.messages import (
@@ -18,68 +17,76 @@
     from agent_chat_cli.app import AgentChatCLIApp
 
 
-class MessageBus:
+@dataclass
+class StreamBuffer:
+    widget: AgentMessageWidget | None = None
+    text: str = ""
+
+    def reset(self) -> None:
+        self.widget = None
+        self.text = ""
+
+
+class Renderer:
     def __init__(self, app: "AgentChatCLIApp") -> None:
         self.app = app
-        self.current_agent_message: AgentMessageWidget | None = None
-        self.current_response_text = ""
+        self._stream = StreamBuffer()
 
-    async def handle_agent_message(self, message: AgentMessage) -> None:
+    async def render_message(self, message: AgentMessage) -> None:
         match message.type:
             case AgentMessageType.STREAM_EVENT:
-                await self._handle_stream_event(message)
+                await self._render_stream_event(message)
 
             case AgentMessageType.ASSISTANT:
-                await self._handle_assistant(message)
+                await self._render_assistant_message(message)
 
             case AgentMessageType.SYSTEM:
-                await self._handle_system(message)
+                await self._render_system_message(message)
 
             case AgentMessageType.USER:
-                await self._handle_user(message)
+                await self._render_user_message(message)
 
             case AgentMessageType.TOOL_PERMISSION_REQUEST:
-                await self._handle_tool_permission_request(message)
+                await self._render_tool_permission_request(message)
 
             case AgentMessageType.RESULT:
-                await self._handle_result()
+                await self._on_complete()
 
-    async def _handle_stream_event(self, message: AgentMessage) -> None:
+        if message.type is not AgentMessageType.RESULT:
+            await self.app.ui_state.scroll_to_bottom()
+
+    async def _render_stream_event(self, message: AgentMessage) -> None:
         text_chunk = message.data.get("text", "")
 
         if not text_chunk:
             return
 
         chat_history = self.app.query_one(ChatHistory)
 
-        if self.current_agent_message is None:
-            self.current_response_text = text_chunk
+        if self._stream.widget is None:
+            self._stream.text = text_chunk
 
             agent_msg = AgentMessageWidget()
             agent_msg.message = text_chunk
 
-            # Append to chat history
-            chat_history.mount(agent_msg)
-            self.current_agent_message = agent_msg
+            await chat_history.mount(agent_msg)
+            self._stream.widget = agent_msg
         else:
-            self.current_response_text += text_chunk
-
-            markdown = self.current_agent_message.query_one(Markdown)
-            markdown.update(self.current_response_text)
+            self._stream.text += text_chunk
 
-        await self._scroll_to_bottom()
+            markdown = self._stream.widget.query_one(Markdown)
+            markdown.update(self._stream.text)
 
-    async def _handle_assistant(self, message: AgentMessage) -> None:
+    async def _render_assistant_message(self, message: AgentMessage) -> None:
         content_blocks = message.data.get("content", [])
         chat_history = self.app.query_one(ChatHistory)
 
         for block in content_blocks:
             block_type = block.get("type")
 
             if block_type == ContentType.TOOL_USE.value:
-                if self.current_agent_message is not None:
-                    self.current_agent_message = None
-                    self.current_response_text = ""
+                if self._stream.widget is not None:
+                    self._stream.reset()
 
                 tool_name = block.get("name", "unknown")
                 tool_input = block.get("input", {})
@@ -88,24 +95,23 @@ async def _handle_assistant(self, message: AgentMessage) -> None:
                 tool_msg.tool_name = tool_name
                 tool_msg.tool_input = tool_input
 
-                # Append to chat history
-                chat_history.mount(tool_msg)
-
-                await self._scroll_to_bottom()
+                await chat_history.mount(tool_msg)
 
-    async def _handle_system(self, message: AgentMessage) -> None:
+    async def _render_system_message(self, message: AgentMessage) -> None:
         system_content = (
             message.data if isinstance(message.data, str) else str(message.data)
         )
+
         await self.app.actions.add_message_to_chat(MessageType.SYSTEM, system_content)
 
-    async def _handle_user(self, message: AgentMessage) -> None:
+    async def _render_user_message(self, message: AgentMessage) -> None:
         user_content = (
             message.data if isinstance(message.data, str) else str(message.data)
         )
+
         await self.app.actions.add_message_to_chat(MessageType.USER, user_content)
 
-    async def _handle_tool_permission_request(self, message: AgentMessage) -> None:
+    async def _render_tool_permission_request(self, message: AgentMessage) -> None:
         log_json(
             {
                 "event": "showing_permission_prompt",
@@ -118,19 +124,9 @@ async def _handle_tool_permission_request(self, message: AgentMessage) -> None:
             tool_input=message.data.get("tool_input", {}),
         )
 
-        await self._scroll_to_bottom()
-
-    async def _handle_result(self) -> None:
+    async def _on_complete(self) -> None:
         if not self.app.agent_loop.query_queue.empty():
             return
 
         self.app.ui_state.stop_thinking()
-
-        self.current_agent_message = None
-        self.current_response_text = ""
-
-    async def _scroll_to_bottom(self) -> None:
-        await asyncio.sleep(0.1)
-
-        container = self.app.query_one(VerticalScroll)
-        container.scroll_end(animate=False, immediate=True)
+        self._stream.reset()
diff --git a/src/agent_chat_cli/core/ui_state.py b/src/agent_chat_cli/core/ui_state.py
@@ -1,5 +1,7 @@
+import asyncio
 from typing import TYPE_CHECKING, Any
 
+from textual.containers import VerticalScroll
 from textual.widgets import TextArea
 
 from agent_chat_cli.components.thinking_indicator import ThinkingIndicator
@@ -69,3 +71,8 @@ def clear_input(self) -> None:
         user_input = self.app.query_one(UserInput)
         input_widget = user_input.query_one(TextArea)
         input_widget.clear()
+
+    async def scroll_to_bottom(self) -> None:
+        await asyncio.sleep(0.1)
+        container = self.app.query_one(VerticalScroll)
+        container.scroll_end(animate=False, immediate=True)
diff --git a/src/agent_chat_cli/docs/architecture.md b/src/agent_chat_cli/docs/architecture.md
@@ -30,7 +30,7 @@ Manages the conversation loop with Claude SDK:
 - Uses `permission_lock` (asyncio.Lock) to serialize parallel permission requests
 - Manages `permission_response_queue` for user responses to tool permission prompts
 
-#### Message Bus (`system/message_bus.py`)
+#### Renderer (`core/renderer.py`)
 Routes agent messages to appropriate UI components:
 - Handles streaming text updates
 - Mounts tool use messages
@@ -82,7 +82,7 @@ Claude SDK (all enabled servers pre-connected at startup)
     ↓
 AgentLoop._handle_message
     ↓
-AgentMessage (typed message) → MessageBus.handle_agent_message
+AgentMessage (typed message) → Actions.render_message
     ↓
 Match on AgentMessageType:
     - STREAM_EVENT → Update streaming message widget
@@ -182,7 +182,7 @@ AgentLoop._can_use_tool (callback with permission_lock acquired)
     ↓
 Emit SYSTEM AgentMessage with tool_permission_request data
     ↓
-MessageBus._handle_system detects permission request
+Renderer._handle_tool_permission_request shows permission prompt
     ↓
 Show ToolPermissionPrompt, hide UserInput
     ↓
@@ -305,14 +305,14 @@ SDK reconnects to previous session with full history
 ### Agent Response Flow
 1. AgentLoop receives SDK message
 2. Parse into AgentMessage with AgentMessageType
-3. MessageBus.handle_agent_message (match/case on type)
+3. Actions.render_message → Renderer (match/case on type)
 4. Update UI components based on type
 5. Scroll to bottom
 
 ## Notes
 
 - Two distinct MessageType enums exist for different purposes (UI vs Agent events)
-- Message bus manages stateful streaming (tracks current_agent_message)
+- Renderer manages stateful streaming via StreamBuffer
 - Config loading combines multiple prompts into final system_prompt
 - Tool names follow format: `mcp__servername__toolname`
 - Actions class provides single interface for all user-initiated operations
diff --git a/tests/core/test_agent_loop.py b/tests/core/test_agent_loop.py
diff --git a/tests/core/test_renderer.py b/tests/core/test_renderer.py
