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

cli/tui/widgets/template_update_modal.py

@@ -0,0 +1,308 @@
+"""Template update modal for editing existing template metadata.
+
+Provides a modal screen that allows users to edit template name, description,
+content type, visibility, and tags.
+"""
+
+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,
+    RadioButton,
+    RadioSet,
+    Static,
+)
+
+from cli.tui.widgets.base_form_modal import BaseFormModal
+
+from alloy_runtime_sdk.api_client.client import ApiClient
+from alloy_runtime_types.dtos.templates import (
+    TemplateListItemResponse,
+    UpdateTemplateRequest,
+)
+from alloy_runtime_types.enums.template_enums import (
+    TemplateContentType,
+    TemplateVisibility,
+)
+
+from cli.infrastructure.forms.tag_picker import TagPicker
+
+if TYPE_CHECKING:
+    from cli.tui.app import AlloyRuntimeApp
+
+
+@dataclass
+class TemplateUpdateResult:
+    """Result of successful template update."""
+
+    template_id: str
+    template_name: str
+
+
+class TemplateUpdateModal(BaseFormModal[TemplateUpdateResult]):
+    """Modal for updating template metadata.
+
+    Provides a form with:
+    - Editable fields: name, content type, visibility, description, tags
+    - Read-only info: ID, version count
+
+    Usage:
+        def on_template_updated(result: TemplateUpdateResult | None):
+            if result is not None:
+                self.notify(f"Updated template: {result.template_name}")
+                self._do_search("")  # Refresh list
+
+        client = await self.app.store.get_client()
+        self.app.push_screen(
+            TemplateUpdateModal(client=client, template=template),
+            on_template_updated
+        )
+    """
+
+    app: "AlloyRuntimeApp"
+
+    def __init__(
+        self,
+        client: ApiClient,
+        template: TemplateListItemResponse,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the template update modal.
+
+        Args:
+            client: ApiClient instance for API calls
+            template: The template to edit
+        """
+        super().__init__(**kwargs)
+        self._client = client
+        self._template = template
+
+    def compose(self) -> ComposeResult:
+        with VerticalScroll(id="template-update-modal"):
+            yield Label(f"Edit Template: {self._template.name}", classes="modal-title")
+
+            # Template info (read-only)
+            yield Static("[bold]Template Info[/]", classes="form-section")
+
+            yield Static(
+                f"[dim]ID:[/] {str(self._template.id)[:8]}...  "
+                f"[dim]Versions:[/] {self._template.latest_version_number}",
+                id="template-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._template.name,
+                placeholder="e.g., email.welcome-header, system.default_prompt",
+                id="name-input",
+            )
+
+            yield Static("Content Type", classes="field-label")
+            with RadioSet(id="content-type-radios"):
+                yield RadioButton(
+                    "System Instruction",
+                    id="type-system",
+                    value=self._template.content_type_id == "system_instruction",
+                )
+                yield RadioButton(
+                    "User Message",
+                    id="type-user",
+                    value=self._template.content_type_id == "user_message",
+                )
+                yield RadioButton(
+                    "Fragment",
+                    id="type-fragment",
+                    value=self._template.content_type_id == "fragment",
+                )
+
+            yield Static("Visibility", classes="field-label")
+            with RadioSet(id="visibility-radios"):
+                yield RadioButton(
+                    "Private",
+                    id="vis-private",
+                    value=self._template.visibility_id == "private",
+                )
+                yield RadioButton(
+                    "Organization",
+                    id="vis-org",
+                    value=self._template.visibility_id == "organization",
+                )
+                yield RadioButton(
+                    "Public",
+                    id="vis-public",
+                    value=self._template.visibility_id == "public",
+                )
+
+            yield Static("Description", classes="field-label")
+            yield Input(
+                value=self._template.description or "",
+                placeholder="Brief description of this template's purpose",
+                id="description-input",
+            )
+
+            yield Static("Tags", classes="field-label")
+            yield TagPicker(
+                client=self._client,
+                placeholder="Search tags...",
+                empty_message="No tags selected",
+                id="tag-picker",
+            )
+
+            # Error display
+            yield Static("", id="error-display", classes="error-display")
+
+            with Horizontal(classes="button-row"):
+                yield Button("Update Template", id="update-btn", variant="success")
+                yield Button("Cancel", id="cancel-btn", variant="default")
+
+    def on_mount(self) -> None:
+        """Focus the name input and populate tags on mount."""
+        self.query_one("#name-input", Input).focus()
+        self._populate_tags()
+
+    def _populate_tags(self) -> None:
+        """Populate the tag picker with existing tags."""
+        tag_picker = self.query_one("#tag-picker", TagPicker)
+        existing_tags = [
+            {"tag_path": t.tag_path, "display_name": t.display_name}
+            for t in self._template.tags
+        ]
+        if existing_tags:
+            tag_picker.set_initial_selection(existing_tags)
+
+    @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 _get_content_type(self) -> TemplateContentType:
+        """Get content type from RadioSet."""
+        radios = self.query_one("#content-type-radios", RadioSet)
+        pressed = radios.pressed_button
+        if pressed is None or pressed.id == "type-system":
+            return TemplateContentType.SYSTEM_INSTRUCTION
+        elif pressed.id == "type-user":
+            return TemplateContentType.USER_MESSAGE
+        else:
+            return TemplateContentType.FRAGMENT
+
+    def _get_visibility(self) -> TemplateVisibility:
+        """Get visibility from RadioSet."""
+        radios = self.query_one("#visibility-radios", RadioSet)
+        pressed = radios.pressed_button
+        if pressed is None or pressed.id == "vis-private":
+            return TemplateVisibility.PRIVATE
+        elif pressed.id == "vis-org":
+            return TemplateVisibility.ORGANIZATION
+        else:
+            return TemplateVisibility.PUBLIC
+
+    def _build_request(self) -> UpdateTemplateRequest:
+        """Build the API request with only changed fields."""
+        name = self.query_one("#name-input", Input).value.strip()
+        description = self.query_one("#description-input", Input).value.strip()
+        content_type = self._get_content_type()
+        visibility = self._get_visibility()
+
+        tag_picker = self.query_one("#tag-picker", TagPicker)
+        new_tag_paths = tag_picker.selected_tags
+        old_tag_paths = [t.tag_path for t in self._template.tags]
+
+        # Only include fields that have changed
+        request_name = name if name != self._template.name else None
+
+        request_description: str | None = None
+        old_description = self._template.description or ""
+        if description != old_description:
+            request_description = description  # Empty string clears description
+
+        request_content_type = (
+            content_type
+            if content_type.value != self._template.content_type_id
+            else None
+        )
+        request_visibility = (
+            visibility if visibility.value != self._template.visibility_id else None
+        )
+
+        # Compare tag lists (order-insensitive)
+        request_tag_paths = (
+            new_tag_paths if sorted(new_tag_paths) != sorted(old_tag_paths) else None
+        )
+
+        return UpdateTemplateRequest(
+            name=request_name,
+            content_type=request_content_type,
+            visibility=request_visibility,
+            description=request_description,
+            tag_paths=request_tag_paths,
+        )
+
+    @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.content_type is None
+                and request.visibility is None
+                and request.description is None
+                and request.tag_paths is None
+            ):
+                self.app.notify("No changes made", severity="information")
+                self.dismiss(None)
+                return
+
+            response = await self._client.update_template(
+                str(self._template.id), request
+            )
+
+            result = TemplateUpdateResult(
+                template_id=str(response.template.id),
+                template_name=response.template.name,
+            )
+            self.dismiss(result)
+
+        except Exception as e:
+            self._show_error(f"Failed to update template: {e}")

cli/tui/widgets/tool_config_create_modal.py

@@ -0,0 +1,216 @@
+"""Tool config creation modal for creating new tool configurations.
+
+Provides a modal screen that allows users to create a new tool configuration
+with required fields: name, tool_id, config JSON, and optional description.
+"""
+
+import json
+from dataclasses import dataclass
+from typing import Any
+
+from textual import on, work
+from textual.app import ComposeResult
+from textual.containers import Horizontal, VerticalScroll
+from textual.widgets import (
+    Button,
+    Input,
+    Label,
+    RadioButton,
+    RadioSet,
+    Static,
+    TextArea,
+)
+
+from cli.infrastructure.scope_utils import get_scope_from_radioset
+from cli.tui.widgets.base_form_modal import BaseFormModal
+
+from alloy_runtime_sdk.api_client.client import ApiClient
+from alloy_runtime_types.dtos.tool_configs import CreateToolConfigRequest
+from alloy_runtime_types.enums.ownership_scope import OwnershipScope
+
+
+@dataclass
+class ToolConfigCreateResult:
+    """Result of successful tool config creation."""
+
+    config_id: str
+    config_name: str
+
+
+class ToolConfigCreateModal(BaseFormModal[ToolConfigCreateResult]):
+    """Modal for creating a new tool configuration.
+
+    Provides a form with:
+    - Required fields: name, tool_id, config (JSON)
+    - Scope selection (user/organization/global)
+    - Optional: description
+
+    Usage:
+        def on_config_created(result: ToolConfigCreateResult | None):
+            if result is not None:
+                self.notify(f"Created config: {result.config_name}")
+                self._do_search("")  # Refresh list
+
+        client = await self.app.store.get_client()
+        self.app.push_screen(
+            ToolConfigCreateModal(client=client),
+            on_config_created
+        )
+    """
+
+    def __init__(
+        self,
+        client: ApiClient,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the tool config creation modal.
+
+        Args:
+            client: ApiClient instance for API calls
+        """
+        super().__init__(**kwargs)
+        self._client = client
+
+    def compose(self) -> ComposeResult:
+        with VerticalScroll(id="tool-config-create-modal"):
+            yield Label("Create Tool Config", classes="modal-title")
+
+            # ===== REQUIRED FIELDS =====
+            yield Static("[bold]Required[/]", classes="form-section")
+
+            yield Static("Name", classes="field-label")
+            yield Input(
+                placeholder="e.g., RAG with HyDE, Fast Web Search",
+                id="name-input",
+            )
+
+            yield Static("Tool ID", classes="field-label")
+            yield Input(
+                placeholder="e.g., rag_search, web_search",
+                id="tool-id-input",
+            )
+
+            yield Static("Scope", classes="field-label")
+            with RadioSet(id="scope-radios"):
+                yield RadioButton("User (personal)", id="scope-user", value=True)
+                yield RadioButton("Organization", id="scope-org")
+                yield RadioButton("Global", id="scope-global")
+
+            yield Static(
+                "Configuration (JSON object with tool parameters)",
+                classes="field-label",
+            )
+            yield TextArea(
+                id="config-textarea",
+                classes="definition-input",
+            )
+
+            # ===== OPTIONAL FIELDS =====
+            yield Static("[bold]Optional[/]", classes="form-section")
+
+            yield Static("Description", classes="field-label")
+            yield Input(
+                placeholder="Brief description of this configuration",
+                id="description-input",
+            )
+
+            # Error display
+            yield Static("", id="error-display", classes="error-display")
+
+            with Horizontal(classes="button-row"):
+                yield Button("Create Config", id="create-btn", variant="success")
+                yield Button("Cancel", id="cancel-btn", variant="default")
+
+    def on_mount(self) -> None:
+        """Focus the name input and set default config on mount."""
+        self.query_one("#config-textarea", TextArea).text = "{}"
+        self.query_one("#name-input", Input).focus()
+
+    @on(Button.Pressed, "#create-btn")
+    def on_create_pressed(self, event: Button.Pressed) -> None:
+        """Handle create 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 len(name) > 255:
+            raise ValueError("Name must be 255 characters or less")
+
+        tool_id = self.query_one("#tool-id-input", Input).value.strip()
+        if not tool_id:
+            raise ValueError("Tool ID is required")
+
+        config_text = self.query_one("#config-textarea", TextArea).text.strip()
+        if not config_text:
+            raise ValueError("Configuration is required")
+
+        try:
+            config = json.loads(config_text)
+            if not isinstance(config, dict):
+                raise ValueError(
+                    "Configuration must be a JSON object (not array/primitive)"
+                )
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Invalid JSON in configuration: {e.msg}")
+
+    def _get_scope(self) -> OwnershipScope:
+        """Get scope from RadioSet."""
+        return get_scope_from_radioset(self.query_one("#scope-radios", RadioSet))
+
+    def _build_request(self) -> CreateToolConfigRequest:
+        """Build the API request."""
+        name = self.query_one("#name-input", Input).value.strip()
+        tool_id = self.query_one("#tool-id-input", Input).value.strip()
+        config_text = self.query_one("#config-textarea", TextArea).text.strip()
+        config = json.loads(config_text)
+        description = self.query_one("#description-input", Input).value.strip() or None
+
+        return CreateToolConfigRequest(
+            name=name,
+            tool_id=tool_id,
+            config=config,
+            description=description,
+            scope=self._get_scope(),
+        )
+
+    @work(exclusive=True)
+    async def _finalize_submission(self) -> None:
+        """Submit to API."""
+        try:
+            request = self._build_request()
+            response = await self._client.create_tool_config(request)
+
+            result = ToolConfigCreateResult(
+                config_id=str(response.id),
+                config_name=response.name,
+            )
+            self.dismiss(result)
+
+        except Exception as e:
+            error_msg = str(e)
+            # Provide user-friendly error messages
+            if "409" in error_msg or "conflict" in error_msg.lower():
+                self._show_error(
+                    "A tool config with this name already exists in this scope"
+                )
+            elif "validation" in error_msg.lower():
+                self._show_error(f"Invalid configuration: {error_msg}")
+            else:
+                self._show_error(f"Failed to create tool config: {error_msg}")