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

cli/tui/chat/widgets/injection_popup.py

@@ -0,0 +1,161 @@
+"""Popup widget for injection autocomplete suggestions.
+
+This is a "dumb" display widget - it shows suggestions and highlights one,
+but all keyboard handling is done by ChatInput which controls this popup.
+"""
+
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.widget import Widget
+from textual.widgets import OptionList, Static
+from textual.widgets.option_list import Option
+
+from cli.tui.chat.services.injection import InjectionCompletion
+
+
+class InjectionSuggestionPopup(Widget):
+    """Display-only popup for autocomplete suggestions.
+
+    This widget is controlled entirely by ChatInput:
+    - ChatInput calls show_suggestions() to display options
+    - ChatInput calls highlight_next/previous() to change selection
+    - ChatInput calls get_selected() when user accepts
+    - ChatInput calls hide() to close
+
+    The popup never takes focus - input stays in the text area.
+    """
+
+    DEFAULT_CSS = """
+    InjectionSuggestionPopup {
+        display: none;
+    }
+    
+    InjectionSuggestionPopup.visible {
+        display: block;
+    }
+    """
+
+    # This widget should never take focus
+    can_focus = False
+
+    def __init__(self, id: str | None = None) -> None:
+        super().__init__(id=id)
+        self._suggestions: list[InjectionCompletion] = []
+        self._injection_type: str = ""
+        self._filter_text: str = ""
+        self._highlighted_index: int = 0
+
+    def compose(self) -> ComposeResult:
+        """Compose the popup layout."""
+        with Vertical():
+            yield Static("@fragment()", id="popup-header")
+            yield Static(
+                "[dim]Type to filter • Tab accept • ↑↓ navigate • Esc dismiss[/]",
+                id="popup-hint",
+            )
+            yield OptionList(id="popup-list")
+            yield Static("No matches found", id="empty-hint")
+
+    def on_mount(self) -> None:
+        """Initialize popup state."""
+        self.query_one("#empty-hint", Static).display = False
+        # Disable focus on the option list too
+        self.query_one("#popup-list", OptionList).can_focus = False
+
+    def show_suggestions(
+        self,
+        suggestions: list[InjectionCompletion],
+        injection_type: str,
+        filter_text: str = "",
+    ) -> None:
+        """Display suggestions in the popup.
+
+        Args:
+            suggestions: List of completion suggestions.
+            injection_type: Type of injection (fragment, text, json, schema).
+            filter_text: Current filter/partial identifier typed by user.
+        """
+        self._suggestions = suggestions
+        self._injection_type = injection_type
+        self._filter_text = filter_text
+        self._highlighted_index = 0
+
+        # Update header to show current input state
+        header = self.query_one("#popup-header", Static)
+        if filter_text:
+            header.update(f"@{injection_type}([bold]{filter_text}[/bold])")
+        else:
+            header.update(f"@{injection_type}()")
+
+        # Update option list
+        option_list = self.query_one("#popup-list", OptionList)
+        option_list.clear_options()
+
+        empty_hint = self.query_one("#empty-hint", Static)
+
+        if suggestions:
+            for i, suggestion in enumerate(suggestions):
+                label = (
+                    f"{suggestion.display_name}  [dim]{suggestion.description}[/dim]"
+                )
+                option_list.add_option(Option(label, id=str(i)))
+
+            option_list.display = True
+            empty_hint.display = False
+            option_list.highlighted = 0
+        else:
+            option_list.display = False
+            empty_hint.display = True
+            if filter_text:
+                empty_hint.update(f"No matches for '{filter_text}'")
+            else:
+                empty_hint.update("No items available")
+
+        self.add_class("visible")
+
+    def hide(self) -> None:
+        """Hide the popup."""
+        self.remove_class("visible")
+        self._suggestions = []
+        self._filter_text = ""
+        self._highlighted_index = 0
+
+    @property
+    def is_visible(self) -> bool:
+        """Check if popup is currently visible."""
+        return self.has_class("visible")
+
+    @property
+    def has_suggestions(self) -> bool:
+        """Check if there are any suggestions to select."""
+        return bool(self._suggestions)
+
+    def highlight_next(self) -> None:
+        """Move highlight to next suggestion."""
+        if not self._suggestions:
+            return
+        if self._highlighted_index < len(self._suggestions) - 1:
+            self._highlighted_index += 1
+            option_list = self.query_one("#popup-list", OptionList)
+            option_list.highlighted = self._highlighted_index
+
+    def highlight_previous(self) -> None:
+        """Move highlight to previous suggestion."""
+        if not self._suggestions:
+            return
+        if self._highlighted_index > 0:
+            self._highlighted_index -= 1
+            option_list = self.query_one("#popup-list", OptionList)
+            option_list.highlighted = self._highlighted_index
+
+    def get_selected(self) -> InjectionCompletion | None:
+        """Get the currently highlighted suggestion.
+
+        Returns:
+            The selected completion, or None if no suggestions.
+        """
+        if not self._suggestions:
+            return None
+        if 0 <= self._highlighted_index < len(self._suggestions):
+            return self._suggestions[self._highlighted_index]
+        return None

cli/tui/chat/widgets/message_display.py

@@ -0,0 +1,287 @@
+"""Message display widget for rendering chat message history."""
+
+from typing import TYPE_CHECKING, Callable
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import VerticalScroll
+from textual.widget import Widget
+from textual.widgets import Static
+
+from cli.tui.chat.messages import CopyToClipboardRequested
+from cli.tui.chat.renderers.markdown import MarkdownRenderer
+from cli.tui.chat.renderers.plain import PlainTextRenderer
+from cli.tui.chat.store import ChatStore
+from cli.tui.chat.types import (
+    ChatPhase,
+    ChatState,
+    MessageRenderer,
+    RenderMode,
+    extract_message_text,
+)
+from cli.tui.chat.widgets.welcome_screen import WelcomeScreen
+
+if TYPE_CHECKING:
+    from cli.tui.app import AlloyRuntimeApp
+
+
+class MessageDisplay(Widget):
+    """Widget for displaying chat message history.
+
+    Features:
+        - Renders message history with timestamps
+        - Shows streaming content in real-time
+        - Auto-scrolls to bottom on new content (unless user scrolls up)
+        - Supports copying last response
+        - Pluggable renderer for different output formats
+
+    Posts Messages:
+        - CopyToClipboardRequested: When user triggers copy action
+
+    Auto-scroll behavior:
+        - During streaming, auto-scrolls to bottom unless user has scrolled up
+        - User scrolling up during streaming disables auto-scroll
+        - User scrolling back to bottom (or pressing G) re-enables auto-scroll
+        - Auto-scroll is always re-enabled when streaming ends
+    """
+
+    app: "AlloyRuntimeApp"
+
+    BINDINGS = [
+        Binding("ctrl+y", "copy_last", "Copy Last", show=False),
+        Binding("ctrl+shift+y", "copy_all", "Copy All", show=False),
+        Binding("g", "scroll_top", "Top", show=False),
+        Binding("G", "scroll_bottom", "Bottom", show=False),
+    ]
+
+    def __init__(
+        self,
+        store: ChatStore,
+        renderer: MessageRenderer | None = None,
+    ) -> None:
+        """Initialize the message display.
+
+        Args:
+            store: ChatStore instance for state management.
+            renderer: Optional renderer for message formatting. Defaults to MarkdownRenderer.
+        """
+        super().__init__()
+        self._store = store
+        self._custom_renderer: MessageRenderer | None = renderer
+        self._markdown_renderer = MarkdownRenderer()
+        self._plain_renderer = PlainTextRenderer()
+        self._unsubscribe: Callable[[], None] | None = None
+        # Auto-scroll is enabled by default; disabled when user scrolls up during streaming
+        self._auto_scroll_enabled = True
+        # Track whether welcome screen is currently shown
+        self._welcome_screen_visible = False
+
+    def _get_renderer(self, state: ChatState) -> MessageRenderer:
+        """Get the appropriate renderer based on state."""
+        if self._custom_renderer:
+            return self._custom_renderer
+        if state.render_mode == RenderMode.PLAIN:
+            return self._plain_renderer
+        return self._markdown_renderer
+
+    def compose(self) -> ComposeResult:
+        """Compose the message display layout."""
+        with VerticalScroll(id="message-scroll"):
+            # Start with welcome screen visible, messages hidden
+            yield WelcomeScreen(id="welcome-screen")
+            messages_widget = Static("", id="messages")
+            messages_widget.display = False
+            yield messages_widget
+        self._welcome_screen_visible = True
+
+    def on_mount(self) -> None:
+        """Subscribe to store on mount."""
+        self._unsubscribe = self._store.subscribe(self._on_state_change)
+
+    def on_unmount(self) -> None:
+        """Unsubscribe from store on unmount."""
+        if self._unsubscribe:
+            self._unsubscribe()
+
+    def _on_state_change(self, state: ChatState) -> None:
+        """React to store state changes."""
+        self._render_messages(state)
+
+    def _is_at_bottom(self) -> bool:
+        """Check if scroll is at or near the bottom."""
+        scroll = self.query_one("#message-scroll", VerticalScroll)
+        # Consider "at bottom" if within 50 pixels of the end
+        # Also consider at bottom if max_scroll is 0 (content fits in view)
+        return scroll.max_scroll_y <= 0 or scroll.scroll_y >= scroll.max_scroll_y - 50
+
+    def _render_messages(self, state: ChatState) -> None:
+        """Render messages to the display using the configured renderer."""
+        messages_widget = self.query_one("#messages", Static)
+        messages = state.messages
+        streaming_content = state.streaming_content
+        streaming_thinking_content = state.streaming_thinking_content
+        pending_user_message = state.pending_user_message
+        is_streaming = state.phase == ChatPhase.STREAMING
+
+        # Check scroll position BEFORE rendering to detect user scroll-up
+        # If streaming and not at bottom, user must have scrolled up
+        if is_streaming and not self._is_at_bottom():
+            self._auto_scroll_enabled = False
+
+        # Get assistant name from session context
+        assistant_name = "Assistant"
+        if state.session:
+            assistant_name = state.session.display_name
+
+        # Check if we have anything to show
+        has_content = (
+            messages
+            or streaming_content
+            or streaming_thinking_content
+            or pending_user_message
+        )
+
+        # Determine if welcome screen should be visible
+        should_show_welcome = state.session is None and not has_content
+
+        # Switch between welcome screen and messages display
+        if should_show_welcome != self._welcome_screen_visible:
+            self._toggle_welcome_screen(should_show_welcome)
+
+        if should_show_welcome:
+            # Welcome screen handles its own content
+            return
+
+        if not has_content:
+            # Session exists but no messages yet
+            messages_widget.update(
+                "[dim]No messages yet. Type below and press Ctrl+D to send.[/]"
+            )
+            return
+
+        # Delegate rendering to the appropriate renderer based on state
+        renderer = self._get_renderer(state)
+        rendered_content = renderer.render(
+            messages,
+            streaming_content=streaming_content,
+            streaming_thinking_content=streaming_thinking_content,
+            pending_user_message=pending_user_message,
+            assistant_name=assistant_name,
+            is_streaming=is_streaming,
+            thinking_collapsed=state.thinking_collapsed,
+        )
+        messages_widget.update(rendered_content)
+
+        # Auto-scroll if enabled
+        if self._auto_scroll_enabled:
+            self._scroll_to_bottom()
+
+        # Re-enable auto-scroll when streaming ends
+        if not is_streaming:
+            self._auto_scroll_enabled = True
+
+    def _scroll_to_bottom(self) -> None:
+        """Scroll the message view to the bottom."""
+        scroll = self.query_one("#message-scroll", VerticalScroll)
+        scroll.scroll_end(animate=False)
+
+    def _toggle_welcome_screen(self, show_welcome: bool) -> None:
+        """Toggle between welcome screen and messages display.
+
+        Args:
+            show_welcome: If True, show welcome screen; if False, show messages.
+        """
+        try:
+            welcome_screen = self.query_one("#welcome-screen", WelcomeScreen)
+            messages_widget = self.query_one("#messages", Static)
+
+            welcome_screen.display = show_welcome
+            messages_widget.display = not show_welcome
+            self._welcome_screen_visible = show_welcome
+
+            # Refresh welcome screen data when showing it
+            if show_welcome:
+                welcome_screen.refresh_data()
+        except Exception:
+            # Widgets may not be mounted yet during initial compose
+            pass
+
+    def _get_welcome_message(self) -> str:
+        """Get the welcome message for new sessions."""
+        return """[bold]Welcome to Alloy Runtime![/]
+
+[dim]Select a session from the sidebar or press Ctrl+N to start a new chat.[/]
+
+[bold cyan]Features:[/]
+- Browse and resume previous chat sessions
+- Start new conversations with agents or models
+- Stream responses in real-time
+- Compose messages in your $EDITOR
+
+[bold cyan]Keyboard shortcuts:[/]
+  Ctrl+D         Send message
+  Ctrl+N         New chat session
+  Ctrl+E         Open message in $EDITOR
+  Ctrl+B         Toggle sidebar
+  Ctrl+R         Regenerate last response
+  Ctrl+U         Undo last turn
+  Ctrl+Y         Copy last response
+  Ctrl+Shift+Y   Copy all messages
+  /              Search sessions
+
+[bold cyan]Tip:[/] Hold Shift while clicking to use native terminal text selection.
+"""
+
+    def action_copy_last(self) -> None:
+        """Copy the last assistant response to clipboard."""
+        messages = self._store.state.messages
+
+        if not messages:
+            self.app.notify("No messages to copy", severity="warning")
+            return
+
+        # Find last assistant message
+        for msg in reversed(messages):
+            if msg.role == "assistant":
+                text = extract_message_text(msg)
+                if text:
+                    self.post_message(CopyToClipboardRequested(text, "Last response"))
+                    return
+
+        self.app.notify("No assistant message to copy", severity="warning")
+
+    def action_copy_all(self) -> None:
+        """Copy all messages to clipboard as plain text."""
+        messages = self._store.state.messages
+
+        if not messages:
+            self.app.notify("No messages to copy", severity="warning")
+            return
+
+        # Build plain text version of all messages
+        lines: list[str] = []
+        for msg in messages:
+            role = msg.role.capitalize()
+            text = extract_message_text(msg)
+            if text:
+                lines.append(f"{role}:\n{text}\n")
+
+        if lines:
+            full_text = "\n".join(lines)
+            self.post_message(CopyToClipboardRequested(full_text, "All messages"))
+        else:
+            self.app.notify("No message content to copy", severity="warning")
+
+    def action_scroll_top(self) -> None:
+        """Scroll to the top of messages."""
+        scroll = self.query_one("#message-scroll", VerticalScroll)
+        scroll.scroll_home(animate=False)
+
+    def action_scroll_bottom(self) -> None:
+        """Scroll to the bottom of messages and resume auto-scroll."""
+        self._auto_scroll_enabled = True
+        self._scroll_to_bottom()
+
+    def show_welcome(self) -> None:
+        """Show the welcome screen."""
+        self._toggle_welcome_screen(show_welcome=True)

cli/tui/chat/widgets/session_sidebar.py

@@ -0,0 +1,214 @@
+"""Session sidebar widget for listing and searching chat sessions."""
+
+from typing import TYPE_CHECKING, Callable
+
+from textual import on, work
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.widget import Widget
+from textual.widgets import Checkbox, DataTable, Input, Static
+
+from alloy_runtime_sdk.api_client.client import ApiClient
+from alloy_runtime_types.dtos.sessions import SessionSummary
+from alloy_runtime_sdk.logging.config import get_logger
+
+from cli.tui.chat.messages import SessionSelected, SessionsLoaded, SessionsLoadError
+from cli.tui.chat.store import ChatStore
+from cli.tui.chat.types import ChatPhase, ChatState, format_session_time
+
+logger = get_logger(__name__)
+
+if TYPE_CHECKING:
+    from cli.tui.app import AlloyRuntimeApp
+
+
+class SessionSidebar(Widget):
+    """Sidebar widget showing session list with search.
+
+    Features:
+        - Search sessions with debounced API calls
+        - Display session list in a DataTable
+        - Select sessions to load their messages
+        - Toggle between named-only and all sessions
+
+    Posts Messages:
+        - SessionSelected: When user selects a session
+        - SessionsLoaded: After successfully loading sessions
+        - SessionsLoadError: When session loading fails
+    """
+
+    app: "AlloyRuntimeApp"
+
+    # No bindings on widget - parent Screen handles all keybindings
+    # and delegates to public methods on this widget
+
+    DEFAULT_CSS = """
+    SessionSidebar #show-untitled-row {
+        height: auto;
+        padding: 0 1;
+    }
+    
+    SessionSidebar #show-untitled {
+        height: auto;
+        min-height: 1;
+        padding: 0;
+        margin: 0;
+    }
+    """
+
+    def __init__(self, store: ChatStore) -> None:
+        """Initialize the session sidebar.
+
+        Args:
+            store: ChatStore instance for state management.
+        """
+        super().__init__()
+        self._store = store
+        self._last_search = ""
+        self._show_untitled = False  # Default: show only named sessions
+        self._unsubscribe: Callable[[], None] | None = None
+        # Track visibility to refresh when sidebar is opened
+        self._was_visible = False
+        # Guard against re-entrant state changes
+        self._refreshing = False
+
+    def compose(self) -> ComposeResult:
+        """Compose the sidebar layout."""
+        with Vertical(id="sidebar-root"):
+            with Vertical(id="session-header"):
+                yield Input(
+                    placeholder="Search sessions...",
+                    id="session-search",
+                )
+                with Horizontal(id="show-untitled-row"):
+                    yield Checkbox("Show untitled", id="show-untitled", value=False)
+                yield Static("Loading...", id="session-status")
+            yield DataTable(id="session-table", cursor_type="row")
+
+    def on_mount(self) -> None:
+        """Initialize table and subscribe to store on mount."""
+        table = self.query_one("#session-table", DataTable[str])
+        table.add_columns("Session", "Time", "Msgs")
+
+        # Subscribe to store changes
+        self._unsubscribe = self._store.subscribe(self._on_state_change)
+
+        # Load initial sessions
+        self._load_sessions("")
+
+    def on_unmount(self) -> None:
+        """Unsubscribe from store on unmount."""
+        if self._unsubscribe:
+            self._unsubscribe()
+
+    def _on_state_change(self, state: ChatState) -> None:
+        """React to store state changes."""
+        # Handle sidebar visibility
+        self.display = state.sidebar_visible
+
+        # Refresh sessions when sidebar becomes visible (with guard against recursion)
+        becoming_visible = state.sidebar_visible and not self._was_visible
+        self._was_visible = state.sidebar_visible
+
+        if becoming_visible and not self._refreshing:
+            self._refreshing = True
+            self._load_sessions(self._last_search)
+
+        # Update table when sessions change
+        self._update_table(state.sessions)
+
+        # Update status based on phase
+        status = self.query_one("#session-status", Static)
+        if state.phase == ChatPhase.LOADING_SESSIONS:
+            status.update("Loading...")
+        elif state.sessions:
+            status.update(f"{len(state.sessions)} sessions")
+        else:
+            status.update("No sessions found")
+
+    def _update_table(self, sessions: tuple[SessionSummary, ...]) -> None:
+        """Update the DataTable with session data."""
+        table = self.query_one("#session-table", DataTable[str])
+        table.clear()
+
+        # Populate table with sessions (filtering is done server-side via named_only)
+        for session in sessions:
+            name = session.name or "[dim]Untitled[/]"
+            if len(name) > 15:
+                name = name[:12] + "..."
+            table.add_row(
+                name,
+                format_session_time(session.last_activity_at),
+                str(session.message_count),
+            )
+
+    @on(Input.Changed, "#session-search")
+    def on_search_changed(self, event: Input.Changed) -> None:
+        """Handle search input changes with debouncing."""
+        query = event.value.strip()
+        if query != self._last_search:
+            self._last_search = query
+            self._store.set_session_search_query(query)
+            self._load_sessions(query)
+
+    @on(Checkbox.Changed, "#show-untitled")
+    def on_show_untitled_changed(self, event: Checkbox.Changed) -> None:
+        """Handle show untitled checkbox toggle - triggers a reload from server."""
+        self._show_untitled = event.value
+        # Reload sessions from server with new filter setting
+        self._load_sessions(self._last_search)
+
+    @on(DataTable.RowSelected, "#session-table")
+    def on_row_selected(self, event: DataTable.RowSelected) -> None:
+        """Handle session selection from table."""
+        row_index = event.cursor_row
+        sessions = self._store.state.sessions
+        if 0 <= row_index < len(sessions):
+            session = sessions[row_index]
+            logger.debug(
+                "sidebar_session_selected",
+                session_id=str(session.id),
+                session_name=session.name,
+            )
+            self.post_message(SessionSelected(session.id))
+
+    @work(exclusive=True)
+    async def _load_sessions(self, query: str) -> None:
+        """Load sessions from API."""
+        logger.debug("sidebar_loading_sessions", query=query or None)
+        self._store.set_phase(ChatPhase.LOADING_SESSIONS)
+        status = self.query_one("#session-status", Static)
+        status.update("Loading...")
+
+        try:
+            client = await self._get_client()
+            response = await client.list_sessions(
+                search=query if query else None,
+                named_only=not self._show_untitled,
+                limit=50,
+            )
+
+            logger.debug("sidebar_sessions_loaded", count=len(response.sessions))
+            self._store.set_sessions(list(response.sessions))
+            self._store.set_phase(ChatPhase.IDLE)
+            self.post_message(SessionsLoaded(list(response.sessions)))
+
+        except Exception as e:
+            logger.warning("sidebar_sessions_load_error", error=str(e))
+            self._store.set_phase(ChatPhase.IDLE)
+            status.update("[red]Error[/]")
+            self.post_message(SessionsLoadError(str(e)))
+        finally:
+            self._refreshing = False
+
+    async def _get_client(self) -> ApiClient:
+        """Get the shared server client."""
+        return await self.app.store.get_client()
+
+    def action_focus_search(self) -> None:
+        """Focus the search input."""
+        self.query_one("#session-search", Input).focus()
+
+    def refresh_sessions(self) -> None:
+        """Refresh the session list with current search query."""
+        self._load_sessions(self._last_search)