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

cli/infrastructure/forms/json_schema_builder.py

@@ -0,0 +1,149 @@
+"""JSON to JSON Schema builder component.
+
+Allows users to paste a JSON example and automatically generates
+a JSON schema using Genson. Shows real-time validation errors.
+"""
+
+import json
+from typing import Any, cast
+
+from genson import SchemaBuilder
+from textual import on
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.message import Message
+from textual.widget import Widget
+from textual.widgets import Static, TextArea
+
+
+def generate_schema_from_json(json_str: str) -> dict[str, Any] | None:
+    """Generate JSON schema from a JSON example string.
+
+    Args:
+        json_str: A JSON string representing an example object
+
+    Returns:
+        The generated JSON schema as a dict, or None if invalid JSON
+    """
+    if not json_str.strip():
+        return None
+
+    data = json.loads(json_str)
+    builder: Any = SchemaBuilder()
+    builder.add_object(data)
+    return cast(dict[str, Any], builder.to_schema())
+
+
+class JsonSchemaBuilder(Widget):
+    """Widget that converts JSON examples to JSON Schema.
+
+    Users paste a JSON object example, and this widget automatically
+    generates the corresponding JSON schema using Genson.
+
+    Usage:
+        yield JsonSchemaBuilder(id="output-schema-builder")
+
+        # Get the generated schema
+        builder = self.query_one("#output-schema-builder", JsonSchemaBuilder)
+        schema = builder.generated_schema  # dict or None
+
+    Features:
+        - Real-time JSON validation with error display
+        - Auto-generates schema as user types
+        - Shows preview of generated schema
+    """
+
+    class SchemaChanged(Message):
+        """Posted when the generated schema changes."""
+
+        def __init__(self, schema: dict[str, Any] | None) -> None:
+            self.schema = schema
+            super().__init__()
+
+    def __init__(
+        self,
+        placeholder: str = '{"name": "John", "age": 30, "active": true}',
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(**kwargs)
+        self._placeholder = placeholder
+        self._generated_schema: dict[str, Any] | None = None
+
+    @property
+    def generated_schema(self) -> dict[str, Any] | None:
+        """Get the generated JSON schema, or None if no valid input."""
+        return self._generated_schema
+
+    @property
+    def json_input(self) -> str:
+        """Get the raw JSON input text."""
+        return self.query_one("#json-input", TextArea).text.strip()
+
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            yield TextArea(
+                placeholder=self._placeholder,
+                id="json-input",
+                classes="json-input",
+            )
+            yield Static("", classes="error-label hidden", id="json-error")
+            yield Static("Generated Schema:", classes="section-label")
+            yield TextArea(
+                "Paste a JSON example above to generate schema",
+                read_only=True,
+                id="schema-preview",
+                classes="schema-preview",
+            )
+
+    @on(TextArea.Changed, "#json-input")
+    def on_json_changed(self, event: TextArea.Changed) -> None:
+        """Validate JSON and generate schema as user types."""
+        self._update_schema(event.text_area.text)
+
+    def _update_schema(self, json_text: str) -> None:
+        """Update the generated schema from JSON input."""
+        error_label = self.query_one("#json-error", Static)
+        preview = self.query_one("#schema-preview", TextArea)
+
+        json_text = json_text.strip()
+
+        if not json_text:
+            # Empty input
+            self._generated_schema = None
+            error_label.update("")
+            error_label.add_class("hidden")
+            preview.text = "Paste a JSON example above to generate schema"
+            self.post_message(self.SchemaChanged(None))
+            return
+
+        try:
+            schema = generate_schema_from_json(json_text)
+            self._generated_schema = schema
+
+            # Show success - display the schema
+            error_label.update("")
+            error_label.add_class("hidden")
+
+            if schema:
+                schema_str = json.dumps(schema, indent=2)
+                preview.text = schema_str
+            else:
+                preview.text = "Empty schema generated"
+
+            self.post_message(self.SchemaChanged(schema))
+
+        except json.JSONDecodeError as e:
+            # Show error
+            self._generated_schema = None
+            error_label.update(
+                f"Invalid JSON: {e.msg} (line {e.lineno}, col {e.colno})"
+            )
+            error_label.remove_class("hidden")
+            preview.text = "Fix JSON errors to generate schema"
+            self.post_message(self.SchemaChanged(None))
+
+    def clear(self) -> None:
+        """Clear the input and generated schema."""
+        self.query_one("#json-input", TextArea).clear()
+        self._generated_schema = None
+        self._update_schema("")

cli/infrastructure/forms/model_picker.py

@@ -0,0 +1,134 @@
+"""Model picker widget with search and multi-select.
+
+A search input that uses the ApiClient to fetch models on each keystroke,
+displaying results in a static list below. Users can select multiple
+models (primary + fallbacks) using Space or Enter.
+"""
+
+from typing import Any
+
+from textual import on
+from textual.message import Message
+from textual.widgets import OptionList
+
+from alloy_runtime_sdk.api_client.client import ApiClient
+from alloy_runtime_types.dtos.models import ModelListItemResponse
+
+from cli.infrastructure.forms.base_picker import MultiSelectPicker
+
+
+class ModelPicker(MultiSelectPicker[ModelListItemResponse]):
+    """Multi-select model picker with live search.
+
+    Uses the ApiClient to fetch models on each keystroke. Results appear in a
+    static box below the search input.
+
+    Usage:
+        yield ModelPicker(
+            client=server_client,
+            id="models"
+        )
+
+        # Get selected models
+        picker = self.query_one("#models", ModelPicker)
+        models = picker.selected_models  # List[ModelListItemResponse]
+
+    Keybindings:
+        - Type to search (fetches from API)
+        - Up/Down to navigate results
+        - Space or Enter to select/deselect
+    """
+
+    class ModelsChanged(Message):
+        """Posted when selected models change."""
+
+        def __init__(self, models: list[ModelListItemResponse]) -> None:
+            self.models = models
+            super().__init__()
+
+    def __init__(
+        self,
+        client: ApiClient,
+        placeholder: str = "Type to search models (e.g., gpt-4, claude, sonnet)...",
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the model picker.
+
+        Args:
+            client: ApiClient instance for API calls
+            placeholder: Placeholder text for search input
+        """
+        super().__init__(
+            client=client,
+            placeholder=placeholder,
+            empty_message="No models selected",
+            **kwargs,
+        )
+
+    @property
+    def selected_models(self) -> list[ModelListItemResponse]:
+        """Get the list of selected models in order (primary first, then fallbacks)."""
+        return self.selected_items
+
+    async def _fetch_items(self, query: str) -> list[ModelListItemResponse]:
+        """Fetch models matching query from the API."""
+        response = await self._client.list_models(
+            search=query,
+            configured_only=True,
+            limit=100,
+        )
+        return list(response.models)
+
+    def _format_item(self, item: ModelListItemResponse) -> str:
+        """Format model for display in option list."""
+        return f"{item.provider_key}:{item.provider_model_name}"
+
+    def _get_item_id(self, item: ModelListItemResponse) -> str:
+        """Get unique identifier for a model."""
+        return f"{item.provider_key}:{item.provider_model_name}"
+
+    def _get_result_count_message(self, count: int) -> str:
+        """Get status message for result count."""
+        if count == 0:
+            return "No models found"
+        return f"{count} model{'s' if count != 1 else ''} found - Space/Enter to select"
+
+    def _format_selection_display(self) -> str | None:
+        """Format selected models as an ordered list."""
+        if not self._selected_items:
+            return None
+
+        lines: list[str] = []
+        for i, model in enumerate(self._selected_items.values()):
+            model_label = f"{model.provider_key}:{model.provider_model_name}"
+            if i == 0:
+                lines.append(f"[bold green]1. {model_label}[/] (primary)")
+            else:
+                lines.append(f"{i + 1}. {model_label}")
+        return "\n".join(lines)
+
+    def _post_selection_changed(self) -> None:
+        """Post ModelsChanged message instead of generic SelectionChanged."""
+        self.post_message(self.ModelsChanged(self.selected_models))
+
+    def on_key(self, event: Any) -> None:
+        """Handle space key to toggle selection."""
+        if event.key == "space":
+            options = self.query_one("#search-options", OptionList)
+            if options.highlighted is not None:
+                self._handle_item_selection(options.highlighted)
+                event.prevent_default()
+                event.stop()
+
+    @on(OptionList.OptionHighlighted, "#search-options")
+    def on_option_highlighted(self, event: OptionList.OptionHighlighted) -> None:
+        """Handle highlighting - space key handling is done via on_key."""
+        pass
+
+    def set_initial_models(self, models: list[ModelListItemResponse]) -> None:
+        """Pre-populate the picker with existing model selections.
+
+        Args:
+            models: List of ModelListItemResponse objects to pre-select
+        """
+        self.set_initial_selections(models)

cli/infrastructure/forms/parsers.py

@@ -0,0 +1,173 @@
+"""Form value parsing utilities.
+
+Provides reusable parsing methods for common form input types with
+validation and user-friendly error messages.
+
+Usage:
+    from cli.infrastructure.forms.parsers import FormParsers
+
+    class MyWidget(Widget, FormParsers):
+        def _parse_values(self):
+            temperature = self.parse_float(
+                self.query_one("#temperature", Input).value,
+                "Temperature",
+                min_val=0.0,
+                max_val=2.0
+            )
+            user_id = self.parse_uuid(self.query_one("#user_id", Input).value, "User ID")
+            config = self.parse_json(self.query_one("#config", TextArea).text, "Config")
+"""
+
+import json
+from typing import Any, cast
+from uuid import UUID
+
+
+class FormParsers:
+    """Mixin providing common value parsing methods for form apps.
+
+    All parsing methods follow the same pattern:
+    - Return None for empty strings
+    - Raise ValueError with user-friendly message on invalid input
+    - Support optional bounds/constraints
+    """
+
+    def parse_uuid(self, value: str, field_name: str) -> UUID | None:
+        """Parse UUID string or return None for empty input.
+
+        Args:
+            value: String value to parse (may be empty)
+            field_name: Human-readable field name for error messages
+
+        Returns:
+            Parsed UUID or None if input is empty
+
+        Raises:
+            ValueError: If value is non-empty but not a valid UUID
+        """
+        if not value:
+            return None
+        try:
+            return UUID(value)
+        except ValueError:
+            raise ValueError(f"{field_name} must be a valid UUID")
+
+    def parse_float(
+        self,
+        value: str,
+        field_name: str,
+        min_val: float | None = None,
+        max_val: float | None = None,
+    ) -> float | None:
+        """Parse float with optional bounds validation.
+
+        Args:
+            value: String value to parse (may be empty)
+            field_name: Human-readable field name for error messages
+            min_val: Optional minimum value (inclusive)
+            max_val: Optional maximum value (inclusive)
+
+        Returns:
+            Parsed float or None if input is empty
+
+        Raises:
+            ValueError: If value is non-empty but not a valid float,
+                       or if value is outside specified bounds
+        """
+        if not value:
+            return None
+        try:
+            f = float(value)
+            if min_val is not None and f < min_val:
+                raise ValueError(f"{field_name} must be >= {min_val}")
+            if max_val is not None and f > max_val:
+                raise ValueError(f"{field_name} must be <= {max_val}")
+            return f
+        except ValueError as e:
+            if "must be" in str(e):
+                raise
+            raise ValueError(f"{field_name} must be a number")
+
+    def parse_int(
+        self,
+        value: str,
+        field_name: str,
+        min_val: int | None = None,
+        max_val: int | None = None,
+    ) -> int | None:
+        """Parse integer with optional bounds validation.
+
+        Args:
+            value: String value to parse (may be empty)
+            field_name: Human-readable field name for error messages
+            min_val: Optional minimum value (inclusive)
+            max_val: Optional maximum value (inclusive)
+
+        Returns:
+            Parsed integer or None if input is empty
+
+        Raises:
+            ValueError: If value is non-empty but not a valid integer,
+                       or if value is outside specified bounds
+        """
+        if not value:
+            return None
+        try:
+            i = int(value)
+            if min_val is not None and i < min_val:
+                raise ValueError(f"{field_name} must be >= {min_val}")
+            if max_val is not None and i > max_val:
+                raise ValueError(f"{field_name} must be <= {max_val}")
+            return i
+        except ValueError as e:
+            if "must be" in str(e):
+                raise
+            raise ValueError(f"{field_name} must be an integer")
+
+    def parse_json(self, value: str, field_name: str) -> dict[str, Any] | None:
+        """Parse JSON string to dict.
+
+        Args:
+            value: JSON string to parse (may be empty)
+            field_name: Human-readable field name for error messages
+
+        Returns:
+            Parsed dict or None if input is empty
+
+        Raises:
+            ValueError: If value is non-empty but not valid JSON,
+                       or if JSON is not an object (dict)
+        """
+        if not value:
+            return None
+        try:
+            result = json.loads(value)
+            if not isinstance(result, dict):
+                raise ValueError(f"{field_name} must be a JSON object")
+            return cast(dict[str, Any], result)
+        except json.JSONDecodeError as e:
+            raise ValueError(f"{field_name} has invalid JSON: {e}")
+
+    def parse_json_list(self, value: str, field_name: str) -> list[Any] | None:
+        """Parse JSON string to list.
+
+        Args:
+            value: JSON string to parse (may be empty)
+            field_name: Human-readable field name for error messages
+
+        Returns:
+            Parsed list or None if input is empty
+
+        Raises:
+            ValueError: If value is non-empty but not valid JSON,
+                       or if JSON is not an array (list)
+        """
+        if not value:
+            return None
+        try:
+            result = json.loads(value)
+            if not isinstance(result, list):
+                raise ValueError(f"{field_name} must be a JSON array")
+            return cast(list[Any], result)
+        except json.JSONDecodeError as e:
+            raise ValueError(f"{field_name} has invalid JSON: {e}")