alloy-runtime-cli 0.1.0__py3-none-any.whl

cli/tui/chat/messages.py

@@ -0,0 +1,223 @@
+"""Textual Messages for inter-widget communication in the chat module.
+
+These messages enable loose coupling between widgets. Child widgets post
+messages that bubble up to parents, allowing the ChatScreen orchestrator
+to coordinate actions without tight coupling.
+"""
+
+from uuid import UUID
+
+from textual.message import Message
+
+from alloy_runtime_types.dtos.sessions import MessageResponse, SessionSummary
+
+
+# =============================================================================
+# Session Events
+# =============================================================================
+
+
+class SessionSelected(Message):
+    """User selected a session from the sidebar."""
+
+    def __init__(self, session_id: UUID) -> None:
+        self.session_id = session_id
+        super().__init__()
+
+
+class SessionCreated(Message):
+    """A new session was successfully created."""
+
+    def __init__(
+        self,
+        session_id: UUID,
+        agent_id: UUID | None,
+        agent_name: str | None,
+    ) -> None:
+        self.session_id = session_id
+        self.agent_id = agent_id
+        self.agent_name = agent_name
+        super().__init__()
+
+
+class SessionsLoaded(Message):
+    """Sessions list was loaded/refreshed."""
+
+    def __init__(self, sessions: list[SessionSummary]) -> None:
+        self.sessions = sessions
+        super().__init__()
+
+
+class SessionsLoadError(Message):
+    """Failed to load sessions."""
+
+    def __init__(self, error: str) -> None:
+        self.error = error
+        super().__init__()
+
+
+# =============================================================================
+# Message Events
+# =============================================================================
+
+
+class MessagesLoaded(Message):
+    """Messages for current session were loaded."""
+
+    def __init__(self, messages: list[MessageResponse]) -> None:
+        self.messages = messages
+        super().__init__()
+
+
+class SendMessageRequested(Message):
+    """User wants to send a message."""
+
+    def __init__(self, content: str) -> None:
+        self.content = content
+        super().__init__()
+
+
+class RegenerateRequested(Message):
+    """User wants to regenerate the last response."""
+
+    pass
+
+
+class UndoRequested(Message):
+    """User wants to undo the last conversation turn."""
+
+    pass
+
+
+# =============================================================================
+# Streaming Events
+# =============================================================================
+
+
+class StreamingStarted(Message):
+    """Response streaming has begun."""
+
+    def __init__(self, execution_id: UUID) -> None:
+        self.execution_id = execution_id
+        super().__init__()
+
+
+class StreamingChunk(Message):
+    """A chunk of streamed content received."""
+
+    def __init__(self, content: str, is_reasoning: bool = False) -> None:
+        self.content = content
+        self.is_reasoning = is_reasoning
+        super().__init__()
+
+
+class StreamingCompleted(Message):
+    """Response streaming finished successfully."""
+
+    def __init__(self, full_content: str) -> None:
+        self.full_content = full_content
+        super().__init__()
+
+
+class StreamingError(Message):
+    """Error occurred during streaming."""
+
+    def __init__(self, error: str) -> None:
+        self.error = error
+        super().__init__()
+
+
+# =============================================================================
+# UI Events
+# =============================================================================
+
+
+class FocusInputRequested(Message):
+    """Request to focus the chat input."""
+
+    pass
+
+
+class FocusSessionSearchRequested(Message):
+    """Request to focus the session search input."""
+
+    pass
+
+
+class CopyToClipboardRequested(Message):
+    """Request to copy content to clipboard."""
+
+    def __init__(self, content: str, label: str = "Content") -> None:
+        self.content = content
+        self.label = label
+        super().__init__()
+
+
+class NewSessionRequested(Message):
+    """User wants to create a new session."""
+
+    pass
+
+
+class OpenEditorRequested(Message):
+    """User wants to open the current input in $EDITOR."""
+
+    def __init__(self, current_text: str) -> None:
+        self.current_text = current_text
+        super().__init__()
+
+
+class EditorContentReturned(Message):
+    """Content was returned from the external editor."""
+
+    def __init__(self, content: str) -> None:
+        self.content = content
+        super().__init__()
+
+
+# =============================================================================
+# Slash Command Events
+# =============================================================================
+
+
+class SlashCommandExecuted(Message):
+    """A slash command was executed by the user.
+
+    Some commands are handled directly (e.g., /clear, /copy), while others
+    signal actions to be performed by the screen (e.g., /new, /undo).
+    """
+
+    def __init__(self, command_name: str, args: str = "") -> None:
+        self.command_name = command_name
+        self.args = args
+        super().__init__()
+
+
+class UnknownSlashCommand(Message):
+    """User entered an unknown slash command."""
+
+    def __init__(self, command_text: str) -> None:
+        self.command_text = command_text
+        super().__init__()
+
+
+# =============================================================================
+# Welcome Screen Events
+# =============================================================================
+
+
+class AgentQuickSelected(Message):
+    """User selected an agent from quick start list for immediate session creation."""
+
+    def __init__(self, agent_id: UUID, agent_name: str) -> None:
+        self.agent_id = agent_id
+        self.agent_name = agent_name
+        super().__init__()
+
+
+class RecentSessionSelected(Message):
+    """User selected a recent session from the welcome screen."""
+
+    def __init__(self, session_id: UUID) -> None:
+        self.session_id = session_id
+        super().__init__()

cli/tui/chat/pane.py

@@ -0,0 +1,141 @@
+"""ChatPane - an individual chat pane with its own session/model.
+
+This widget encapsulates the main chat area (header, messages, input) and can be
+used standalone or in a split-pane layout for comparing different models.
+"""
+
+from typing import TYPE_CHECKING, Any
+
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.widget import Widget
+
+from cli.tui.chat.store import ChatStore
+from cli.tui.chat.widgets.chat_header import ChatHeader
+from cli.tui.chat.widgets.chat_input import ChatInput
+from cli.tui.chat.widgets.injection_popup import InjectionSuggestionPopup
+from cli.tui.chat.widgets.message_display import MessageDisplay
+
+if TYPE_CHECKING:
+    pass
+
+
+class ChatPane(Widget):
+    """Individual chat pane with its own session/model.
+
+    This widget contains the main chat interface components:
+    - ChatHeader: Shows current session/model info
+    - MessageDisplay: Shows message history and streaming content
+    - ChatInput: Text input for composing messages
+
+    Each pane has its own ChatStore, allowing independent sessions
+    or the same session with different views.
+
+    Usage:
+        # Single pane
+        pane = ChatPane(store=my_store, pane_id="main")
+
+        # Split panes for comparison
+        left_pane = ChatPane(store=left_store, pane_id="left")
+        right_pane = ChatPane(store=right_store, pane_id="right")
+    """
+
+    DEFAULT_CSS = """
+    ChatPane {
+        width: 1fr;
+        height: 100%;
+    }
+    
+    ChatPane.focused-pane {
+        border: tall $accent;
+    }
+    
+    ChatPane.unfocused-pane {
+        border: tall $surface-darken-2;
+    }
+    
+    ChatPane #pane-container {
+        height: 100%;
+    }
+    """
+
+    def __init__(
+        self,
+        store: ChatStore,
+        pane_id: str = "main",
+        show_border: bool = False,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the chat pane.
+
+        Args:
+            store: ChatStore instance for state management.
+            pane_id: Unique identifier for this pane (e.g., "left", "right", "main").
+            show_border: Whether to show a border around the pane (for split view).
+        """
+        super().__init__(**kwargs)
+        self._store = store
+        self._pane_id = pane_id
+        self._show_border = show_border
+
+    @property
+    def pane_id(self) -> str:
+        """Get the pane identifier."""
+        return self._pane_id
+
+    @property
+    def store(self) -> ChatStore:
+        """Get the pane's ChatStore."""
+        return self._store
+
+    def compose(self) -> ComposeResult:
+        """Compose the pane layout."""
+        with Vertical(id="pane-container"):
+            yield ChatHeader(self._store)
+            yield MessageDisplay(self._store)
+            # Popup is positioned here (above ChatInput) so it can float over messages
+            yield InjectionSuggestionPopup(id="injection-popup")
+            yield ChatInput(self._store)
+
+    def on_mount(self) -> None:
+        """Apply border styling based on configuration."""
+        if self._show_border:
+            self.add_class("unfocused-pane")
+
+    def set_focused(self, focused: bool) -> None:
+        """Update the pane's focused state (visual indicator).
+
+        Args:
+            focused: Whether this pane is the active/focused pane.
+        """
+        if not self._show_border:
+            return
+
+        if focused:
+            self.remove_class("unfocused-pane")
+            self.add_class("focused-pane")
+        else:
+            self.remove_class("focused-pane")
+            self.add_class("unfocused-pane")
+
+    def set_show_border(self, show_border: bool) -> None:
+        """Enable or disable border styling for the pane."""
+        self._show_border = show_border
+        if not show_border:
+            self.remove_class("focused-pane")
+            self.remove_class("unfocused-pane")
+
+    def focus_input(self) -> None:
+        """Focus the chat input in this pane."""
+        chat_input = self.query_one(ChatInput)
+        chat_input.focus_input()
+
+    def clear_input(self) -> None:
+        """Clear the chat input in this pane."""
+        chat_input = self.query_one(ChatInput)
+        chat_input.clear_input()
+
+    def get_input_text(self) -> str:
+        """Get the current text from the chat input."""
+        chat_input = self.query_one(ChatInput)
+        return chat_input.get_text()

cli/tui/chat/renderers/base.py

@@ -0,0 +1,72 @@
+"""Base utilities for message renderers.
+
+Provides common functionality used by all renderer implementations.
+"""
+
+from alloy_runtime_types.dtos.sessions import MessageResponse
+
+from cli.tui.chat.types import (
+    extract_message_text,
+    extract_message_text_for_display,
+    format_time,
+)
+
+
+def format_user_header(msg: MessageResponse, *, include_time: bool = True) -> str:
+    """Format a user message header.
+
+    Args:
+        msg: The message to format.
+        include_time: Whether to include the timestamp.
+
+    Returns:
+        Formatted header string.
+    """
+    if include_time:
+        return f"You [{format_time(msg.created_at)}]:"
+    return "You:"
+
+
+def format_assistant_header(msg: MessageResponse, *, include_time: bool = True) -> str:
+    """Format an assistant message header.
+
+    Args:
+        msg: The message to format.
+        include_time: Whether to include the timestamp.
+
+    Returns:
+        Formatted header string.
+    """
+    if include_time:
+        return f"Assistant [{format_time(msg.created_at)}]:"
+    return "Assistant:"
+
+
+def get_message_body(msg: MessageResponse) -> str:
+    """Extract the body text from a message.
+
+    Args:
+        msg: The message to extract text from.
+
+    Returns:
+        Message body text.
+    """
+    return extract_message_text(msg)
+
+
+def get_message_body_for_display(msg: MessageResponse) -> tuple[str, bool]:
+    """Extract the body text from a message, truncating long content.
+
+    Long content (e.g., from @fragment() injections) is truncated to prevent
+    overwhelming the TUI. The first/last 50 chars are shown with a truncation
+    indicator.
+
+    Args:
+        msg: The message to extract text from.
+
+    Returns:
+        Tuple of (body_text, was_truncated)
+        - body_text: The message body, possibly truncated
+        - was_truncated: True if any content was truncated
+    """
+    return extract_message_text_for_display(msg)

cli/tui/chat/renderers/markdown.py

@@ -0,0 +1,250 @@
+"""Markdown renderer for chat messages.
+
+Renders messages with Rich markdown formatting for display in Textual widgets.
+Uses Rich's Markdown class to properly render markdown syntax (headers, code blocks,
+lists, etc.) in assistant responses.
+"""
+
+import re
+from datetime import datetime
+
+from rich.console import Group, RenderableType
+from rich.markdown import Markdown
+from rich.text import Text
+
+from alloy_runtime_types.dtos.sessions import MessageResponse
+
+from cli.tui.chat.renderers.base import (
+    get_message_body,
+    get_message_body_for_display,
+)
+from cli.tui.chat.types import extract_thinking_content, format_time
+
+# Spinner frames for streaming indicator
+SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+
+# Color for thinking/reasoning blocks
+THINKING_COLOR = "#bb9af7"  # tokyo-night purple accent
+
+# Color for truncated content indicator
+TRUNCATED_COLOR = "#f7768e"  # tokyo-night red/pink for attention
+
+
+class MarkdownRenderer:
+    """Renders messages with Rich markdown formatting.
+
+    Features:
+        - User messages with muted styling
+        - Assistant messages rendered as proper markdown (code blocks, headers, etc.)
+        - Agent/model name in header
+        - Timestamps on each message
+        - Spinner during streaming
+        - Optimistic user message display
+        - Thinking/reasoning blocks with distinctive styling
+
+    This is the default renderer for the chat interface. It uses Rich's Markdown
+    class to properly render markdown syntax in assistant responses.
+    """
+
+    def __init__(self) -> None:
+        self._spinner_frame = 0
+
+    def render(
+        self,
+        messages: tuple[MessageResponse, ...],
+        streaming_content: str = "",
+        streaming_thinking_content: str = "",
+        pending_user_message: str | None = None,
+        assistant_name: str = "Assistant",
+        is_streaming: bool = False,
+        thinking_collapsed: bool = False,
+    ) -> Group:
+        """Render messages to a Rich Group with proper markdown formatting.
+
+        Args:
+            messages: Tuple of message responses to render.
+            streaming_content: Partial content being streamed (appended to end).
+            streaming_thinking_content: Partial thinking/reasoning content being streamed.
+            pending_user_message: User message shown optimistically before server confirms.
+            assistant_name: Name to display for assistant (agent name or model).
+            is_streaming: Whether currently streaming a response.
+            thinking_collapsed: Whether thinking blocks should be collapsed.
+
+        Returns:
+            Rich Group containing formatted renderables suitable for display.
+        """
+        renderables: list[RenderableType] = []
+
+        # Colors: user messages in dim/muted, assistant in accent color
+        # Using colors that work well with tokyo-night theme
+        user_color = "dim white"
+        assistant_color = "#7aa2f7"  # tokyo-night blue accent
+
+        for msg in messages:
+            time_str = format_time(msg.created_at)
+
+            if msg.role == "user":
+                # Only truncate user messages (template injections are user-initiated)
+                body, was_truncated = get_message_body_for_display(msg)
+                header = Text(f"You [{time_str}]:", style=f"bold {user_color}")
+                renderables.append(header)
+                # Style truncated content differently
+                if was_truncated:
+                    renderables.append(self._style_truncated_content(body))
+                else:
+                    renderables.append(Text(body))
+            else:
+                # Never truncate assistant messages - show full response
+                body = self._get_full_message_body(msg)
+
+                # For assistant messages, check for thinking content
+                thinking_content = extract_thinking_content(msg)
+                if thinking_content:
+                    # Render thinking block (not streaming, use collapsed setting)
+                    renderables.append(
+                        self._render_thinking_block_renderable(
+                            thinking_content,
+                            is_streaming=False,
+                            collapsed=thinking_collapsed,
+                        )
+                    )
+                    renderables.append(Text(""))
+
+                header = Text(
+                    f"{assistant_name} [{time_str}]:", style=f"bold {assistant_color}"
+                )
+                renderables.append(header)
+                # Render assistant body as proper markdown
+                renderables.append(Markdown(body))
+
+            renderables.append(Text(""))
+
+        # Show pending user message (optimistic UI)
+        if pending_user_message:
+            now_str = datetime.now().strftime("%H:%M")
+            header = Text(f"You [{now_str}]:", style=f"bold {user_color}")
+            renderables.append(header)
+            renderables.append(Text(pending_user_message))
+            renderables.append(Text(""))
+
+        # Show streaming thinking/reasoning block
+        if streaming_thinking_content:
+            renderables.append(
+                self._render_thinking_block_renderable(
+                    streaming_thinking_content, is_streaming, thinking_collapsed
+                )
+            )
+            renderables.append(Text(""))
+
+        # Show streaming response with spinner
+        if is_streaming or streaming_content:
+            spinner = self._get_spinner() if is_streaming else ""
+            if streaming_content:
+                header = Text()
+                header.append(f"{assistant_name}:", style=f"bold {assistant_color}")
+                header.append(f" {spinner}", style="yellow")
+                renderables.append(header)
+                # Render streaming content as markdown too
+                renderables.append(Markdown(streaming_content))
+            elif not streaming_thinking_content:
+                # Only show "Thinking..." if we don't have actual thinking content
+                header = Text()
+                header.append(f"{assistant_name}:", style=f"bold {assistant_color}")
+                header.append(f" {spinner}", style="yellow")
+                renderables.append(header)
+                renderables.append(Text("Waiting for response...", style="dim"))
+
+        return Group(*renderables)
+
+    def _render_thinking_block_renderable(
+        self,
+        content: str,
+        is_streaming: bool = False,
+        collapsed: bool = False,
+    ) -> Text:
+        """Render a thinking/reasoning block with distinctive styling.
+
+        Args:
+            content: The thinking content to render.
+            is_streaming: Whether the thinking is still streaming.
+            collapsed: Whether to show collapsed view.
+
+        Returns:
+            Rich Text object for the thinking block.
+        """
+        spinner = self._get_spinner() if is_streaming else ""
+
+        if collapsed:
+            # Show collapsed indicator with line count
+            line_count = content.count("\n") + 1
+            result = Text()
+            result.append(
+                f"◆ Thinking ({line_count} lines)... {spinner}", style=THINKING_COLOR
+            )
+            result.append(" (expand with /thinking)", style="dim")
+            return result
+
+        # Full thinking block with border styling
+        lines: list[str] = []
+        lines.append(f"◆ Thinking {spinner}")
+
+        # Indent and dim the thinking content
+        for line in content.split("\n"):
+            lines.append(f"│ {line}")
+
+        result = Text()
+        result.append(lines[0] + "\n", style=f"bold {THINKING_COLOR}")
+        for line in lines[1:]:
+            result.append(line + "\n", style="dim italic")
+
+        return result
+
+    def _get_spinner(self) -> str:
+        """Get the current spinner frame and advance to next."""
+        frame = SPINNER_FRAMES[self._spinner_frame % len(SPINNER_FRAMES)]
+        self._spinner_frame += 1
+        return frame
+
+    def _get_full_message_body(self, msg: MessageResponse) -> str:
+        """Get the full message body without truncation.
+
+        Used for assistant messages which should never be truncated.
+
+        Args:
+            msg: The message to extract body from
+
+        Returns:
+            Full message body text
+        """
+        return get_message_body(msg)
+
+    def _style_truncated_content(self, body: str) -> Text:
+        """Style content that contains truncation indicators.
+
+        Highlights the truncation indicator (e.g., "[1,234 chars truncated]")
+        in a distinctive color so users can clearly see content was truncated.
+
+        Args:
+            body: The message body with truncation indicator(s)
+
+        Returns:
+            Rich Text object with styled truncation indicators
+        """
+        result = Text()
+        # Pattern to match truncation indicators like "... [1,234 chars truncated] ..."
+        pattern = r"(\.\.\. \[[\d,]+ chars truncated\] \.\.\.)"
+
+        last_end = 0
+        for match in re.finditer(pattern, body):
+            # Add text before the match
+            if match.start() > last_end:
+                result.append(body[last_end : match.start()])
+            # Add the truncation indicator with styling
+            result.append(match.group(1), style=f"bold {TRUNCATED_COLOR}")
+            last_end = match.end()
+
+        # Add remaining text after last match
+        if last_end < len(body):
+            result.append(body[last_end:])
+
+        return result