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

cli/tui/chat/widgets/welcome_screen.py

@@ -0,0 +1,290 @@
+"""Welcome screen widget for the chat interface.
+
+Displays quick access to frequently used agents and recent sessions,
+allowing users to start chatting with minimal friction.
+"""
+
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING, Any
+from uuid import UUID
+
+from textual import on, work
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.widget import Widget
+from textual.widgets import OptionList, Static
+from textual.widgets.option_list import Option
+
+from alloy_runtime_sdk.api_client.client import ApiClient
+from alloy_runtime_types.dtos.agents import AgentSummary
+from alloy_runtime_types.dtos.sessions import SessionSummary
+
+from cli.tui.chat.messages import AgentQuickSelected, RecentSessionSelected
+
+if TYPE_CHECKING:
+    from cli.tui.app import AlloyRuntimeApp
+
+
+class WelcomeScreen(Widget):
+    """Welcome screen with quick access to agents and recent sessions.
+
+    Features:
+        - Shows top agents by usage (named session count)
+        - Shows recent named sessions for quick resumption
+        - Number keys (1-9) for instant agent selection
+        - Keyboard navigation with arrow keys
+
+    Posts Messages:
+        - AgentQuickSelected: When user selects an agent
+        - RecentSessionSelected: When user selects a recent session
+    """
+
+    app: "AlloyRuntimeApp"
+
+    BINDINGS = [
+        Binding("1", "select_agent(0)", "Agent 1", show=False),
+        Binding("2", "select_agent(1)", "Agent 2", show=False),
+        Binding("3", "select_agent(2)", "Agent 3", show=False),
+        Binding("4", "select_agent(3)", "Agent 4", show=False),
+        Binding("5", "select_agent(4)", "Agent 5", show=False),
+        Binding("6", "select_agent(5)", "Agent 6", show=False),
+        Binding("7", "select_agent(6)", "Agent 7", show=False),
+        Binding("8", "select_agent(7)", "Agent 8", show=False),
+        Binding("9", "select_agent(8)", "Agent 9", show=False),
+    ]
+
+    DEFAULT_CSS = """
+    WelcomeScreen {
+        width: 100%;
+        height: auto;
+        padding: 1 2;
+    }
+    
+    WelcomeScreen #welcome-title {
+        text-align: center;
+        text-style: bold;
+        margin-bottom: 1;
+    }
+    
+    WelcomeScreen .section-title {
+        margin-top: 1;
+        margin-bottom: 0;
+        text-style: bold;
+        color: $accent;
+    }
+    
+    WelcomeScreen .section-divider {
+        color: $text-muted;
+        margin-bottom: 0;
+    }
+    
+    WelcomeScreen #agents-list {
+        height: auto;
+        max-height: 12;
+        margin-bottom: 1;
+        background: transparent;
+        border: none;
+    }
+    
+    WelcomeScreen #sessions-list {
+        height: auto;
+        max-height: 6;
+        margin-bottom: 1;
+        background: transparent;
+        border: none;
+    }
+    
+    WelcomeScreen .empty-hint {
+        color: $text-muted;
+        text-style: italic;
+        padding: 0 1;
+    }
+    
+    WelcomeScreen #footer-hints {
+        margin-top: 1;
+        color: $text-muted;
+    }
+    """
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self._agents: list[AgentSummary] = []
+        self._sessions: list[SessionSummary] = []
+        self._loading = True
+
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            yield Static("Welcome to Alloy Runtime", id="welcome-title")
+
+            yield Static("Quick Start", classes="section-title")
+            yield Static("─" * 40, classes="section-divider")
+            yield OptionList(id="agents-list")
+
+            yield Static("Recent Sessions", classes="section-title")
+            yield Static("─" * 40, classes="section-divider")
+            yield OptionList(id="sessions-list")
+
+            yield Static(
+                "[dim][Ctrl+N][/] New session  [dim]/[/] Search sessions  [dim][?][/] Help",
+                id="footer-hints",
+            )
+
+    def on_mount(self) -> None:
+        """Load agents and sessions when mounted."""
+        self._load_data()
+
+    @work(exclusive=True)
+    async def _load_data(self) -> None:
+        """Load frequently used agents and recent sessions."""
+        try:
+            client = await self._get_client()
+
+            # Load agents sorted by usage (last 90 days)
+            agents_response = await client.list_agents(
+                sort_by="usage",
+                usage_days=90,
+                limit=7,
+            )
+            self._agents = list(agents_response.agents)
+
+            # Load recent named sessions
+            sessions_response = await client.list_sessions(
+                named_only=True,
+                limit=5,
+            )
+            self._sessions = list(sessions_response.sessions)
+
+            self._loading = False
+            self._update_agents_list()
+            self._update_sessions_list()
+
+        except Exception as e:
+            self._loading = False
+            self._show_error(str(e))
+
+    async def _get_client(self) -> ApiClient:
+        """Get the shared server client."""
+        return await self.app.store.get_client()
+
+    def _update_agents_list(self) -> None:
+        """Update the agents option list."""
+        agents_list = self.query_one("#agents-list", OptionList)
+        agents_list.clear_options()
+
+        if not self._agents:
+            agents_list.add_option(
+                Option(
+                    "[dim italic]No agents yet. Press Ctrl+N to start.[/]",
+                    disabled=True,
+                )
+            )
+            return
+
+        for i, agent in enumerate(self._agents):
+            # Format: [1] Agent Name (N chats) - description
+            number = i + 1
+            usage_text = ""
+            if agent.usage_count is not None and agent.usage_count > 0:
+                usage_text = f" ({agent.usage_count} chat{'s' if agent.usage_count != 1 else ''})"
+
+            desc_text = ""
+            if agent.description:
+                desc = (
+                    agent.description[:40] + "..."
+                    if len(agent.description) > 40
+                    else agent.description
+                )
+                desc_text = f" [dim]- {desc}[/]"
+
+            label = (
+                f"[bold cyan][{number}][/] {agent.name}[dim]{usage_text}[/]{desc_text}"
+            )
+            agents_list.add_option(Option(label, id=str(agent.id)))
+
+    def _update_sessions_list(self) -> None:
+        """Update the sessions option list."""
+        sessions_list = self.query_one("#sessions-list", OptionList)
+        sessions_list.clear_options()
+
+        if not self._sessions:
+            sessions_list.add_option(
+                Option(
+                    "[dim italic]No recent sessions[/]",
+                    disabled=True,
+                )
+            )
+            return
+
+        for session in self._sessions:
+            # Format: Session Name - time ago
+            name = session.name or "Untitled"
+            if len(name) > 35:
+                name = name[:32] + "..."
+
+            time_ago = self._format_time_ago(session.last_activity_at)
+            label = f"  {name} [dim]{time_ago}[/]"
+            sessions_list.add_option(Option(label, id=str(session.id)))
+
+    def _format_time_ago(self, dt: datetime) -> str:
+        """Format datetime as human-readable time ago."""
+        now = datetime.now(timezone.utc)
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=timezone.utc)
+
+        delta = now - dt
+        seconds = delta.total_seconds()
+
+        if seconds < 60:
+            return "just now"
+        elif seconds < 3600:
+            mins = int(seconds / 60)
+            return f"{mins}m ago"
+        elif seconds < 86400:
+            hours = int(seconds / 3600)
+            return f"{hours}h ago"
+        elif seconds < 604800:
+            days = int(seconds / 86400)
+            return f"{days}d ago"
+        else:
+            weeks = int(seconds / 604800)
+            return f"{weeks}w ago"
+
+    def _show_error(self, error: str) -> None:
+        """Show error in the agents list."""
+        agents_list = self.query_one("#agents-list", OptionList)
+        agents_list.clear_options()
+        agents_list.add_option(Option(f"[red]Error loading: {error}[/]", disabled=True))
+
+    def action_select_agent(self, index: int) -> None:
+        """Select an agent by number key (0-indexed)."""
+        if index < len(self._agents):
+            agent = self._agents[index]
+            self.post_message(AgentQuickSelected(agent.id, agent.name))
+
+    @on(OptionList.OptionSelected, "#agents-list")
+    def on_agent_selected(self, event: OptionList.OptionSelected) -> None:
+        """Handle agent selection from option list."""
+        if event.option.id is None:
+            return
+
+        agent_id = UUID(event.option.id)
+        # Find the agent name
+        for agent in self._agents:
+            if agent.id == agent_id:
+                self.post_message(AgentQuickSelected(agent_id, agent.name))
+                break
+
+    @on(OptionList.OptionSelected, "#sessions-list")
+    def on_session_selected(self, event: OptionList.OptionSelected) -> None:
+        """Handle session selection from option list."""
+        if event.option.id is None:
+            return
+
+        session_id = UUID(event.option.id)
+        self.post_message(RecentSessionSelected(session_id))
+
+    def refresh_data(self) -> None:
+        """Refresh the agents and sessions data."""
+        self._loading = True
+        self._load_data()

cli/tui/screens/agents.py

@@ -0,0 +1,344 @@
+"""Agents screen for browsing and managing AI agents.
+
+This screen provides:
+- Search and browse agents
+- View agent details in preview panel
+- Create new agents
+- Copy agent names
+"""
+
+from typing import TYPE_CHECKING
+
+from textual import on, work
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical, VerticalScroll
+from textual.widgets import Button, DataTable, Input, Static
+
+from alloy_runtime_types.dtos.agents import AgentSummary
+
+from cli.infrastructure.scope_utils import format_scope_label
+from cli.infrastructure.tui.clipboard import copy_to_clipboard
+from cli.infrastructure.tui.formatters import format_datetime, truncate_text
+from cli.tui.screens.base import BrowserWidget
+from cli.tui.screens.nav_screen import NavScreen
+from cli.tui.widgets.agent_create_modal import AgentCreateModal
+from cli.tui.widgets.agent_form_modal import AgentFormResult
+from cli.tui.widgets.agent_update_modal import AgentUpdateModal
+from cli.tui.widgets.confirm_modal import ConfirmModal
+
+if TYPE_CHECKING:
+    from cli.tui.app import AlloyRuntimeApp
+
+
+class AgentsWidget(BrowserWidget[AgentSummary]):
+    """Widget for browsing and managing agents."""
+
+    app: "AlloyRuntimeApp"
+
+    TITLE = "Agents"
+    TABLE_COLUMNS = ["Name", "Scope", "Models", "Updated"]
+
+    def compose(self) -> ComposeResult:
+        """Compose the browser layout with a New Agent button."""
+        with Vertical(id="browser-root"):
+            with Vertical(id="search-container"):
+                with Horizontal(id="search-row"):
+                    yield Input(
+                        placeholder=f"Search {self.TITLE.lower()}...",
+                        id="search-input",
+                    )
+                    yield Button("+ New", id="new-agent-btn", variant="primary")
+                yield Static("Loading...", id="status-bar")
+
+            with Horizontal(id="main-container"):
+                with Vertical(id="list-container"):
+                    yield DataTable(id="data-table", cursor_type="row")
+
+                with Vertical(id="detail-container"):
+                    yield Static("Preview", id="preview-title")
+                    with VerticalScroll(id="preview-scroll"):
+                        yield Static(
+                            "Select an item to view details",
+                            id="preview-content",
+                        )
+
+    @on(Button.Pressed, "#new-agent-btn")
+    def _on_new_agent_btn_pressed(self, event: Button.Pressed) -> None:
+        """Handle New Agent button press."""
+        self.open_new_agent_modal()
+
+    async def _fetch_items(self, query: str) -> tuple[list[AgentSummary], int]:
+        """Fetch agents from the API."""
+        client = await self._ensure_client()
+        response = await client.list_agents(
+            search=query if query else None,
+            limit=50,
+        )
+
+        # Update agent cache for cross-screen use (e.g., chat agent picker)
+        self.app.store.agent_cache = list(response.agents)
+
+        return response.agents, response.total
+
+    def _format_row(self, item: AgentSummary) -> tuple[str, ...]:
+        """Format an agent as a table row."""
+        return (
+            truncate_text(item.name, max_length=30),
+            format_scope_label(
+                str(item.organization_id) if item.organization_id else None,
+                str(item.user_id) if item.user_id else None,
+            ),
+            f"{item.model_count} models",
+            format_datetime(item.updated_at),
+        )
+
+    def _update_preview(self, item: AgentSummary) -> None:
+        """Update the preview pane with agent details."""
+        preview = self.query_one("#preview-content", Static)
+
+        scope = format_scope_label(
+            str(item.organization_id) if item.organization_id else None,
+            str(item.user_id) if item.user_id else None,
+        )
+
+        created = format_datetime(item.created_at)
+        updated = format_datetime(item.updated_at)
+
+        system_instruction_id = (
+            str(item.system_instruction_version_id)
+            if item.system_instruction_version_id
+            else "-"
+        )
+        input_schema_id = str(item.input_schema_id) if item.input_schema_id else "-"
+        output_schema_id = str(item.output_schema_id) if item.output_schema_id else "-"
+
+        preview_text = f"""[bold]Agent ID:[/] {item.id}
+[bold]Name:[/] {item.name}
+[bold]Scope:[/] {scope}
+[bold]Models:[/] {item.model_count}
+
+[bold]Description:[/]
+{item.description or "(no description)"}
+
+[bold]System Instruction Version ID:[/]
+{system_instruction_id}
+
+[bold]Input Schema ID:[/]
+{input_schema_id}
+
+[bold]Output Schema ID:[/]
+{output_schema_id}
+
+[bold]Created:[/] {created}
+[bold]Updated:[/] {updated}"""
+
+        preview.update(preview_text)
+
+    # =========================================================================
+    # Public methods for parent Screen to call
+    # =========================================================================
+
+    def copy_agent_name(self) -> None:
+        """Copy the agent name to clipboard."""
+        agent = self.get_selected_item()
+        if not agent:
+            self.app.notify("No agent selected", severity="warning")
+            return
+
+        copy_to_clipboard(self.app, agent.name, "Agent name")
+
+    def open_new_agent_modal(self) -> None:
+        """Open the agent creation modal."""
+        self._open_agent_create_modal()
+
+    def open_edit_agent_modal(self) -> None:
+        """Open the agent update modal for the selected agent."""
+        agent = self.get_selected_item()
+        if not agent:
+            self.app.notify("No agent selected", severity="warning")
+            return
+        self._open_agent_update_modal(agent)
+
+    def delete_selected_agent(self) -> None:
+        """Delete the currently selected agent."""
+        agent = self.get_selected_item()
+        if not agent:
+            self.app.notify("No agent selected", severity="warning")
+            return
+
+        agent_name = agent.name
+        self.app.push_screen(
+            ConfirmModal(
+                title="Delete Agent",
+                message=f"Delete agent '{agent_name}'? This cannot be undone.",
+            ),
+            lambda confirmed: self._on_delete_confirmed(confirmed, agent_name),
+        )
+
+    # =========================================================================
+    # Internal async operations
+    # =========================================================================
+
+    @work(exclusive=True)
+    async def _open_agent_create_modal(self) -> None:
+        """Open the agent creation modal."""
+        try:
+            client = await self._ensure_client()
+            self.app.push_screen(
+                AgentCreateModal(client=client),
+                self._on_agent_created,
+            )
+        except Exception as e:
+            self.app.notify(f"Failed to open agent creator: {e}", severity="error")
+
+    def _on_agent_created(self, result: AgentFormResult | None) -> None:
+        """Callback when agent creation modal is dismissed."""
+        if result is not None:
+            self.app.notify(
+                f"Created agent: {result.agent_name}",
+                severity="information",
+            )
+            # Refresh the agent list
+            self._do_search(self._last_search)
+
+    @work(exclusive=True)
+    async def _open_agent_update_modal(self, agent_summary: AgentSummary) -> None:
+        """Fetch full agent details and open the update modal."""
+        try:
+            client = await self._ensure_client()
+            # Fetch full agent details (summary doesn't have all fields)
+            agent = await client.get_agent(str(agent_summary.id))
+            self.app.push_screen(
+                AgentUpdateModal(client=client, agent=agent),
+                self._on_agent_updated,
+            )
+        except Exception as e:
+            self.app.notify(f"Failed to open agent editor: {e}", severity="error")
+
+    def _on_agent_updated(self, result: AgentFormResult | None) -> None:
+        """Callback when agent update modal is dismissed."""
+        if result is not None:
+            self.app.notify(
+                f"Updated agent: {result.agent_name}",
+                severity="information",
+            )
+            # Refresh the agent list
+            self._do_search(self._last_search)
+
+    def _on_delete_confirmed(self, confirmed: bool | None, agent_name: str) -> None:
+        """Callback when delete confirmation modal is dismissed."""
+        if confirmed:
+            self._execute_delete(agent_name)
+
+    @work(exclusive=True)
+    async def _execute_delete(self, agent_name: str) -> None:
+        """Execute the delete operation."""
+        try:
+            client = await self._ensure_client()
+            await client.delete_agent(agent_name)
+
+            self.app.notify(
+                f"Agent '{agent_name}' deleted successfully",
+                severity="information",
+            )
+            # Refresh the agent list
+            self._do_search(self._last_search)
+
+        except Exception as e:
+            error_msg = str(e)
+            if "pipeline" in error_msg.lower():
+                self.app.notify(
+                    "Cannot delete: agent is referenced by pipelines",
+                    severity="error",
+                )
+            else:
+                self.app.notify(f"Failed to delete agent: {e}", severity="error")
+
+
+class AgentsScreen(NavScreen):
+    """Screen for browsing and managing agents.
+
+    This is a proper Textual Screen that wraps the AgentsWidget
+    and provides keybindings that work regardless of focus.
+    """
+
+    app: "AlloyRuntimeApp"
+
+    SCREEN_ID = "agents"
+
+    DEFAULT_CSS = """
+    AgentsScreen #screen-root {
+        height: 1fr;
+    }
+    
+    AgentsScreen .browser-widget {
+        height: 100%;
+        width: 100%;
+    }
+    """
+
+    # Screen-specific bindings (Ctrl+ prefixed)
+    # NavScreen.BINDINGS provides global navigation (c, a, t, s, m, d, ?)
+    BINDINGS = NavScreen.BINDINGS + [
+        Binding("ctrl+f", "focus_search", "Search", show=True),
+        Binding("ctrl+r", "refresh", "Refresh", show=True),
+        Binding("ctrl+y", "copy_name", "Copy Name", show=True),
+        Binding("ctrl+n", "new_agent", "New", show=True),
+        Binding("ctrl+e", "edit_agent", "Edit", show=True),
+        Binding("ctrl+d", "delete_agent", "Delete", show=True),
+        Binding("escape", "focus_table", "Focus List", show=False),
+        Binding("enter", "copy_name", "Copy Name", show=False),
+    ]
+
+    def compose_content(self) -> ComposeResult:
+        """Compose the screen content."""
+        yield AgentsWidget(id="agents-widget")
+
+    def on_screen_resume(self) -> None:
+        """Focus the data table when screen becomes active."""
+        self.call_after_refresh(self._focus_table)
+
+    def _focus_table(self) -> None:
+        """Focus the data table."""
+        try:
+            widget = self.query_one("#agents-widget", AgentsWidget)
+            widget.focus_table()
+        except Exception:
+            pass
+
+    def _get_widget(self) -> AgentsWidget:
+        """Get the agents widget."""
+        return self.query_one("#agents-widget", AgentsWidget)
+
+    # =========================================================================
+    # Actions (keybinding handlers)
+    # =========================================================================
+
+    def action_focus_search(self) -> None:
+        """Focus the search input."""
+        self._get_widget().focus_search()
+
+    def action_focus_table(self) -> None:
+        """Focus the data table."""
+        self._get_widget().focus_table()
+
+    def action_refresh(self) -> None:
+        """Refresh the current search results."""
+        self._get_widget().refresh_data()
+
+    def action_copy_name(self) -> None:
+        """Copy the agent name to clipboard."""
+        self._get_widget().copy_agent_name()
+
+    def action_new_agent(self) -> None:
+        """Open the agent creation modal."""
+        self._get_widget().open_new_agent_modal()
+
+    def action_edit_agent(self) -> None:
+        """Open the agent update modal."""
+        self._get_widget().open_edit_agent_modal()
+
+    def action_delete_agent(self) -> None:
+        """Delete the selected agent."""
+        self._get_widget().delete_selected_agent()