Merge pull request #9 from damassi/chore/add-ui-state

refactor: Add ui_state for managing ui state behaviors

Author: damassi

src/agent_chat_cli/app.py

@@ -12,6 +12,7 @@
 from agent_chat_cli.core.agent_loop import AgentLoop
 from agent_chat_cli.core.message_bus import MessageBus
 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
 
 from dotenv import load_dotenv
@@ -32,6 +33,7 @@ class AgentChatCLIApp(App):
     def __init__(self) -> None:
         super().__init__()
 
+        self.ui_state = UIState(app=self)
         self.message_bus = MessageBus(app=self)
         self.actions = Actions(app=self)
         self.agent_loop = AgentLoop(app=self)

src/agent_chat_cli/components/tool_permission_prompt.py

@@ -2,8 +2,9 @@
 
 from textual.widget import Widget
 from textual.app import ComposeResult
-from textual.widgets import Label, Input
+from textual.widgets import Label, TextArea
 from textual.reactive import reactive
+from textual.binding import Binding
 
 from agent_chat_cli.components.caret import Caret
 from agent_chat_cli.components.flex import Flex
@@ -20,6 +21,10 @@ class ToolPermissionPrompt(Widget):
     tool_name = reactive("")
     tool_input: dict[str, Any] = reactive({}, init=False)  # type: ignore[assignment]
 
+    BINDINGS = [
+        Binding("enter", "submit", "Submit", priority=True),
+    ]
+
     def __init__(self, actions: "Actions") -> None:
         super().__init__()
         self.actions = actions
@@ -32,14 +37,20 @@ def compose(self) -> ComposeResult:
 
         with Flex():
             yield Caret()
-            yield Input(placeholder="Yes", id="permission-input")
+            yield TextArea(
+                "",
+                show_line_numbers=False,
+                soft_wrap=True,
+                placeholder="Yes",
+                id="permission-input",
+            )
 
     def watch_is_visible(self, is_visible: bool) -> None:
         self.display = is_visible
 
         if is_visible:
-            input_widget = self.query_one("#permission-input", Input)
-            input_widget.value = ""
+            input_widget = self.query_one("#permission-input", TextArea)
+            input_widget.clear()
             input_widget.focus()
 
     def watch_tool_name(self, tool_name: str) -> None:
@@ -59,24 +70,25 @@ def watch_tool_name(self, tool_name: str) -> None:
 
         tool_display_label.update(tool_display)
 
-    async def on_input_submitted(self, event: Input.Submitted) -> None:
-        raw_value = event.value
-        response = event.value.strip() or "yes"
+    async def action_submit(self) -> None:
+        input_widget = self.query_one("#permission-input", TextArea)
+        raw_value = input_widget.text
+        response = raw_value.strip() or "yes"
 
         log_json(
             {
                 "event": "permission_input_submitted",
                 "raw_value": raw_value,
-                "stripped_value": event.value.strip(),
+                "stripped_value": raw_value.strip(),
                 "final_response": response,
             }
         )
 
         await self.actions.respond_to_tool_permission(response)
 
-    async def on_input_blurred(self, event: Input.Blurred) -> None:
+    def on_descendant_blur(self) -> None:
         if self.is_visible:
-            input_widget = self.query_one("#permission-input", Input)
+            input_widget = self.query_one("#permission-input", TextArea)
             input_widget.focus()
 
     async def on_key(self, event) -> None:
@@ -86,7 +98,8 @@ async def on_key(self, event) -> None:
             event.stop()
             event.prevent_default()
 
-            input_widget = self.query_one("#permission-input", Input)
-            input_widget.value = "no"
+            input_widget = self.query_one("#permission-input", TextArea)
+            input_widget.clear()
+            input_widget.insert("no")
 
-            await input_widget.action_submit()
+            await self.action_submit()

src/agent_chat_cli/core/actions.py

@@ -1,11 +1,8 @@
 from typing import TYPE_CHECKING
 
-from textual.widgets import TextArea
-
 from agent_chat_cli.utils.enums import ControlCommand
 from agent_chat_cli.components.chat_history import ChatHistory, MessagePosted
 from agent_chat_cli.components.messages import Message
-from agent_chat_cli.components.thinking_indicator import ThinkingIndicator
 from agent_chat_cli.components.tool_permission_prompt import ToolPermissionPrompt
 from agent_chat_cli.utils.logger import log_json
 
@@ -20,19 +17,10 @@ def __init__(self, app: "AgentChatCLIApp") -> None:
     def quit(self) -> None:
         self.app.exit()
 
-    async def query(self, user_input: str) -> None:
-        await self.app.agent_loop.query_queue.put(user_input)
-
     async def submit_user_message(self, message: str) -> None:
         self.app.post_message(MessagePosted(Message.user(message)))
-
-        thinking_indicator = self.app.query_one(ThinkingIndicator)
-        thinking_indicator.is_thinking = True
-
-        input_widget = self.app.query_one(TextArea)
-        input_widget.cursor_blink = False
-
-        await self.query(message)
+        self.app.ui_state.start_thinking()
+        await self._query(message)
 
     def post_system_message(self, message: str) -> None:
         self.app.post_message(MessagePosted(Message.system(message)))
@@ -45,24 +33,19 @@ async def interrupt(self) -> None:
         if permission_prompt.is_visible:
             return
 
-        self.app.agent_loop.interrupting = True
+        self.app.ui_state.set_interrupting(True)
         await self.app.agent_loop.client.interrupt()
-
-        thinking_indicator = self.app.query_one(ThinkingIndicator)
-        thinking_indicator.is_thinking = False
+        self.app.ui_state.stop_thinking()
 
     async def new(self) -> None:
         await self.app.agent_loop.query_queue.put(ControlCommand.NEW_CONVERSATION)
 
         chat_history = self.app.query_one(ChatHistory)
         await chat_history.remove_children()
 
-        thinking_indicator = self.app.query_one(ThinkingIndicator)
-        thinking_indicator.is_thinking = False
+        self.app.ui_state.stop_thinking()
 
     async def respond_to_tool_permission(self, response: str) -> None:
-        from agent_chat_cli.components.user_input import UserInput
-
         log_json(
             {
                 "event": "permission_response_action",
@@ -72,23 +55,15 @@ async def respond_to_tool_permission(self, response: str) -> None:
 
         await self.app.agent_loop.permission_response_queue.put(response)
 
-        permission_prompt = self.app.query_one(ToolPermissionPrompt)
-        permission_prompt.is_visible = False
-
-        user_input = self.app.query_one(UserInput)
-        user_input.display = True
-
-        input_widget = self.app.query_one(TextArea)
-        input_widget.focus()
+        self.app.ui_state.hide_permission_prompt()
+        self.app.ui_state.start_thinking()
 
-        thinking_indicator = self.app.query_one(ThinkingIndicator)
-        thinking_indicator.is_thinking = True
-        input_widget.cursor_blink = False
-
-        # Check if it's a deny or custom response (anything except yes/allow)
         normalized = response.lower().strip()
         if normalized not in ["y", "yes", "allow", ""]:
             if normalized in ["n", "no", "deny"]:
-                await self.query("The user has denied the tool")
+                await self._query("The user has denied the tool")
             else:
                 await self.submit_user_message(response)
+
+    async def _query(self, user_input: str) -> None:
+        await self.app.agent_loop.query_queue.put(user_input)

src/agent_chat_cli/core/agent_loop.py

@@ -55,7 +55,6 @@ def __init__(
         self.permission_lock = asyncio.Lock()
 
         self._running = False
-        self.interrupting = False
 
     async def start(self) -> None:
         mcp_servers = {
@@ -81,12 +80,12 @@ async def start(self) -> None:
                     await self._initialize_client(mcp_servers=mcp_servers)
                 continue
 
-            self.interrupting = False
+            self.app.ui_state.set_interrupting(False)
 
             await self.client.query(user_input)
 
             async for message in self.client.receive_response():
-                if self.interrupting:
+                if self.app.ui_state.interrupting:
                     continue
 
                 await self._handle_message(message)

src/agent_chat_cli/core/message_bus.py

@@ -1,12 +1,10 @@
 import asyncio
 from typing import TYPE_CHECKING
 
-from textual.widgets import Markdown, TextArea
+from textual.widgets import Markdown
 from textual.containers import VerticalScroll
 
 from agent_chat_cli.components.chat_history import ChatHistory, MessagePosted
-from agent_chat_cli.components.thinking_indicator import ThinkingIndicator
-from agent_chat_cli.components.tool_permission_prompt import ToolPermissionPrompt
 from agent_chat_cli.components.messages import (
     AgentMessage as AgentMessageWidget,
     Message,
@@ -46,11 +44,11 @@ async def handle_agent_message(self, message: AgentMessage) -> None:
             case AgentMessageType.RESULT:
                 await self._handle_result()
 
-    async def _scroll_to_bottom(self) -> None:
-        await asyncio.sleep(0.1)
+    async def on_message_posted(self, event: MessagePosted) -> None:
+        chat_history = self.app.query_one(ChatHistory)
+        chat_history.add_message(event.message)
 
-        container = self.app.query_one(VerticalScroll)
-        container.scroll_end(animate=False, immediate=True)
+        await self._scroll_to_bottom()
 
     async def _handle_stream_event(self, message: AgentMessage) -> None:
         text_chunk = message.data.get("text", "")
@@ -121,45 +119,31 @@ async def _handle_user(self, message: AgentMessage) -> None:
         await self._scroll_to_bottom()
 
     async def _handle_tool_permission_request(self, message: AgentMessage) -> None:
-        from agent_chat_cli.components.user_input import UserInput
-
         log_json(
             {
                 "event": "showing_permission_prompt",
                 "tool_name": message.data.get("tool_name", ""),
             }
         )
 
-        thinking_indicator = self.app.query_one(ThinkingIndicator)
-        thinking_indicator.is_thinking = False
-
-        permission_prompt = self.app.query_one(ToolPermissionPrompt)
-        permission_prompt.tool_name = message.data.get("tool_name", "")
-        permission_prompt.tool_input = message.data.get("tool_input", {})
-        permission_prompt.is_visible = True
-
-        user_input = self.app.query_one(UserInput)
-        user_input.display = False
+        self.app.ui_state.show_permission_prompt(
+            tool_name=message.data.get("tool_name", ""),
+            tool_input=message.data.get("tool_input", {}),
+        )
 
         await self._scroll_to_bottom()
 
     async def _handle_result(self) -> None:
-        # Check if there's a queued message (e.g., from custom permission response)
         if not self.app.agent_loop.query_queue.empty():
-            # Don't turn off thinking - there's more work to do
             return
 
-        thinking_indicator = self.app.query_one(ThinkingIndicator)
-        thinking_indicator.is_thinking = False
-
-        input_widget = self.app.query_one(TextArea)
-        input_widget.cursor_blink = True
+        self.app.ui_state.stop_thinking()
 
         self.current_agent_message = None
         self.current_response_text = ""
 
-    async def on_message_posted(self, event: MessagePosted) -> None:
-        chat_history = self.app.query_one(ChatHistory)
-        chat_history.add_message(event.message)
+    async def _scroll_to_bottom(self) -> None:
+        await asyncio.sleep(0.1)
 
-        await self._scroll_to_bottom()
+        container = self.app.query_one(VerticalScroll)
+        container.scroll_end(animate=False, immediate=True)

src/agent_chat_cli/core/ui_state.py

@@ -0,0 +1,65 @@
+from typing import TYPE_CHECKING, Any
+
+from textual.widgets import TextArea
+
+from agent_chat_cli.components.thinking_indicator import ThinkingIndicator
+from agent_chat_cli.components.tool_permission_prompt import ToolPermissionPrompt
+
+if TYPE_CHECKING:
+    from agent_chat_cli.app import AgentChatCLIApp
+
+
+class UIState:
+    def __init__(self, app: "AgentChatCLIApp") -> None:
+        self.app = app
+        self._interrupting = False
+
+    @property
+    def interrupting(self) -> bool:
+        return self._interrupting
+
+    def set_interrupting(self, value: bool) -> None:
+        self._interrupting = value
+
+    def start_thinking(self) -> None:
+        thinking_indicator = self.app.query_one(ThinkingIndicator)
+        thinking_indicator.is_thinking = True
+
+        input_widget = self.app.query_one(TextArea)
+        input_widget.cursor_blink = False
+
+    def stop_thinking(self, show_cursor: bool = True) -> None:
+        thinking_indicator = self.app.query_one(ThinkingIndicator)
+        thinking_indicator.is_thinking = False
+
+        if show_cursor:
+            input_widget = self.app.query_one(TextArea)
+            input_widget.cursor_blink = True
+
+    def show_permission_prompt(
+        self, tool_name: str, tool_input: dict[str, Any]
+    ) -> None:
+        from agent_chat_cli.components.user_input import UserInput
+
+        thinking_indicator = self.app.query_one(ThinkingIndicator)
+        thinking_indicator.is_thinking = False
+
+        permission_prompt = self.app.query_one(ToolPermissionPrompt)
+        permission_prompt.tool_name = tool_name
+        permission_prompt.tool_input = tool_input
+        permission_prompt.is_visible = True
+
+        user_input = self.app.query_one(UserInput)
+        user_input.display = False
+
+    def hide_permission_prompt(self) -> None:
+        from agent_chat_cli.components.user_input import UserInput
+
+        permission_prompt = self.app.query_one(ToolPermissionPrompt)
+        permission_prompt.is_visible = False
+
+        user_input = self.app.query_one(UserInput)
+        user_input.display = True
+
+        input_widget = self.app.query_one(TextArea)
+        input_widget.focus()