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

cli/commands/schemas/get/presenter.py

@@ -0,0 +1,129 @@
+"""Presenter for schema get command output."""
+
+import json
+import sys
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from cli.infrastructure.formatting.fields import (
+    format_datetime,
+    format_optional,
+    format_uuid,
+)
+from alloy_runtime_types.dtos.schemas import GetSchemaResponse
+
+
+def _derive_scope(response: GetSchemaResponse) -> str:
+    """Derive scope string from organization_id and user_id fields.
+
+    Args:
+        response: Schema response from server
+
+    Returns:
+        Scope string: user, organization, or global
+    """
+    if response.organization_id is not None and response.user_id is None:
+        return "organization"
+    elif response.user_id is not None:
+        return "user"
+    else:
+        return "global"
+
+
+def _format_definition_for_display(
+    schema_format_id: str, schema_definition: str
+) -> str:
+    """Format schema definition for display.
+
+    JSON schemas are pretty-printed, regex patterns shown as-is.
+
+    Args:
+        schema_format_id: Format type (json_schema, regex)
+        schema_definition: The schema definition string
+
+    Returns:
+        Formatted definition string
+    """
+    if schema_format_id == "json_schema":
+        try:
+            # Parse and pretty-print JSON
+            parsed = json.loads(schema_definition)
+            return json.dumps(parsed, indent=2, ensure_ascii=False)
+        except (json.JSONDecodeError, TypeError):
+            # If parsing fails, return as-is
+            return schema_definition
+    else:
+        # Regex or other formats - return as-is
+        return schema_definition
+
+
+def present_schema_details(response: GetSchemaResponse) -> None:
+    """Present schema details with Rich formatting.
+
+    Metadata goes to stderr (visible in terminal but not piped).
+    Schema definition goes to stdout (for piping to other commands).
+
+    Args:
+        response: GetSchemaResponse from server
+    """
+    # Create console for stderr output (metadata)
+    stderr_console = Console(file=sys.stderr, force_terminal=True)
+
+    # Print success message to stderr
+    stderr_console.print(
+        f"[green]✓[/green] Schema retrieved: {response.schema_name} (v{response.version})"
+    )
+
+    # Build metadata table
+    metadata_table = Table(show_header=False, box=None, padding=(0, 1))
+    metadata_table.add_column("Field", style="dim", width=20)
+    metadata_table.add_column("Value")
+
+    metadata_table.add_row("ID", format_uuid(response.id, short=False))
+    metadata_table.add_row("Name", response.schema_name)
+    metadata_table.add_row("Format", response.schema_format_id)
+    metadata_table.add_row("Version", str(response.version))
+    metadata_table.add_row("Description", format_optional(response.description))
+    metadata_table.add_row("Scope", _derive_scope(response))
+    metadata_table.add_row("Is Latest", "Yes" if response.is_latest else "No")
+    metadata_table.add_row(
+        "Organization ID",
+        format_optional(response.organization_id, lambda x: format_uuid(x, short=True)),
+    )
+    metadata_table.add_row(
+        "User ID",
+        format_optional(response.user_id, lambda x: format_uuid(x, short=True)),
+    )
+    metadata_table.add_row("Created At", format_datetime(response.created_at))
+
+    # Display metadata panel to stderr
+    metadata_panel = Panel(
+        metadata_table,
+        title=f"Schema: {response.schema_name}",
+        border_style="blue",
+    )
+    stderr_console.print(metadata_panel)
+
+    # Format and display definition to stdout for piping
+    formatted_definition = _format_definition_for_display(
+        response.schema_format_id, response.schema_definition
+    )
+
+    # Also show definition preview in a panel to stderr
+    preview_text = (
+        formatted_definition
+        if len(formatted_definition) <= 500
+        else formatted_definition[:500] + "\n... (truncated in preview)"
+    )
+    definition_panel = Panel(
+        Text(preview_text, style="dim"),
+        title=f"Schema Definition Preview ({response.schema_format_id})",
+        border_style="green",
+    )
+    stderr_console.print(definition_panel)
+
+    # Print full definition to stdout for piping
+    print(formatted_definition, file=sys.stdout)

cli/commands/schemas/list/command.py

@@ -0,0 +1,64 @@
+"""Schemas list command implementation."""
+
+from typing import Optional
+
+import typer
+
+from cli.commands.schemas.list.presenter import present_schemas_list
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def schemas_list_command(
+    search: Optional[str] = typer.Option(
+        None,
+        "-s",
+        "--search",
+        help="Fuzzy search terms",
+    ),
+    schema_format: Optional[str] = typer.Option(
+        None,
+        "--schema-format",
+        help="Filter: json_schema or regex",
+    ),
+    limit: int = typer.Option(
+        50,
+        "-l",
+        "--limit",
+        min=1,
+        max=100,
+        help="Max results",
+    ),
+    offset: int = typer.Option(
+        0,
+        "--offset",
+        min=0,
+        help="Skip N results",
+    ),
+) -> None:
+    """List schemas.
+
+    Examples:
+        ai schemas list
+        ai schemas list -s "user profile"
+        ai schemas list --schema-format json_schema
+        ai schemas list -l 20
+    """
+    _execute_list(
+        search=search, schema_format=schema_format, limit=limit, offset=offset
+    )
+
+
+@async_command
+async def _execute_list(
+    search: Optional[str], schema_format: Optional[str], limit: int, offset: int
+) -> None:
+    """Execute list schemas operation."""
+    async with authenticated_client() as (_config, client):
+        response = await client.list_schemas(
+            search=search,
+            schema_format=schema_format,
+            limit=limit,
+            offset=offset,
+        )
+
+    present_schemas_list(response)

cli/commands/schemas/list/presenter.py

@@ -0,0 +1,133 @@
+"""Presenter for schemas list command output."""
+
+from pydantic import BaseModel, Field
+from alloy_runtime_types.dtos.schemas import ListSchemasResponse, SchemaSummary
+
+from cli.infrastructure.scope_utils import format_scope_label
+from cli.infrastructure.output import OutputService
+from cli.infrastructure.renderers.list_renderer import ColumnConfig
+
+
+class SchemaDisplay(BaseModel):
+    """Schema with computed scope field for display."""
+
+    id: str = Field(..., description="Schema ID")
+    schema_name: str = Field(..., description="Schema name")
+    version: int = Field(..., description="Version number")
+    schema_format_id: str = Field(..., description="Format type")
+    description: str | None = Field(None, description="Description")
+    scope: str = Field(..., description="Ownership scope")
+    created_at: str = Field(..., description="Creation date")
+
+
+def _format_description(description: str | None) -> str:
+    """Format description for display, truncating if too long.
+
+    Args:
+        description: Optional description text
+
+    Returns:
+        Formatted description string
+    """
+    if not description:
+        return "-"
+    if len(description) > 120:
+        return description[:117] + "..."
+    return description
+
+
+def _transform_schema_for_display(schema: SchemaSummary) -> SchemaDisplay:
+    """Transform schema summary into display model with computed fields.
+
+    Args:
+        schema: Schema summary from API
+
+    Returns:
+        SchemaDisplay with computed scope field
+    """
+    return SchemaDisplay(
+        id=str(schema.id),
+        schema_name=schema.schema_name,
+        version=schema.version,
+        schema_format_id=schema.schema_format_id,
+        description=schema.description,
+        scope=format_scope_label(
+            str(schema.organization_id) if schema.organization_id else None,
+            str(schema.user_id) if schema.user_id else None,
+        ),
+        created_at=schema.created_at.strftime("%Y-%m-%d") if schema.created_at else "-",
+    )
+
+
+def present_schemas_list(response: ListSchemasResponse) -> None:
+    """Present list of schemas with Rich table formatting.
+
+    Args:
+        response: List schemas response from server
+    """
+    output = OutputService.get()
+
+    if not response.schemas:
+        output.info("No schemas found")
+        return
+
+    # Transform schemas for display
+    display_items = [_transform_schema_for_display(s) for s in response.schemas]
+
+    # Define table columns with compact layout configuration
+    # Line 1 (primary): ID, version, format, scope, created - machine-readable data
+    # Line 2 (detail): Name, description - human-readable content
+    columns = [
+        ColumnConfig(
+            source_field="id",
+            header_label="ID",
+            compact_line=1,
+            compact_style="cyan",
+        ),
+        ColumnConfig(
+            source_field="version",
+            header_label="Ver",
+            align="right",
+            formatter=lambda x: f"v{x}" if x else "-",
+            compact_line=1,
+            compact_style="yellow",
+        ),
+        ColumnConfig(
+            source_field="schema_format_id",
+            header_label="Format",
+            compact_line=1,
+            compact_style="magenta",
+        ),
+        ColumnConfig(
+            source_field="scope",
+            header_label="Scope",
+            compact_line=1,
+            compact_style="dim",
+        ),
+        ColumnConfig(
+            source_field="created_at",
+            header_label="Created",
+            compact_line=1,
+            compact_style="blue",
+        ),
+        ColumnConfig(
+            source_field="schema_name",
+            header_label="Name",
+            compact_line=2,
+            compact_style="white bold",
+        ),
+        ColumnConfig(
+            source_field="description",
+            header_label="Description",
+            formatter=_format_description,
+            compact_line=2,
+            compact_style="dim",
+        ),
+    ]
+
+    # Render table
+    output.table(
+        items=display_items,  # type: ignore[arg-type]
+        title=f"Schemas ({response.total})",
+        columns=columns,
+    )

cli/commands/schemas/update/command.py

@@ -0,0 +1,369 @@
+"""Schema update command implementation."""
+
+import json
+import os
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from cli.commands.shared_flags import CLEAR_DESCRIPTION, DESCRIPTION, FILE_INPUT
+from cli.commands.schemas.update.presenter import present_schema_update_success
+from cli.infrastructure.command import async_command, authenticated_client
+from cli.infrastructure.file_content import FileContentError, resolve_content
+from alloy_runtime_types.dtos.schemas import UpdateSchemaRequest
+from alloy_runtime_sdk.exceptions.errors import NotFoundError
+
+
+class EditorError(Exception):
+    """Raised when editor operations fail."""
+
+
+def _get_editor() -> str:
+    """Get the user's preferred editor.
+
+    Checks in order:
+    1. $EDITOR environment variable
+    2. $VISUAL environment variable
+    3. Common editors on PATH (nano, vim, vi)
+
+    Returns:
+        Path/name of editor to use
+
+    Raises:
+        EditorError: If no suitable editor is found
+    """
+    # Check environment variables first
+    editor = os.environ.get("EDITOR") or os.environ.get("VISUAL")
+    if editor:
+        return editor
+
+    # Fall back to common editors
+    for fallback in ("nano", "vim", "vi"):
+        if shutil.which(fallback):
+            return fallback
+
+    raise EditorError(
+        "No editor found. Set $EDITOR environment variable or install nano/vim."
+    )
+
+
+def _open_editor_for_schema(initial_content: str, schema_format: str) -> str | None:
+    """Open editor with schema-specific file extension for syntax highlighting.
+
+    Args:
+        initial_content: Initial schema definition content
+        schema_format: Schema format ID (json_schema or regex)
+
+    Returns:
+        Edited content or None if editor failed
+
+    Raises:
+        EditorError: If no editor is available
+    """
+    editor = _get_editor()
+
+    # Choose file extension based on schema format
+    if schema_format == "json_schema":
+        suffix = ".json"
+        # Pretty-print JSON for better editing experience
+        try:
+            parsed = json.loads(initial_content)
+            initial_content = json.dumps(parsed, indent=2, ensure_ascii=False)
+        except (json.JSONDecodeError, TypeError):
+            # If parsing fails, use as-is
+            pass
+    else:
+        # Regex pattern
+        suffix = ".txt"
+
+    # Create temp file
+    with tempfile.NamedTemporaryFile(
+        mode="w",
+        suffix=suffix,
+        delete=False,
+    ) as f:
+        f.write(initial_content)
+        temp_path = Path(f.name)
+
+    try:
+        # Get file modification time before editing
+        mtime_before = temp_path.stat().st_mtime
+
+        # Open editor and wait for it to close
+        editor_parts = editor.split()
+        cmd = editor_parts + [str(temp_path)]
+
+        result = subprocess.call(cmd)
+
+        if result != 0:
+            return None
+
+        # Check if file was modified
+        mtime_after = temp_path.stat().st_mtime
+        if mtime_after == mtime_before:
+            # File wasn't modified - still return content in case no changes needed
+            pass
+
+        # Read the edited content
+        content = temp_path.read_text()
+        return content
+
+    finally:
+        # Clean up temp file
+        try:
+            temp_path.unlink()
+        except OSError:
+            pass  # Best effort cleanup
+
+
+def schemas_update_command(
+    schema: str = typer.Argument(..., help="Schema name or UUID"),
+    # Metadata fields
+    description: Optional[str] = DESCRIPTION,
+    # Definition fields
+    definition: Optional[str] = typer.Option(
+        None,
+        "-D",
+        "--definition",
+        help="Schema definition (or @file)",
+    ),
+    definition_file: Optional[Path] = FILE_INPUT,
+    # Clear flags
+    clear_description: bool = CLEAR_DESCRIPTION,
+) -> None:
+    """Update an existing schema.
+
+    By default, opens interactive editor. Use flags for non-interactive mode.
+    Name and format cannot be changed.
+
+    Examples:
+
+        # Interactive (default)
+        ai schemas update my-schema
+
+        # Update description
+        ai schemas update my-schema -d "New description"
+
+        # Update definition from file
+        ai schemas update my-schema -f schema.json
+
+        # Update definition inline
+        ai schemas update my-schema -D '{"type": "object", ...}'
+    """
+    # Validate definition source - can't have both file and inline
+    if definition_file is not None and definition is not None:
+        raise typer.BadParameter("Cannot specify both --file and --definition")
+
+    # Validate clear flags
+    if clear_description and description is not None:
+        raise typer.BadParameter(
+            "Cannot specify both --description and --clear-description"
+        )
+
+    # Check if any flags were provided (non-interactive mode)
+    has_flags = any(
+        [
+            description is not None,
+            definition is not None,
+            definition_file is not None,
+            clear_description,
+        ]
+    )
+
+    if has_flags:
+        # Non-interactive mode - execute with provided flags
+        _execute_update_non_interactive(
+            schema_identifier=schema,
+            description=description,
+            definition=definition,
+            definition_file=definition_file,
+            clear_description=clear_description,
+        )
+    else:
+        # Interactive mode - fetch current data and launch editor
+        _execute_update_interactive(schema_identifier=schema)
+
+
+def _execute_update_interactive(schema_identifier: str) -> None:
+    """Launch interactive editor for updating schema.
+
+    This function is synchronous because editor operations are blocking.
+    We use asyncio.run() just for the initial schema fetch, then
+    run the editor synchronously.
+
+    Args:
+        schema_identifier: Schema name or UUID
+
+    Raises:
+        ConfigurationError: If environment variables are missing
+        AuthenticationError: If API key is invalid
+        NotFoundError: If schema doesn't exist
+        ServerError: If server returns 5xx error
+    """
+    import asyncio
+
+    from cli.infrastructure.error_display import display_error
+    from cli.infrastructure.output import OutputService
+
+    try:
+        # Fetch current schema data (async operation, run in its own event loop)
+        async def fetch_schema():
+            async with authenticated_client() as (_, client):
+                return await client.get_schema(schema_identifier)
+
+        try:
+            current_data = asyncio.run(fetch_schema())
+        except NotFoundError:
+            raise typer.BadParameter(
+                f"Schema '{schema_identifier}' not found. "
+                "Use 'ai schemas list' to see available schemas."
+            )
+
+        output = OutputService.get()
+
+        # Show current schema info
+        output.info(
+            f"Schema: {current_data.schema_name} (v{current_data.version})\n"
+            f"Format: {current_data.schema_format_id}\n"
+            f"Description: {current_data.description or '(none)'}"
+        )
+
+        # Open editor with current definition
+        with output.console.status(
+            f"Opening editor for {current_data.schema_name}...", spinner="dots"
+        ):
+            pass  # Just show briefly before opening editor
+
+        try:
+            edited_content = _open_editor_for_schema(
+                initial_content=current_data.schema_definition,
+                schema_format=current_data.schema_format_id,
+            )
+        except EditorError as e:
+            raise typer.BadParameter(str(e))
+
+        if edited_content is None:
+            output.warning("Editor exited with error. Update cancelled.")
+            raise typer.Exit(code=0)
+
+        # Check if definition was modified
+        definition_changed = (
+            edited_content.strip() != current_data.schema_definition.strip()
+        )
+
+        if not definition_changed:
+            output.info("No changes to schema definition. Update cancelled.")
+            raise typer.Exit(code=0)
+
+        # Prompt for description update
+        output.info("\nSchema definition has been modified.")
+        update_description = typer.confirm(
+            "Do you want to update the description as well?",
+            default=False,
+        )
+
+        new_description: Optional[str] = None
+        if update_description:
+            new_description = typer.prompt(
+                "Enter new description (leave empty to clear)",
+                default=current_data.description or "",
+            )
+            # Empty string means clear (strip to handle whitespace-only input)
+            if new_description and not new_description.strip():
+                new_description = ""
+
+        # Build request
+        request = UpdateSchemaRequest(
+            schema_definition=edited_content.strip(),
+            description=new_description,
+        )
+
+        # Execute update via API
+        async def update_schema():
+            async with authenticated_client() as (_, client):
+                # Resolve to UUID (server only accepts UUID for update)
+                return await client.update_schema(current_data.id, request)
+
+        response = asyncio.run(update_schema())
+
+        # Present success output
+        present_schema_update_success(response)
+
+    except typer.Exit:
+        # Re-raise Exit exceptions (don't treat as errors)
+        raise
+    except Exception as e:
+        display_error(e)
+        raise typer.Exit(code=1)
+
+
+@async_command
+async def _execute_update_non_interactive(
+    schema_identifier: str,
+    description: Optional[str],
+    definition: Optional[str],
+    definition_file: Optional[Path],
+    clear_description: bool,
+) -> None:
+    """Execute the schema update operation in non-interactive mode.
+
+    Args:
+        schema_identifier: Schema name or UUID
+        description: Optional new description
+        definition: Optional new definition (inline or @file)
+        definition_file: Optional definition file path
+        clear_description: If True, clear the description
+
+    Raises:
+        ConfigurationError: If environment variables are missing
+        AuthenticationError: If API key is invalid
+        NotFoundError: If schema doesn't exist
+        ValidationError: If update data is invalid
+        ServerError: If server returns 5xx error
+    """
+    # Resolve content from @file references
+    try:
+        definition = resolve_content(definition)
+    except FileContentError as e:
+        raise typer.BadParameter(str(e))
+
+    # Get definition from file if specified
+    schema_definition: Optional[str] = None
+    if definition_file is not None:
+        schema_definition = definition_file.read_text()
+    elif definition is not None:
+        schema_definition = definition
+
+    # Handle description
+    final_description: Optional[str] = description
+    if clear_description:
+        final_description = ""
+
+    # Build update request - only include fields that were explicitly provided
+    request = UpdateSchemaRequest(
+        description=final_description
+        if (description is not None or clear_description)
+        else None,
+        schema_definition=schema_definition,
+    )
+
+    # Execute API call with authenticated client
+    async with authenticated_client() as (_config, client):
+        # First resolve schema identifier to get UUID and current data
+        try:
+            schema_data = await client.get_schema(schema_identifier)
+        except NotFoundError:
+            raise typer.BadParameter(
+                f"Schema '{schema_identifier}' not found. "
+                "Use 'ai schemas list' to see available schemas."
+            )
+
+        # Execute update (server requires UUID)
+        response = await client.update_schema(schema_data.id, request)
+
+    # Present success output
+    present_schema_update_success(response)