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

cli/infrastructure/forms/tag_picker.py

@@ -0,0 +1,207 @@
+"""Tag picker widget for selecting multiple tags.
+
+A multi-select search picker that uses the ApiClient to fetch tags
+and allows selecting multiple tags by their paths. Supports creating
+new tags on-the-fly when the searched tag doesn't exist.
+"""
+
+from typing import Any
+
+from textual.message import Message
+from textual.widgets import OptionList
+from textual.widgets.option_list import Option
+
+from alloy_runtime_sdk.api_client.client import ApiClient
+
+from cli.infrastructure.forms.base_picker import MultiSelectPicker
+from cli.infrastructure.validation.tag_validation import validate_tag_path
+
+
+class TagPicker(MultiSelectPicker[dict[str, Any]]):
+    """Multi-select tag picker with live API search and on-the-fly tag creation.
+
+    Uses the ApiClient to fetch tags on each keystroke. Results appear in a
+    list below the search input. User can select multiple tags.
+
+    When searching for a tag that doesn't exist, the picker shows an option
+    to create the new tag. The tag will be auto-created on the server when
+    the content is saved.
+
+    Usage:
+        yield TagPicker(
+            client=server_client,
+            placeholder="Search tags...",
+            id="tags",
+        )
+
+        # Get selected tag paths
+        picker = self.query_one("#tags", TagPicker)
+        tag_paths = picker.selected_tags  # list[str]
+    """
+
+    class TagsChanged(Message):
+        """Posted when selected tags change."""
+
+        def __init__(self, selected_tags: list[str]) -> None:
+            self.selected_tags = selected_tags
+            super().__init__()
+
+    def __init__(
+        self,
+        client: ApiClient,
+        placeholder: str = "Search tags...",
+        empty_message: str = "No tags selected (required)",
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the tag picker.
+
+        Args:
+            client: ApiClient instance for API calls
+            placeholder: Placeholder text for search input
+            empty_message: Message shown when nothing is selected
+        """
+        super().__init__(
+            client=client,
+            placeholder=placeholder,
+            empty_message=empty_message,
+            **kwargs,
+        )
+        self._last_search_query: str = ""
+
+    @property
+    def selected_tags(self) -> list[str]:
+        """Get the list of selected tag paths."""
+        return list(self._selected_items.keys())
+
+    @property
+    def selected_tag_items(self) -> list[dict[str, Any]]:
+        """Get the full selected tag dicts."""
+        return list(self._selected_items.values())
+
+    async def _fetch_items(self, query: str) -> list[dict[str, Any]]:
+        """Fetch tags matching query from the API."""
+        self._last_search_query = query
+        response = await self._client.list_tags(search=query, limit=50)
+        results = [tag.model_dump() for tag in response.tags]
+
+        # Check if query exactly matches any existing tag
+        exact_match_exists = any(tag.get("tag_path", "") == query for tag in results)
+
+        # If no exact match, check if we can offer to create the tag
+        if not exact_match_exists:
+            is_valid, _ = validate_tag_path(query)
+            if is_valid:
+                # Add synthetic "create new tag" option at the top
+                create_option = {
+                    "tag_path": query,
+                    "display_name": query,
+                    "_is_new": True,
+                }
+                results.insert(0, create_option)
+
+        return results
+
+    def _format_item(self, item: dict[str, Any]) -> str:
+        """Format tag for display in option list."""
+        tag_path = item.get("tag_path", "")
+        is_new = item.get("_is_new", False)
+
+        if is_new:
+            return f"[cyan][+] Create:[/] {tag_path}"
+        else:
+            display_name = item.get("display_name", tag_path)
+            if display_name and display_name != tag_path:
+                return f"{tag_path} ({display_name})"
+            return tag_path
+
+    def _get_item_id(self, item: dict[str, Any]) -> str:
+        """Get unique identifier for a tag (its path)."""
+        return item.get("tag_path", "")
+
+    def _get_result_count_message(self, count: int) -> str:
+        """Get status message for result count."""
+        # Count existing vs new tags
+        existing_count = sum(
+            1 for t in self._search_results if not t.get("_is_new", False)
+        )
+        has_create_option = any(t.get("_is_new", False) for t in self._search_results)
+
+        if existing_count == 0 and not has_create_option:
+            # No results and query is invalid
+            is_valid, error = validate_tag_path(self._last_search_query)
+            if not is_valid:
+                return f"[yellow]{error}[/]"
+            return "No tags found"
+        elif has_create_option and existing_count == 0:
+            return "No existing tags - Enter to create new tag"
+        elif has_create_option:
+            return f"{existing_count} tag{'s' if existing_count != 1 else ''} found - or create new"
+        else:
+            return f"{existing_count} tag{'s' if existing_count != 1 else ''} - Enter to toggle"
+
+    def _update_options(self) -> None:
+        """Update the option list with current search results (custom styling for tags)."""
+        options = self.query_one("#search-options", OptionList)
+        options.clear_options()
+
+        for i, tag in enumerate(self._search_results):
+            tag_path = tag.get("tag_path", "")
+            is_new = tag.get("_is_new", False)
+
+            if is_new:
+                # Style "create new tag" option distinctly
+                if tag_path in self._selected_items:
+                    display_text = f"[green]✓[/] [cyan][+] Create:[/] {tag_path}"
+                else:
+                    display_text = f"  [cyan][+] Create:[/] {tag_path}"
+            else:
+                # Existing tag with display name
+                display_name = tag.get("display_name", tag_path)
+                if display_name and display_name != tag_path:
+                    display_text = f"{tag_path} ({display_name})"
+                else:
+                    display_text = tag_path
+
+                # Mark selected tags with checkmark
+                if tag_path in self._selected_items:
+                    display_text = f"[green]✓[/] {display_text}"
+                else:
+                    display_text = f"  {display_text}"
+
+            options.add_option(Option(display_text, id=f"opt-{i}"))
+
+        if self._search_results:
+            options.highlighted = 0
+
+    def _format_selection_display(self) -> str | None:
+        """Format selected tags for display."""
+        if not self._selected_items:
+            return None
+
+        # Format tags, marking new ones with (new)
+        formatted_tags: list[str] = []
+        for tag_path, tag_data in self._selected_items.items():
+            if tag_data.get("_is_new", False):
+                formatted_tags.append(f"[cyan]{tag_path}[/] [dim](new)[/]")
+            else:
+                formatted_tags.append(tag_path)
+
+        paths = ", ".join(formatted_tags)
+        return f"[bold green]Selected ({len(self._selected_items)}):[/] {paths}"
+
+    def _post_selection_changed(self) -> None:
+        """Post TagsChanged message with tag paths."""
+        self.post_message(self.TagsChanged(self.selected_tags))
+
+    def set_initial_selection(self, tags: list[dict[str, Any]]) -> None:
+        """Pre-populate the picker with existing tag selections.
+
+        Args:
+            tags: List of tag dicts with at least 'tag_path' key
+        """
+        self._selected_items.clear()
+        for tag in tags:
+            tag_path = tag.get("tag_path", "")
+            if tag_path:
+                self._selected_items[tag_path] = tag
+        self._update_selected_display()

cli/infrastructure/forms/template_picker.py

@@ -0,0 +1,131 @@
+"""Template picker component for selecting system instruction templates.
+
+A specialized search picker that uses the ApiClient to fetch templates
+and returns the selected template's latest version ID.
+"""
+
+from typing import Any
+
+from alloy_runtime_sdk.api_client.client import ApiClient
+from alloy_runtime_types.enums.template_enums import TemplateContentType
+
+from cli.infrastructure.forms.base_picker import SingleSelectPicker
+
+
+def _format_template(template: dict[str, Any]) -> str:
+    """Format a template for display in the picker."""
+    name = template.get("name", "Unknown")
+    version = template.get("latest_version_number", "?")
+    visibility = template.get("visibility_id", "private")
+    content_type = template.get("content_type_id", "")
+
+    # Short visibility label
+    vis_label = {"private": "Private", "organization": "Org", "public": "Public"}.get(
+        visibility, visibility
+    )
+
+    # Include content type if not system_instruction (since that's the default filter)
+    type_label = ""
+    if content_type and content_type != "system_instruction":
+        type_label = f" [{content_type}]"
+
+    return f"{name} (v{version}) - {vis_label}{type_label}"
+
+
+class TemplatePicker(SingleSelectPicker[dict[str, Any]]):
+    """Template picker for selecting system instruction templates.
+
+    Searches templates via the ApiClient and returns the selected template's
+    latest version ID. User sees friendly template names, not UUIDs.
+
+    Usage:
+        yield TemplatePicker(
+            client=server_client,
+            id="system-template",
+        )
+
+        # Get selected version ID
+        picker = self.query_one("#system-template", TemplatePicker)
+        version_id = picker.selected_id  # UUID string or None
+    """
+
+    def __init__(
+        self,
+        client: ApiClient,
+        content_type: TemplateContentType
+        | None = TemplateContentType.SYSTEM_INSTRUCTION,
+        placeholder: str = "Search templates (e.g., system prompt default)...",
+        empty_message: str = "No template selected (optional)",
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the template picker.
+
+        Args:
+            client: ApiClient instance for API calls
+            content_type: Filter by template content type (default: system_instruction)
+            placeholder: Placeholder text for search input
+            empty_message: Message shown when nothing is selected
+        """
+        super().__init__(
+            client=client,
+            placeholder=placeholder,
+            empty_message=empty_message,
+            **kwargs,
+        )
+        self._content_type = content_type
+
+    @property
+    def selected_version_id(self) -> str | None:
+        """Alias for selected_id - returns the template version UUID."""
+        return self.selected_id
+
+    @property
+    def selected_template_name(self) -> str | None:
+        """Get the name of the selected template."""
+        if self._selected_item is None:
+            return None
+        return self._selected_item.get("name")
+
+    async def _fetch_items(self, query: str) -> list[dict[str, Any]]:
+        """Fetch templates matching query from the API."""
+        response = await self._client.list_templates(
+            search=query,
+            content_type=self._content_type,
+            limit=50,
+        )
+        return [template.model_dump() for template in response.templates]
+
+    def _format_item(self, item: dict[str, Any]) -> str:
+        """Format template for display in option list."""
+        return _format_template(item)
+
+    def _get_item_id(self, item: dict[str, Any]) -> str:
+        """Get unique identifier for a template (latest_version_id)."""
+        return str(item.get("latest_version_id", ""))
+
+    def _is_item_selected(self, item: dict[str, Any]) -> bool:
+        """Check if an item is currently selected (by latest_version_id)."""
+        if self._selected_item is None:
+            return False
+        return self._get_item_id(item) == self._get_item_id(self._selected_item)
+
+    def set_initial_template(self, template: dict[str, Any]) -> None:
+        """Pre-populate the picker with an existing template selection.
+
+        Args:
+            template: Template dict with at least 'latest_version_id' and 'name' keys
+        """
+        self.set_initial_selection(template)
+
+    def set_initial_template_by_version_id(
+        self, version_id: str, name: str = "Selected Template"
+    ) -> None:
+        """Pre-populate the picker with a template by its version ID.
+
+        Use this when you only have the version ID and not the full template data.
+
+        Args:
+            version_id: The template version UUID
+            name: Display name for the template
+        """
+        self.set_initial_selection({"latest_version_id": version_id, "name": name})

cli/infrastructure/forms/tool_config_picker.py

@@ -0,0 +1,130 @@
+"""Tool config picker widget with search and single-select.
+
+A search input that uses the ApiClient to fetch tool configs on each keystroke,
+displaying results in a static list below. Filters by tool_id to only show
+configs for a specific tool.
+"""
+
+from typing import Any
+
+from alloy_runtime_sdk.api_client.client import ApiClient
+from alloy_runtime_types.dtos.tool_configs import ToolConfigSummary
+
+from cli.infrastructure.forms.base_picker import SingleSelectPicker
+
+
+class ToolConfigPicker(SingleSelectPicker[ToolConfigSummary]):
+    """Single-select tool config picker with live search.
+
+    Filters tool configs by tool_id to only show configs for the selected tool.
+
+    Usage:
+        yield ToolConfigPicker(
+            client=server_client,
+            tool_id="rag_search",
+            id="tool-config-picker"
+        )
+
+        # Get selected config
+        picker = self.query_one("#tool-config-picker", ToolConfigPicker)
+        config = picker.selected_config  # ToolConfigSummary | None
+
+    Keybindings:
+        - Type to search (fetches from API)
+        - Up/Down to navigate results
+        - Enter to select/deselect
+    """
+
+    def __init__(
+        self,
+        client: ApiClient,
+        tool_id: str | None = None,
+        placeholder: str = "Type to search saved configs...",
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the tool config picker.
+
+        Args:
+            client: ApiClient instance for API calls
+            tool_id: Filter by tool ID (e.g., 'rag_search')
+            placeholder: Placeholder text for search input
+        """
+        super().__init__(
+            client=client,
+            placeholder=placeholder,
+            empty_message="No saved config selected",
+            fetch_on_mount=True,  # Load configs initially
+            **kwargs,
+        )
+        self._tool_id = tool_id
+
+    @property
+    def tool_id(self) -> str | None:
+        """Get the tool ID filter."""
+        return self._tool_id
+
+    @tool_id.setter
+    def tool_id(self, value: str | None) -> None:
+        """Set the tool ID filter and refresh results."""
+        self._tool_id = value
+        # Clear current selection if tool changed
+        self.clear()
+        # Trigger a refresh
+        if self._fetch_on_mount:
+            self._fetch_initial()
+
+    @property
+    def selected_config(self) -> ToolConfigSummary | None:
+        """Get the selected tool config."""
+        return self.selected_item
+
+    @property
+    def selected_config_id(self) -> str | None:
+        """Get the ID of the selected tool config as string."""
+        if self.selected_item:
+            return str(self.selected_item.id)
+        return None
+
+    async def _fetch_items(self, query: str) -> list[ToolConfigSummary]:
+        """Fetch tool configs matching query from the API."""
+        if not self._tool_id:
+            # No tool selected yet, return empty list
+            return []
+
+        response = await self._client.list_tool_configs(
+            search=query if query else None,
+            tool_id=self._tool_id,
+            limit=50,
+        )
+        return list(response.tool_configs)
+
+    def _format_item(self, item: ToolConfigSummary) -> str:
+        """Format tool config for display in option list."""
+        desc = ""
+        if item.description:
+            desc = (
+                f" - {item.description[:30]}..."
+                if len(item.description) > 30
+                else f" - {item.description}"
+            )
+        return f"{item.name}{desc}"
+
+    def _get_item_id(self, item: ToolConfigSummary) -> str:
+        """Get unique identifier for a tool config."""
+        return str(item.id)
+
+    def _get_result_count_message(self, count: int) -> str:
+        """Get status message for result count."""
+        if count == 0:
+            if not self._tool_id:
+                return "Select a tool first"
+            return "No saved configs found for this tool"
+        return f"{count} config{'s' if count != 1 else ''} found - Enter to select"
+
+    def set_initial_config(self, config: ToolConfigSummary) -> None:
+        """Pre-populate the picker with an existing config selection.
+
+        Args:
+            config: ToolConfigSummary object to pre-select
+        """
+        self.set_initial_selection(config)

cli/infrastructure/forms/tool_picker.py

@@ -0,0 +1,103 @@
+"""Tool picker widget with search and single-select.
+
+A search input that uses the ApiClient to fetch available tools on each keystroke,
+displaying results in a static list below. Users can select a single tool.
+"""
+
+from typing import Any
+
+from alloy_runtime_sdk.api_client.client import ApiClient
+from alloy_runtime_types.dtos.tools import ToolResponse
+
+from cli.infrastructure.forms.base_picker import SingleSelectPicker
+
+
+class ToolPicker(SingleSelectPicker[ToolResponse]):
+    """Single-select tool picker with live search.
+
+    Uses the ApiClient to fetch tools on each keystroke. Results appear in a
+    static box below the search input.
+
+    Usage:
+        yield ToolPicker(
+            client=server_client,
+            id="tool-picker"
+        )
+
+        # Get selected tool
+        picker = self.query_one("#tool-picker", ToolPicker)
+        tool = picker.selected_tool  # ToolResponse | None
+
+    Keybindings:
+        - Type to search (fetches from API)
+        - Up/Down to navigate results
+        - Enter to select/deselect
+    """
+
+    def __init__(
+        self,
+        client: ApiClient,
+        placeholder: str = "Type to search tools (e.g., rag, web, search)...",
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the tool picker.
+
+        Args:
+            client: ApiClient instance for API calls
+            placeholder: Placeholder text for search input
+        """
+        super().__init__(
+            client=client,
+            placeholder=placeholder,
+            empty_message="No tool selected",
+            fetch_on_mount=True,  # Load all tools initially
+            **kwargs,
+        )
+
+    @property
+    def selected_tool(self) -> ToolResponse | None:
+        """Get the selected tool."""
+        return self.selected_item
+
+    @property
+    def selected_tool_id(self) -> str | None:
+        """Get the ID of the selected tool."""
+        return self.selected_id
+
+    async def _fetch_items(self, query: str) -> list[ToolResponse]:
+        """Fetch tools matching query from the API."""
+        response = await self._client.list_tools(
+            search=query if query else None,
+            limit=50,
+        )
+        return list(response.tools)
+
+    def _format_item(self, item: ToolResponse) -> str:
+        """Format tool for display in option list."""
+        has_config = item.parameter_schema is not None
+        config_indicator = " [dim][configurable][/]" if has_config else ""
+        # Truncate description if too long
+        desc = (
+            item.description[:50] + "..."
+            if len(item.description) > 50
+            else item.description
+        )
+        return f"{item.id}{config_indicator} - {desc}"
+
+    def _get_item_id(self, item: ToolResponse) -> str:
+        """Get unique identifier for a tool."""
+        return item.id
+
+    def _get_result_count_message(self, count: int) -> str:
+        """Get status message for result count."""
+        if count == 0:
+            return "No tools found"
+        return f"{count} tool{'s' if count != 1 else ''} found - Enter to select"
+
+    def set_initial_tool(self, tool: ToolResponse) -> None:
+        """Pre-populate the picker with an existing tool selection.
+
+        Args:
+            tool: ToolResponse object to pre-select
+        """
+        self.set_initial_selection(tool)