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

cli/tui/widgets/agent_update_modal.py

@@ -0,0 +1,299 @@
+"""Agent update modal for editing existing agents.
+
+Provides a comprehensive modal screen that allows users to edit an existing agent
+with all its current fields pre-populated.
+"""
+
+from typing import Any
+
+from textual import work
+from textual.widgets import Input, TextArea
+
+from alloy_runtime_sdk.api_client.client import ApiClient
+from alloy_runtime_types.dtos.agents import (
+    GetAgentResponse,
+    UpdateAgentRequest,
+)
+from alloy_runtime_types.dtos.models import ModelListItemResponse
+from alloy_runtime_types.enums.ownership_scope import OwnershipScope
+
+from cli.infrastructure.forms.schema_picker import SchemaPicker
+from cli.infrastructure.forms.tag_picker import TagPicker
+from cli.infrastructure.forms.template_picker import TemplatePicker
+from cli.tui.widgets.agent_form_modal import AgentFormModal, AgentFormResult
+
+
+class AgentUpdateModal(AgentFormModal):
+    """Modal for updating an existing agent.
+
+    Pre-populates all form fields with the current agent configuration.
+    Scope cannot be changed after creation.
+
+    Usage:
+        def on_agent_updated(result: AgentFormResult | None):
+            if result is not None:
+                self.notify(f"Updated agent: {result.agent_name}")
+                self._do_search("")  # Refresh list
+
+        client = await self.app.store.get_client()
+        agent = await client.get_agent(agent_id)
+        self.app.push_screen(
+            AgentUpdateModal(client=client, agent=agent),
+            on_agent_updated
+        )
+    """
+
+    def __init__(
+        self,
+        client: ApiClient,
+        agent: GetAgentResponse,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the agent update modal.
+
+        Args:
+            client: ApiClient instance for API calls
+            agent: The agent to edit (full details from get_agent)
+        """
+        super().__init__(client=client, **kwargs)
+        self._agent = agent
+
+    def _get_modal_title(self) -> str:
+        """Return the modal title."""
+        return f"Edit Agent: {self._agent.name}"
+
+    def _get_submit_button_text(self) -> str:
+        """Return the submit button text."""
+        return "Update Agent"
+
+    def _is_scope_editable(self) -> bool:
+        """Return whether the scope can be changed (not allowed for updates)."""
+        return False
+
+    def on_mount(self) -> None:
+        """Populate form fields with existing agent data."""
+        super().on_mount()
+        self._populate_form_async()
+
+    @work(exclusive=True)
+    async def _populate_form_async(self) -> None:
+        """Populate all form fields with the existing agent data (async for API calls)."""
+        agent = self._agent
+
+        # Basic fields
+        self._set_name(agent.name)
+        self._set_description(agent.description)
+
+        # Scope (read-only, just display)
+        scope = self._infer_scope_from_agent(agent)
+        self._set_scope(scope)
+
+        # Models - need to convert AgentModelResponse to ModelListItemResponse-like objects
+        if agent.models:
+            model_items = [
+                ModelListItemResponse(
+                    provider_key=m.provider_key.value,  # Use .value to get string from enum
+                    provider_model_name=m.provider_model_name,
+                    is_active=True,  # Assume active since it's assigned to agent
+                    input_modalities=["text"],  # Default, actual not stored on agent
+                    output_modalities=["text"],  # Default, actual not stored on agent
+                )
+                for m in sorted(agent.models, key=lambda x: x.preference_order)
+            ]
+            self._set_models(model_items)
+
+        # Tags - need to convert AgentTagResponse to dict format
+        if agent.tags:
+            tag_items = [
+                {
+                    "tag_path": t.tag_path,
+                    "display_name": t.display_name,
+                    "id": str(t.tag_id),
+                }
+                for t in agent.tags
+            ]
+            self._set_tags(tag_items)
+
+        # Base agent
+        if agent.base_agent_id:
+            self._set_base_agent(str(agent.base_agent_id), "Base Agent")
+
+        # System instruction template - fetch actual data
+        if agent.system_instruction_version_id:
+            template_data = await self._fetch_template_data(
+                str(agent.system_instruction_version_id)
+            )
+            if template_data:
+                # Use the set_initial_selection with full data for proper display
+                template_picker = self.query_one(
+                    "#system-template-picker", TemplatePicker
+                )
+                template_picker.set_initial_selection(template_data)
+
+        # Output schema - fetch actual data
+        if agent.output_schema_id:
+            schema_data = await self._fetch_schema_data(str(agent.output_schema_id))
+            if schema_data:
+                # Use the set_initial_selection with full data for proper display
+                output_schema_picker = self.query_one(
+                    "#output-schema-picker", SchemaPicker
+                )
+                output_schema_picker.set_initial_selection(schema_data)
+
+        # Generation params
+        if agent.generation_params:
+            self._set_generation_params(agent.generation_params)
+
+        # Default headers
+        if agent.default_request_headers:
+            self._set_default_headers(agent.default_request_headers)
+
+        # Tools
+        if agent.tools:
+            self._set_tools(agent.tools)
+
+    def _infer_scope_from_agent(self, agent: GetAgentResponse) -> OwnershipScope:
+        """Infer the scope from agent ownership fields."""
+        if agent.user_id:
+            return OwnershipScope.USER
+        elif agent.organization_id:
+            return OwnershipScope.ORGANIZATION
+        else:
+            return OwnershipScope.GLOBAL
+
+    async def _fetch_template_data(self, version_id: str) -> dict[str, Any] | None:
+        """Fetch the template data for a given version ID.
+
+        Args:
+            version_id: Template version UUID
+
+        Returns:
+            Template data dict for display, or None if fetch fails
+        """
+        try:
+            # Get template by version ID using the new endpoint
+            from uuid import UUID
+
+            response = await self._client.get_template_by_version(UUID(version_id))
+
+            # Find the specific version to get its version number
+            matching_version = next(
+                (v for v in response.versions if str(v.id) == version_id), None
+            )
+            version_number = matching_version.version if matching_version else "?"
+
+            # Build data dict that matches what the picker's formatter expects
+            return {
+                "latest_version_id": version_id,
+                "name": response.template.name,
+                "latest_version_number": version_number,
+                "visibility_id": response.template.visibility_id,
+                "content_type_id": response.template.content_type_id,
+            }
+        except Exception:
+            # If fetch fails, create a minimal fallback dict
+            return {
+                "latest_version_id": version_id,
+                "name": f"Template ({version_id[:8]}...)",
+                "latest_version_number": "?",
+                "visibility_id": "private",
+                "content_type_id": "",
+            }
+
+    async def _fetch_schema_data(self, schema_id: str) -> dict[str, Any] | None:
+        """Fetch the schema data for a given schema ID.
+
+        Args:
+            schema_id: Schema UUID
+
+        Returns:
+            Schema data dict for display, or None if fetch fails
+        """
+        try:
+            response = await self._client.get_schema(schema_id)
+            # Build data dict that matches what the picker's formatter expects
+            return {
+                "id": schema_id,
+                "schema_name": response.schema_name,
+                "version": response.version,
+                "schema_format_id": response.schema_format_id,
+                "user_id": str(response.user_id) if response.user_id else None,
+                "organization_id": str(response.organization_id)
+                if response.organization_id
+                else None,
+                "description": response.description,
+            }
+        except Exception:
+            # If fetch fails, create a minimal fallback dict
+            return {
+                "id": schema_id,
+                "schema_name": f"Schema ({schema_id[:8]}...)",
+                "version": "?",
+                "schema_format_id": "unknown",
+                "user_id": None,
+                "organization_id": None,
+                "description": None,
+            }
+
+    async def _submit_form(self) -> AgentFormResult:
+        """Submit the form to update the agent."""
+        request = self._build_update_request()
+        response = await self._client.update_agent(self._agent.id, request)
+
+        return AgentFormResult(
+            agent_id=str(response.id),
+            agent_name=response.name,
+            is_update=True,
+        )
+
+    def _build_update_request(self) -> UpdateAgentRequest:
+        """Build the UpdateAgentRequest from form fields."""
+        # Name
+        name = self.query_one("#name-input", Input).value.strip()
+
+        # Models
+        model_configs = self._build_model_configs()
+
+        # Tags
+        tag_picker = self.query_one("#tag-picker", TagPicker)
+        tags = tag_picker.selected_tags
+
+        # Description
+        description = self.query_one("#description-input", Input).value.strip() or None
+
+        # System instruction template
+        template_picker = self.query_one("#system-template-picker", TemplatePicker)
+        system_instruction_version_id = self._parse_uuid(
+            template_picker.selected_id, "System Template"
+        )
+
+        # Schemas
+        output_schema_picker = self.query_one("#output-schema-picker", SchemaPicker)
+        output_schema_id = self._parse_uuid(
+            output_schema_picker.selected_id, "Output Schema"
+        )
+
+        # Output schema from JSON builder
+        output_schema = self._get_output_schema()
+
+        # Generation parameters
+        gen_params = self._build_generation_params()
+
+        # Default headers
+        default_headers = self._parse_json(
+            self.query_one("#default-headers-textarea", TextArea).text,
+            "Default Headers",
+        )
+
+        return UpdateAgentRequest(
+            name=name,
+            models=model_configs,
+            tags=tags,
+            description=description,
+            system_instruction_version_id=system_instruction_version_id,
+            output_schema_id=output_schema_id,
+            output_schema=output_schema,
+            default_request_headers=default_headers,
+            generation_params=gen_params,
+            tools=self._build_tools(),
+        )

cli/tui/widgets/base_form_modal.py

@@ -0,0 +1,77 @@
+"""Base class for form modals with error handling.
+
+Provides common functionality for all form modals:
+- Standard cancel/submit bindings
+- Error display methods
+- Auto-hide error on input change
+"""
+
+from typing import Generic, TypeVar
+
+from textual import on
+from textual.binding import Binding
+from textual.screen import ModalScreen
+from textual.widgets import Input, Static, TextArea
+
+T = TypeVar("T")
+
+
+class BaseFormModal(ModalScreen[T | None], Generic[T]):
+    """Abstract base for all form modals with error handling.
+
+    Provides:
+    - Standard cancel/submit bindings (escape, ctrl+s)
+    - Error display methods (_show_error, _hide_error)
+    - Auto-hide error on input/textarea change
+    - Standard action_cancel implementation
+
+    Subclasses must:
+    - Include Static(id="error-display") in compose()
+    - Implement action_submit()
+
+    Usage:
+        class MyModal(BaseFormModal[MyResult]):
+            def compose(self) -> ComposeResult:
+                # ... form fields ...
+                yield Static("", id="error-display", classes="error-display")
+                # ... buttons ...
+
+            def action_submit(self) -> None:
+                try:
+                    self._validate()
+                    self._hide_error()
+                    self._finalize()
+                except ValueError as e:
+                    self._show_error(str(e))
+    """
+
+    BINDINGS = [
+        Binding("escape", "cancel", "Cancel", show=True),
+        Binding("ctrl+s", "submit", "Submit", show=True, priority=True),
+    ]
+
+    def _show_error(self, message: str) -> None:
+        """Show an error message."""
+        error_display = self.query_one("#error-display", Static)
+        error_display.update(f"[red]Error: {message}[/]")
+        error_display.add_class("visible")
+
+    def _hide_error(self) -> None:
+        """Hide the error display."""
+        error_display = self.query_one("#error-display", Static)
+        error_display.update("")
+        error_display.remove_class("visible")
+
+    def action_cancel(self) -> None:
+        """Cancel and dismiss the modal."""
+        self.dismiss(None)
+
+    @on(Input.Changed)
+    def on_input_changed(self, event: Input.Changed) -> None:
+        """Auto-hide error when any input changes."""
+        self._hide_error()
+
+    @on(TextArea.Changed)
+    def on_textarea_changed(self, event: TextArea.Changed) -> None:
+        """Auto-hide error when any textarea changes."""
+        self._hide_error()

cli/tui/widgets/confirm_modal.py

@@ -0,0 +1,75 @@
+"""Confirmation modal for destructive actions."""
+
+from typing import Any
+
+from textual import on
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Button, Static
+
+
+class ConfirmModal(ModalScreen[bool]):
+    """Modal for confirming destructive actions.
+
+    Usage:
+        def callback(confirmed: bool) -> None:
+            if confirmed:
+                # Perform action
+                pass
+
+        self.app.push_screen(
+            ConfirmModal(
+                title="Delete Agent",
+                message="Delete agent 'my-agent'? This cannot be undone.",
+            ),
+            callback
+        )
+    """
+
+    BINDINGS = [
+        Binding("escape", "cancel", "Cancel", show=True),
+        Binding("n", "cancel", "No", show=False),
+    ]
+
+    def __init__(
+        self,
+        title: str = "Confirm Action",
+        message: str = "Are you sure?",
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the confirmation modal.
+
+        Args:
+            title: Modal title
+            message: Confirmation message to display
+            **kwargs: Additional keyword arguments for ModalScreen
+        """
+        super().__init__(**kwargs)
+        self._title = title
+        self._message = message
+
+    def compose(self) -> ComposeResult:
+        """Compose the modal layout."""
+        with Vertical(id="confirm-modal"):
+            yield Static(self._title, classes="modal-title")
+            yield Static(self._message, id="confirm-message")
+
+            with Horizontal(classes="button-row"):
+                yield Button("Cancel", id="cancel-btn", variant="default")
+                yield Button("Confirm", id="confirm-btn", variant="error")
+
+    @on(Button.Pressed, "#confirm-btn")
+    def on_confirm_pressed(self, event: Button.Pressed) -> None:
+        """Confirm the action."""
+        self.dismiss(True)
+
+    @on(Button.Pressed, "#cancel-btn")
+    def on_cancel_pressed(self, event: Button.Pressed) -> None:
+        """Cancel the action."""
+        self.dismiss(False)
+
+    def action_cancel(self) -> None:
+        """Cancel via escape or n key."""
+        self.dismiss(False)

cli/tui/widgets/help_modal.py

@@ -0,0 +1,145 @@
+"""Help modal showing keyboard shortcuts and features.
+
+Provides a modal screen with comprehensive keyboard shortcut reference
+for all screens in the TUI application.
+"""
+
+from typing import Any
+
+from textual import on
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical, VerticalScroll
+from textual.screen import ModalScreen
+from textual.widgets import Button, Static
+
+
+class HelpModal(ModalScreen[None]):
+    """Modal showing keyboard shortcuts and help information.
+
+    Usage:
+        self.app.push_screen(HelpModal())
+    """
+
+    BINDINGS = [
+        Binding("escape", "close", "Close", show=True),
+        Binding("q", "close", "Close", show=False),
+    ]
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            yield Static("Keyboard Shortcuts", classes="modal-title")
+
+            with VerticalScroll():
+                # Global navigation (works everywhere)
+                yield Static("[bold]Global Navigation[/]", classes="section-title")
+                yield Static("[cyan]c[/]         Switch to Chat screen")
+                yield Static("[cyan]a[/]         Switch to Agents screen")
+                yield Static("[cyan]t[/]         Switch to Templates screen")
+                yield Static("[cyan]m[/]         Switch to Content (media) screen")
+                yield Static("[cyan]s[/]         Switch to Schemas screen")
+                yield Static("[cyan]g[/]         Switch to Tool Configs screen")
+                yield Static("[cyan]d[/]         Show Dashboard")
+                yield Static("[cyan]?[/]         Show this help")
+                yield Static("[cyan]Ctrl+C[/]    Quit application")
+
+                # Chat screen
+                yield Static("[bold]Chat Screen[/]", classes="section-title")
+                yield Static("[cyan]Ctrl+N[/]    New chat session")
+                yield Static("[cyan]Ctrl+D[/]    Send message")
+                yield Static("[cyan]Ctrl+E[/]    Open message in $EDITOR")
+                yield Static("[cyan]Ctrl+R[/]    Regenerate last response")
+                yield Static("[cyan]Ctrl+U[/]    Undo last turn")
+                yield Static("[cyan]Ctrl+Y[/]    Copy last response")
+                yield Static("[cyan]Ctrl+Shift+Y[/]  Copy all messages")
+                yield Static("[cyan]Ctrl+L[/]    Clear display")
+                yield Static("[cyan]Ctrl+B[/]    Toggle sidebar")
+                yield Static("[cyan]Escape[/]    Cancel streaming / Focus input")
+                yield Static("[cyan]g[/]         Scroll to top")
+                yield Static("[cyan]G[/]         Scroll to bottom")
+
+                # Chat split view
+                yield Static("[bold]Chat Split View[/]", classes="section-title")
+                yield Static("[cyan]Ctrl+Shift+S[/]  Toggle split view")
+                yield Static("[cyan]Ctrl+Shift+Tab[/]  Switch between panes")
+                yield Static("[cyan]Ctrl+Shift+Y[/]  Toggle sync mode (send to both)")
+
+                # Welcome screen (when no session active)
+                yield Static(
+                    "[bold]Welcome Screen (Agent Quick Select)[/]",
+                    classes="section-title",
+                )
+                yield Static("[cyan]1-9[/]       Select agent by number")
+
+                # Browser screens (Agents/Templates/Content/Schemas)
+                yield Static(
+                    "[bold]Browser Screens (Agents/Templates/Content/Schemas)[/]",
+                    classes="section-title",
+                )
+                yield Static("[cyan]Ctrl+F[/]    Focus search input")
+                yield Static("[cyan]Ctrl+R[/]    Refresh results")
+                yield Static("[cyan]Ctrl+Y[/]    Copy name/content")
+                yield Static("[cyan]Ctrl+N[/]    Create new item")
+                yield Static("[cyan]Escape[/]    Focus list")
+                yield Static("[cyan]Enter[/]     Copy name/content")
+                yield Static("[cyan]Up/Down[/]   Navigate list")
+
+                # Agents specific
+                yield Static("[bold]Agents Screen[/]", classes="section-title")
+                yield Static("[cyan]Ctrl+E[/]    Edit selected agent")
+                yield Static("[cyan]Ctrl+D[/]    Delete selected agent")
+
+                # Templates specific
+                yield Static("[bold]Templates Screen[/]", classes="section-title")
+                yield Static("[cyan]Ctrl+Shift+Y[/]  Copy template content")
+                yield Static("[cyan]Ctrl+E[/]    Edit template in $EDITOR")
+                yield Static("[cyan]Ctrl+U[/]    Edit template name/description")
+                yield Static("[cyan]Ctrl+V[/]    Create new version")
+                yield Static("[cyan]Ctrl+O[/]    Render and open template")
+
+                # Content specific
+                yield Static("[bold]Content Screen[/]", classes="section-title")
+                yield Static(
+                    "[cyan]Three search inputs:[/] Fuzzy, Tag filter, External ID"
+                )
+                yield Static(
+                    "[cyan]Ctrl+I[/]    Copy ID (external_id if set, else UUID)"
+                )
+                yield Static("[cyan]Ctrl+T[/]    Manage tags")
+                yield Static("[cyan]Ctrl+E[/]    View in $EDITOR")
+                yield Static("[cyan]Ctrl+D[/]    Delete selected content")
+
+                # Schemas specific
+                yield Static("[bold]Schemas Screen[/]", classes="section-title")
+                yield Static("[cyan]Ctrl+Shift+Y[/]  Copy schema definition")
+                yield Static("[cyan]Ctrl+E[/]    Edit definition in $EDITOR")
+                yield Static("[cyan]Ctrl+U[/]    Edit schema name/description")
+                yield Static("[cyan]Ctrl+V[/]    Create new version")
+
+                # Tool Configs specific
+                yield Static("[bold]Tool Configs Screen[/]", classes="section-title")
+                yield Static("[cyan]Ctrl+E[/]    Edit selected config")
+                yield Static(
+                    "[cyan]Ctrl+D[/]    Delete selected config (blocked if in use)"
+                )
+
+                # Modals
+                yield Static("[bold]Modals & Dialogs[/]", classes="section-title")
+                yield Static("[cyan]Escape[/]    Cancel / Close modal")
+                yield Static("[cyan]Ctrl+S[/]    Submit form")
+                yield Static("[cyan]n[/]         Cancel (confirmation dialogs)")
+
+            with Vertical(classes="button-row"):
+                yield Button("Close", id="close-btn", variant="primary")
+
+    @on(Button.Pressed, "#close-btn")
+    def on_close_pressed(self, event: Button.Pressed) -> None:
+        """Close the modal."""
+        self.dismiss(None)
+
+    def action_close(self) -> None:
+        """Close via escape or q key."""
+        self.dismiss(None)