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

cli/tui/widgets/schema_update_modal.py

@@ -0,0 +1,188 @@
+"""Schema update modal for editing existing schemas.
+
+Provides a modal screen that allows users to edit schema name and description.
+"""
+
+import re
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from textual import on, work
+from textual.app import ComposeResult
+from textual.containers import Horizontal, VerticalScroll
+from textual.widgets import (
+    Button,
+    Input,
+    Label,
+    Static,
+)
+
+from cli.tui.widgets.base_form_modal import BaseFormModal
+
+from alloy_runtime_sdk.api_client.client import ApiClient
+from alloy_runtime_types.dtos.schemas import GetSchemaResponse, UpdateSchemaRequest
+
+if TYPE_CHECKING:
+    from cli.tui.app import AlloyRuntimeApp
+
+
+@dataclass
+class SchemaUpdateResult:
+    """Result of successful schema update."""
+
+    schema_id: str
+    schema_name: str
+    version: int
+
+
+class SchemaUpdateModal(BaseFormModal[SchemaUpdateResult]):
+    """Modal for updating schema name and description.
+
+    Usage:
+        def on_schema_updated(result: SchemaUpdateResult | None):
+            if result is not None:
+                self.notify(f"Updated schema: {result.schema_name}")
+                self._do_search("")  # Refresh list
+
+        client = await self.app.store.get_client()
+        full_schema = await client.get_schema(schema_id)
+        self.app.push_screen(
+            SchemaUpdateModal(client=client, schema=full_schema),
+            on_schema_updated
+        )
+    """
+
+    app: "AlloyRuntimeApp"
+
+    def __init__(
+        self,
+        client: ApiClient,
+        schema: GetSchemaResponse,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the schema update modal.
+
+        Args:
+            client: ApiClient instance for API calls
+            schema: The schema to edit (full details from get_schema)
+        """
+        super().__init__(**kwargs)
+        self._client = client
+        self._schema = schema
+
+    def compose(self) -> ComposeResult:
+        with VerticalScroll(id="schema-update-modal"):
+            yield Label(
+                f"Edit Schema: {self._schema.schema_name}", classes="modal-title"
+            )
+
+            # Schema info (read-only)
+            yield Static("[bold]Schema Info[/]", classes="form-section")
+
+            yield Static(
+                f"[dim]Format:[/] {self._schema.schema_format_id}  "
+                f"[dim]Version:[/] v{self._schema.version}  "
+                f"[dim]ID:[/] {str(self._schema.id)[:8]}...",
+                id="schema-info",
+                classes="info-display",
+            )
+
+            # Editable fields
+            yield Static("[bold]Edit Properties[/]", classes="form-section")
+
+            yield Static(
+                "Name (lowercase, dots/dashes/underscores)", classes="field-label"
+            )
+            yield Input(
+                value=self._schema.schema_name,
+                placeholder="e.g., user.profile, api.response-format",
+                id="name-input",
+            )
+
+            yield Static("Description", classes="field-label")
+            yield Input(
+                value=self._schema.description or "",
+                placeholder="Brief description of this schema's purpose",
+                id="description-input",
+            )
+
+            # Error display
+            yield Static("", id="error-display", classes="error-display")
+
+            with Horizontal(classes="button-row"):
+                yield Button("Update Schema", id="update-btn", variant="success")
+                yield Button("Cancel", id="cancel-btn", variant="default")
+
+    def on_mount(self) -> None:
+        """Focus the name input on mount."""
+        self.query_one("#name-input", Input).focus()
+
+    @on(Button.Pressed, "#update-btn")
+    def on_update_pressed(self, event: Button.Pressed) -> None:
+        """Handle update button press."""
+        self.action_submit()
+
+    @on(Button.Pressed, "#cancel-btn")
+    def on_cancel_pressed(self, event: Button.Pressed) -> None:
+        """Handle cancel button press."""
+        self.dismiss(None)
+
+    def action_submit(self) -> None:
+        """Handle form submission."""
+        try:
+            self._validate_fields()
+            self._hide_error()
+            self._finalize_submission()
+        except ValueError as e:
+            self._show_error(str(e))
+
+    def _validate_fields(self) -> None:
+        """Validate all required fields."""
+        name = self.query_one("#name-input", Input).value.strip()
+        if not name:
+            raise ValueError("Name is required")
+
+        if not re.match(r"^[a-z0-9._-]+$", name):
+            raise ValueError(
+                "Name must be lowercase alphanumeric with dots, dashes, or underscores only"
+            )
+
+    def _build_request(self) -> UpdateSchemaRequest:
+        """Build the API request."""
+        name = self.query_one("#name-input", Input).value.strip()
+        description = self.query_one("#description-input", Input).value.strip()
+
+        # Only include fields that have changed
+        request_name = name if name != self._schema.schema_name else None
+        request_description = (
+            description if description != (self._schema.description or "") else None
+        )
+
+        return UpdateSchemaRequest(
+            name=request_name,
+            description=request_description,
+        )
+
+    @work(exclusive=True)
+    async def _finalize_submission(self) -> None:
+        """Submit to API."""
+        try:
+            request = self._build_request()
+
+            # Check if anything actually changed
+            if request.name is None and request.description is None:
+                self.app.notify("No changes made", severity="information")
+                self.dismiss(None)
+                return
+
+            response = await self._client.update_schema(self._schema.id, request)
+
+            result = SchemaUpdateResult(
+                schema_id=str(response.id),
+                schema_name=response.schema_name,
+                version=response.version,
+            )
+            self.dismiss(result)
+
+        except Exception as e:
+            self._show_error(f"Failed to update schema: {e}")

cli/tui/widgets/status_footer.py

@@ -0,0 +1,147 @@
+"""StatusFooter widget - vim-style status bar with notification support.
+
+This widget replaces both the standard Footer and toast notifications with
+a unified status bar that shows keyboard shortcuts by default and temporarily
+displays notifications.
+"""
+
+from typing import Any
+
+from textual.app import ComposeResult
+from textual.containers import Container
+from textual.reactive import reactive
+from textual.timer import Timer
+from textual.widget import Widget
+from textual.widgets import Footer, Static
+
+
+class StatusFooter(Widget):
+    """A footer that can show temporary notifications in place of key bindings.
+
+    By default, displays keyboard shortcuts like the standard Footer.
+    When show_notification() is called, temporarily shows the notification
+    message with appropriate styling, then reverts to shortcuts.
+
+    This is implemented as a container that swaps between a Footer widget
+    and a notification Static widget.
+    """
+
+    DEFAULT_CSS = """
+    StatusFooter {
+        dock: bottom;
+        height: 1;
+        width: 100%;
+    }
+
+    StatusFooter > Container {
+        height: 1;
+        width: 100%;
+    }
+
+    StatusFooter Footer {
+        height: 1;
+    }
+
+    StatusFooter .notification-bar {
+        height: 1;
+        width: 100%;
+        padding: 0 1;
+        display: none;
+    }
+
+    StatusFooter .notification-bar.visible {
+        display: block;
+    }
+
+    StatusFooter .notification-bar.info {
+        background: $primary;
+        color: $text;
+    }
+
+    StatusFooter .notification-bar.success {
+        background: $success;
+        color: $text;
+    }
+
+    StatusFooter .notification-bar.warning {
+        background: $warning;
+        color: $text;
+    }
+
+    StatusFooter .notification-bar.error {
+        background: $error;
+        color: $text;
+    }
+
+    StatusFooter Footer.hidden {
+        display: none;
+    }
+    """
+
+    notification_active: reactive[bool] = reactive(False)
+
+    def __init__(self, **kwargs: Any) -> None:
+        """Initialize the status footer."""
+        super().__init__(**kwargs)
+        self._notification_timer: Timer | None = None
+
+    def compose(self) -> ComposeResult:
+        """Compose the footer with both normal footer and notification bar."""
+        with Container():
+            # Footer shows key hints for all tabs
+            yield Footer(id="footer-keys")
+            yield Static("", id="notification-bar", classes="notification-bar")
+
+    def show_notification(
+        self,
+        message: str,
+        severity: str = "information",
+        timeout: float = 2.0,
+    ) -> None:
+        """Show a notification message temporarily.
+
+        Args:
+            message: The notification message to display
+            severity: One of "information", "warning", "error"
+            timeout: Seconds before reverting to shortcuts (default 3.0)
+        """
+        # Cancel any existing timer
+        if self._notification_timer is not None:
+            self._notification_timer.stop()
+            self._notification_timer = None
+
+        # Update notification bar content and styling
+        notification_bar = self.query_one("#notification-bar", Static)
+        footer = self.query_one("#footer-keys", Footer)
+
+        # Set the message
+        notification_bar.update(message)
+
+        # Reset classes and apply severity
+        notification_bar.remove_class("info", "success", "warning", "error")
+        severity_class = {
+            "information": "info",
+            "success": "success",
+            "warning": "warning",
+            "error": "error",
+        }.get(severity, "info")
+        notification_bar.add_class(severity_class)
+
+        # Show notification, hide footer
+        notification_bar.add_class("visible")
+        footer.add_class("hidden")
+        self.notification_active = True
+
+        # Schedule clearing the notification
+        self._notification_timer = self.set_timer(timeout, self._clear_notification)
+
+    def _clear_notification(self) -> None:
+        """Clear the notification and show shortcuts again."""
+        notification_bar = self.query_one("#notification-bar", Static)
+        footer = self.query_one("#footer-keys", Footer)
+
+        # Hide notification, show footer
+        notification_bar.remove_class("visible")
+        footer.remove_class("hidden")
+        self.notification_active = False
+        self._notification_timer = None