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

cli/tui/widgets/new_session_modal.py

@@ -0,0 +1,328 @@
+"""New session modal for creating chat sessions.
+
+Provides a modal screen that allows users to create a new chat session,
+selecting either an agent or a direct model to use.
+"""
+
+from dataclasses import dataclass
+from typing import Any
+from uuid import UUID
+
+from textual import on
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical, VerticalScroll
+from textual.screen import ModalScreen
+from textual.widgets import (
+    Button,
+    Input,
+    Label,
+    Static,
+    TabbedContent,
+    TabPane,
+    TextArea,
+)
+
+from alloy_runtime_sdk.api_client.client import ApiClient
+from alloy_runtime_types.dtos.models import ModelListItemResponse
+
+from cli.infrastructure.forms.agent_picker import AgentPicker
+from cli.infrastructure.forms.base_picker import SingleSelectPicker
+
+
+@dataclass
+class NewSessionConfig:
+    """Configuration for a new chat session.
+
+    Supports two modes:
+    - Agent mode: Use agent_id/agent_name (model comes from agent config)
+    - Model mode: Use provider_key/provider_model_name directly
+    """
+
+    name: str | None
+    # Agent mode fields
+    agent_id: UUID | None = None
+    agent_name: str | None = None
+    # Model mode fields
+    provider_key: str | None = None
+    provider_model_name: str | None = None
+    system_instruction: str | None = None
+
+    @property
+    def is_model_mode(self) -> bool:
+        """Check if this config uses direct model mode."""
+        return self.provider_key is not None and self.provider_model_name is not None
+
+    @property
+    def is_agent_mode(self) -> bool:
+        """Check if this config uses agent mode."""
+        return self.agent_id is not None
+
+
+class SingleModelPicker(SingleSelectPicker[ModelListItemResponse]):
+    """Single-select model picker for the new session modal.
+
+    Unlike ModelPicker which allows multi-select for fallback models,
+    this picker only allows selecting one model for direct model chat.
+    """
+
+    def __init__(
+        self,
+        client: ApiClient,
+        placeholder: str = "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 model selected",
+            **kwargs,
+        )
+
+    @property
+    def selected_model(self) -> ModelListItemResponse | None:
+        """Get the selected model."""
+        return self._selected_item
+
+    @property
+    def selected_provider_key(self) -> str | None:
+        """Get the provider key of the selected model."""
+        if self._selected_item is None:
+            return None
+        return self._selected_item.provider_key
+
+    @property
+    def selected_model_name(self) -> str | None:
+        """Get the model name of the selected model."""
+        if self._selected_item is None:
+            return None
+        return self._selected_item.provider_model_name
+
+    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=50,
+        )
+        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}"
+
+
+class NewSessionModal(ModalScreen[NewSessionConfig | None]):
+    """Modal for creating a new chat session.
+
+    Allows users to optionally name the session and select either:
+    - An agent (uses agent's system instruction and models)
+    - A model directly (optionally with a custom system instruction)
+
+    Returns NewSessionConfig on create, or None if cancelled.
+
+    Usage:
+        def on_session_created(result: NewSessionConfig | None):
+            if result is not None:
+                # Create session with result
+                pass
+
+        self.app.push_screen(
+            NewSessionModal(client=server_client),
+            on_session_created
+        )
+    """
+
+    BINDINGS = [
+        Binding("escape", "cancel", "Cancel", show=True),
+    ]
+
+    DEFAULT_CSS = """
+    NewSessionModal {
+        align: center middle;
+    }
+    
+    NewSessionModal > Vertical {
+        width: 80;
+        max-height: 40;
+        background: $surface;
+        border: thick $primary;
+        padding: 1 2;
+    }
+    
+    NewSessionModal .modal-title {
+        text-align: center;
+        text-style: bold;
+        margin-bottom: 1;
+    }
+    
+    NewSessionModal .section-label {
+        margin-top: 1;
+        text-style: bold;
+    }
+    
+    NewSessionModal .help-text {
+        color: $text-muted;
+        margin-bottom: 1;
+    }
+    
+    NewSessionModal .button-row {
+        margin-top: 1;
+        height: auto;
+        align: center middle;
+    }
+    
+    NewSessionModal .button-row Button {
+        margin: 0 1;
+    }
+    
+    NewSessionModal #session-name {
+        margin-bottom: 1;
+    }
+    
+    NewSessionModal TabbedContent {
+        height: auto;
+        max-height: 25;
+    }
+    
+    NewSessionModal TabPane {
+        height: auto;
+        padding: 1;
+    }
+    
+    NewSessionModal #system-instruction {
+        height: 5;
+        margin-top: 1;
+    }
+    
+    NewSessionModal #model-tab-scroll {
+        height: 100%;
+        max-height: 20;
+    }
+    """
+
+    def __init__(
+        self,
+        client: ApiClient,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the new session modal.
+
+        Args:
+            client: ApiClient instance for API calls
+        """
+        super().__init__(**kwargs)
+        self._client = client
+        self._active_tab: str = "agent"
+
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            yield Label("New Chat Session", classes="modal-title")
+
+            yield Static("Session Name (optional):", classes="section-label")
+            yield Input(
+                placeholder="Enter a name for this chat...",
+                id="session-name",
+            )
+
+            with TabbedContent(id="mode-tabs"):
+                with TabPane("Agent", id="agent-tab"):
+                    yield Static(
+                        "Choose an agent to chat with. The agent's system instruction "
+                        "and configured models will be used.",
+                        classes="help-text",
+                    )
+                    yield AgentPicker(
+                        client=self._client,
+                        placeholder="Search for an agent...",
+                        id="agent-picker",
+                    )
+
+                with TabPane("Model", id="model-tab"):
+                    with VerticalScroll(id="model-tab-scroll"):
+                        yield Static(
+                            "Chat directly with a model. Optionally provide a system instruction.",
+                            classes="help-text",
+                        )
+                        yield SingleModelPicker(
+                            client=self._client,
+                            placeholder="Search for a model...",
+                            id="model-picker",
+                        )
+                        yield Static(
+                            "System Instruction (optional):", classes="section-label"
+                        )
+                        yield TextArea(
+                            id="system-instruction",
+                        )
+
+            with Horizontal(classes="button-row"):
+                yield Button("Create", id="create-btn", variant="success")
+                yield Button("Cancel", id="cancel-btn", variant="default")
+
+    def on_mount(self) -> None:
+        """Focus the session name input on mount."""
+        self.query_one("#session-name", Input).focus()
+
+    @on(TabbedContent.TabActivated)
+    def on_tab_activated(self, event: TabbedContent.TabActivated) -> None:
+        """Track which tab is active."""
+        if event.pane.id == "agent-tab":
+            self._active_tab = "agent"
+        elif event.pane.id == "model-tab":
+            self._active_tab = "model"
+
+    @on(Button.Pressed, "#create-btn")
+    def on_create_pressed(self, event: Button.Pressed) -> None:
+        """Create session and dismiss with config."""
+        name_input = self.query_one("#session-name", Input)
+        name = name_input.value.strip() or None
+
+        if self._active_tab == "agent":
+            # Agent mode
+            agent_picker = self.query_one("#agent-picker", AgentPicker)
+            agent_id_str = agent_picker.selected_agent_id
+            agent_id = UUID(agent_id_str) if agent_id_str else None
+            agent_name = agent_picker.selected_agent_name
+
+            config = NewSessionConfig(
+                name=name,
+                agent_id=agent_id,
+                agent_name=agent_name,
+            )
+        else:
+            # Model mode
+            model_picker = self.query_one("#model-picker", SingleModelPicker)
+            system_input = self.query_one("#system-instruction", TextArea)
+
+            provider_key = model_picker.selected_provider_key
+            model_name = model_picker.selected_model_name
+            system_instruction = system_input.text.strip() or None
+
+            config = NewSessionConfig(
+                name=name,
+                provider_key=provider_key,
+                provider_model_name=model_name,
+                system_instruction=system_instruction,
+            )
+
+        self.dismiss(config)
+
+    @on(Button.Pressed, "#cancel-btn")
+    def on_cancel_pressed(self, event: Button.Pressed) -> None:
+        """Cancel and dismiss with None."""
+        self.dismiss(None)
+
+    def action_cancel(self) -> None:
+        """Cancel via escape key."""
+        self.dismiss(None)

cli/tui/widgets/schema_create_modal.py

@@ -0,0 +1,271 @@
+"""Schema creation modal for creating new validation schemas.
+
+Provides a comprehensive modal screen that allows users to create a new schema
+with support for JSON Schema or Regex formats, including JSON example generation.
+"""
+
+import json
+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, Vertical, 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.schemas import CreateSchemaRequest
+from alloy_runtime_types.enums.ownership_scope import OwnershipScope
+from alloy_runtime_types.enums.schema_enums import SchemaFormat
+
+from cli.infrastructure.forms.json_schema_builder import JsonSchemaBuilder
+
+if TYPE_CHECKING:
+    from cli.tui.app import AlloyRuntimeApp
+
+
+@dataclass
+class SchemaCreateResult:
+    """Result of successful schema creation."""
+
+    schema_id: str
+    schema_name: str
+    version: int
+
+
+class SchemaCreateModal(BaseFormModal[SchemaCreateResult]):
+    """Modal for creating a new schema.
+
+    Provides a comprehensive form with:
+    - Required fields: name, schema format, definition
+    - Schema definition via TextArea (paste JSON schema or regex)
+    - JSON Schema generation from JSON example
+    - Optional fields: description
+    - Scope selection (user/organization/global)
+
+    Usage:
+        def on_schema_created(result: SchemaCreateResult | None):
+            if result is not None:
+                # Schema was created successfully
+                self.notify(f"Created schema: {result.schema_name}")
+                self._do_search("")  # Refresh list
+
+        client = await self.app.store.get_client()
+        self.app.push_screen(
+            SchemaCreateModal(client=client),
+            on_schema_created
+        )
+    """
+
+    app: "AlloyRuntimeApp"
+
+    def __init__(
+        self,
+        client: ApiClient,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the schema creation modal.
+
+        Args:
+            client: ApiClient instance for API calls
+        """
+        super().__init__(**kwargs)
+        self._client = client
+
+    def compose(self) -> ComposeResult:
+        with VerticalScroll(id="schema-create-modal"):
+            yield Label("Create New Schema", classes="modal-title")
+
+            # ===== REQUIRED FIELDS =====
+            yield Static("[bold]Required[/]", classes="form-section")
+
+            yield Static(
+                "Name (lowercase, dots/dashes/underscores)", classes="field-label"
+            )
+            yield Input(
+                placeholder="e.g., user.profile, api.response-format",
+                id="name-input",
+            )
+
+            yield Static("Schema Format", classes="field-label")
+            with RadioSet(id="format-radios"):
+                yield RadioButton("JSON Schema", id="format-json-schema", value=True)
+                yield RadioButton("Regex", id="format-regex")
+
+            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")
+
+            # ===== SCHEMA DEFINITION =====
+            yield Static("[bold]Schema Definition[/]", classes="form-section")
+
+            yield Static(
+                "Definition (paste JSON Schema or Regex pattern)", classes="field-label"
+            )
+            yield TextArea(
+                id="definition-textarea",
+                classes="definition-input",
+            )
+
+            # JSON Schema builder section (only visible for JSON Schema format)
+            with Vertical(id="json-builder-section"):
+                yield Static(
+                    "Or: Generate from JSON example (JSON Schema only)",
+                    classes="field-label",
+                )
+                yield JsonSchemaBuilder(id="schema-builder")
+                yield Button(
+                    "Use Generated Schema",
+                    id="use-generated-btn",
+                    variant="primary",
+                    disabled=True,
+                )
+
+            # ===== OPTIONAL FIELDS =====
+            yield Static("[bold]Optional[/]", classes="form-section")
+
+            yield Static("Description", classes="field-label")
+            yield Input(
+                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("Create Schema", id="create-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(RadioSet.Changed, "#format-radios")
+    def on_format_changed(self, event: RadioSet.Changed) -> None:
+        """Handle schema format change - show/hide JSON builder."""
+        json_builder_section = self.query_one("#json-builder-section", Vertical)
+        if event.pressed.id == "format-json-schema":
+            json_builder_section.display = True
+        else:
+            json_builder_section.display = False
+            # Clear the builder when switching to regex
+            self.query_one("#schema-builder", JsonSchemaBuilder).clear()
+
+    @on(JsonSchemaBuilder.SchemaChanged)
+    def on_schema_builder_changed(self, event: JsonSchemaBuilder.SchemaChanged) -> None:
+        """Enable/disable the 'Use Generated Schema' button based on builder state."""
+        use_btn = self.query_one("#use-generated-btn", Button)
+        use_btn.disabled = event.schema is None
+
+    @on(Button.Pressed, "#use-generated-btn")
+    def on_use_generated_pressed(self, event: Button.Pressed) -> None:
+        """Copy the generated schema to the definition textarea."""
+        builder = self.query_one("#schema-builder", JsonSchemaBuilder)
+        if builder.generated_schema:
+            schema_str = json.dumps(builder.generated_schema, indent=2)
+            self.query_one("#definition-textarea", TextArea).text = schema_str
+            self.app.notify(
+                "Generated schema copied to definition", severity="information"
+            )
+
+    @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 not re.match(r"^[a-z0-9._-]+$", name):
+            raise ValueError(
+                "Name must be lowercase alphanumeric with dots, dashes, or underscores only"
+            )
+
+        definition = self.query_one("#definition-textarea", TextArea).text.strip()
+        if not definition:
+            raise ValueError(
+                "Schema definition is required. Paste a JSON Schema or regex pattern."
+            )
+
+        # Validate JSON schema format
+        schema_format = self._get_schema_format()
+        if schema_format == SchemaFormat.JSON_SCHEMA:
+            try:
+                json.loads(definition)
+            except json.JSONDecodeError as e:
+                raise ValueError(f"Invalid JSON in schema definition: {e.msg}")
+
+    def _get_schema_format(self) -> SchemaFormat:
+        """Get schema format from RadioSet."""
+        radios = self.query_one("#format-radios", RadioSet)
+        pressed = radios.pressed_button
+        if pressed is None or pressed.id == "format-json-schema":
+            return SchemaFormat.JSON_SCHEMA
+        return SchemaFormat.REGEX
+
+    def _get_scope(self) -> OwnershipScope:
+        """Get scope from RadioSet."""
+        return get_scope_from_radioset(self.query_one("#scope-radios", RadioSet))
+
+    def _build_request(self) -> CreateSchemaRequest:
+        """Build the API request."""
+        name = self.query_one("#name-input", Input).value.strip()
+        definition = self.query_one("#definition-textarea", TextArea).text.strip()
+        description = self.query_one("#description-input", Input).value.strip() or None
+
+        return CreateSchemaRequest(
+            name=name,
+            schema_format=self._get_schema_format(),
+            schema_definition=definition,
+            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_schema(request)
+
+            result = SchemaCreateResult(
+                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 create schema: {e}")