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

cli/infrastructure/output.py

@@ -0,0 +1,192 @@
+"""Unified output service for CLI presentation.
+
+This module provides format-aware output that can switch between
+Rich terminal output and JSON for scripting/piping.
+"""
+
+from enum import Enum
+
+from pydantic import BaseModel
+
+from cli.infrastructure.console import get_console
+from cli.infrastructure.formatters.base import Formatter
+from cli.infrastructure.formatters.compact_formatter import CompactFormatter
+from cli.infrastructure.formatters.json_formatter import JsonFormatter
+from cli.infrastructure.formatters.lines_formatter import LinesFormatter
+from cli.infrastructure.renderers.entity_renderer import FieldConfig
+from cli.infrastructure.renderers.list_renderer import ColumnConfig
+
+
+class OutputFormat(Enum):
+    """Supported output formats."""
+
+    COMPACT = "compact"  # Default: 2-line blocks, copy-friendly, no borders
+    JSON = "json"  # Machine-readable JSON
+    LINES = "lines"  # Key-value lines format
+
+
+class OutputService:
+    """Format-aware output service.
+
+    Usage:
+        output = OutputService.get()  # Uses global format setting
+        output.success("Operation completed")
+        output.entity(response, "User Details", USER_FIELDS)
+        output.table(items, "Users", USER_COLUMNS)
+    """
+
+    _instance: "OutputService | None" = None
+    _format: OutputFormat = OutputFormat.COMPACT
+
+    def __init__(self, format: OutputFormat = OutputFormat.COMPACT):
+        """Initialize output service with specified format.
+
+        Args:
+            format: Output format (compact, json, or lines)
+        """
+        self.format = format
+        self._console = get_console()
+        self._formatter = self._create_formatter(format)
+
+    @classmethod
+    def configure(cls, format: OutputFormat) -> None:
+        """Configure global output format. Call once at app startup.
+
+        Args:
+            format: Output format to use globally
+        """
+        cls._format = format
+        cls._instance = None  # Reset singleton
+
+    @classmethod
+    def get(cls) -> "OutputService":
+        """Get the configured output service instance.
+
+        Returns:
+            Singleton OutputService instance
+        """
+        if cls._instance is None:
+            cls._instance = cls(cls._format)
+        return cls._instance
+
+    def _create_formatter(self, format: OutputFormat) -> Formatter:
+        """Create formatter instance for the specified format.
+
+        Args:
+            format: Output format
+
+        Returns:
+            Formatter instance
+        """
+        if format == OutputFormat.JSON:
+            return JsonFormatter()
+        if format == OutputFormat.LINES:
+            return LinesFormatter()
+        # Default: COMPACT
+        return CompactFormatter(self._console)
+
+    # Message methods
+    def success(self, message: str) -> None:
+        """Print a success message.
+
+        Args:
+            message: Success message to display
+        """
+        output = self._formatter.format_success(message)
+        self._console.print(output)
+
+    def info(self, message: str) -> None:
+        """Print an informational message.
+
+        Args:
+            message: Info message to display
+        """
+        output = self._formatter.format_info(message)
+        self._console.print(output)
+
+    def warning(self, message: str) -> None:
+        """Print a warning message.
+
+        Args:
+            message: Warning message to display
+        """
+        output = self._formatter.format_warning(message)
+        self._console.print(output)
+
+    def status(self, message: str) -> None:
+        """Print a status message (dim, no icon).
+
+        Args:
+            message: Status message to display
+        """
+        self._console.print(f"[dim]{message}[/dim]")
+
+    # Entity rendering
+    def entity(
+        self, entity: BaseModel, title: str | None, fields: list[FieldConfig]
+    ) -> None:
+        """Render a single entity (Pydantic model).
+
+        Args:
+            entity: Pydantic model instance to render
+            title: Display title for the entity
+            fields: Field configurations defining what to show
+        """
+        from cli.infrastructure.renderers.entity_renderer import EntityRenderer
+
+        renderer = EntityRenderer(self._formatter)
+        renderer.render(entity, title, fields)
+
+    # List rendering
+    def table(
+        self, items: list[BaseModel], title: str | None, columns: list[ColumnConfig]
+    ) -> None:
+        """Render a list of entities as a table.
+
+        Args:
+            items: List of Pydantic model instances
+            title: Optional table title
+            columns: Column configurations
+        """
+        from cli.infrastructure.renderers.list_renderer import ListRenderer
+
+        renderer = ListRenderer(self._formatter)
+        renderer.render(items, columns, title)
+
+    # Raw console access for complex cases
+    @property
+    def console(self):
+        """Get the underlying console for complex rendering needs.
+
+        Returns:
+            Rich Console instance
+        """
+        return self._console
+
+
+# Convenience functions for direct usage (uses global singleton)
+def print_success(message: str) -> None:
+    """Print a success message with checkmark.
+
+    Args:
+        message: Success message to display
+    """
+    OutputService.get().success(message)
+
+
+def print_info(message: str) -> None:
+    """Print an informational message.
+
+    Args:
+        message: Info message to display
+    """
+    OutputService.get().info(message)
+
+
+def print_warning(message: str) -> None:
+    """Print a warning message.
+
+    Args:
+        message: Warning message to display
+    """
+    OutputService.get().warning(message)

cli/infrastructure/provider_setup.py

@@ -0,0 +1,81 @@
+"""Provider credentials setup service.
+
+Shared logic for prompting users to configure AI provider API keys.
+Used by both login and signup flows.
+"""
+
+from cli.infrastructure.console import Confirm, Prompt, get_console
+from alloy_runtime_sdk.api_client.client import ApiClient
+from alloy_runtime_types.dtos.organization_credentials import (
+    CreateOrganizationCredentialRequest,
+)
+from alloy_runtime_types.enums.provider import Provider
+
+# Provider definitions: (display_name, Provider enum, env_hint, example_prefix)
+PROVIDERS = [
+    ("X.Ai", Provider.XAI, "XAI_API_KEY", "..."),
+    ("Google", Provider.GOOGLE, "GOOGLE_API_KEY", "..."),
+    ("Anthropic", Provider.ANTHROPIC, "ANTHROPIC_API_KEY", "sk-ant-..."),
+    ("OpenAI", Provider.OPENAI, "OPENAI_API_KEY", "sk-..."),
+    ("OpenRouter", Provider.OPENROUTER, "OPENROUTER_API_KEY", "sk-or-..."),
+]
+
+
+async def prompt_provider_credentials(api_url: str, api_key: str) -> int:
+    """Prompt user to configure provider API keys.
+
+    Args:
+        api_url: API server base URL
+        api_key: User's API key for authenticated requests
+
+    Returns:
+        Number of providers successfully configured
+    """
+    console = get_console()
+
+    console.print("\n[bold cyan]AI Provider Credentials Setup[/bold cyan]")
+    console.print(
+        "[dim]Configure API keys for AI providers to start using the platform.[/dim]\n"
+    )
+
+    configured_count = 0
+
+    async with ApiClient(base_url=api_url, api_key=api_key) as client:
+        for display_name, provider_enum, _env_hint, example_prefix in PROVIDERS:
+            if Confirm.ask(
+                f"Configure [cyan]{display_name}[/cyan] API key?", default=False
+            ):
+                api_key_value = Prompt.ask(
+                    f"[cyan]{display_name} API Key[/cyan] (e.g., {example_prefix})",
+                    password=True,
+                )
+
+                if api_key_value and api_key_value.strip():
+                    try:
+                        request = CreateOrganizationCredentialRequest(
+                            credential_type_id="org_provider",
+                            name=f"{display_name} API Key",
+                            plaintext_value=api_key_value.strip(),
+                            provider_key=provider_enum,
+                            description=f"{display_name} API key configured during signup",
+                        )
+                        await client.create_organization_credential(request)
+                        console.print(
+                            f"[green]✓[/green] {display_name} credential saved!"
+                        )
+                        configured_count += 1
+                    except Exception as e:
+                        console.print(
+                            f"[red]✗[/red] Failed to save {display_name} credential: {e}"
+                        )
+
+    if configured_count > 0:
+        console.print(f"\n[green]Configured {configured_count} provider(s)![/green]")
+        console.print("[green]You're ready to use Alloy Runtime![/green]")
+    else:
+        console.print("\n[yellow]No providers configured.[/yellow]")
+        console.print(
+            "[dim]You can add them later with the credentials commands.[/dim]"
+        )
+
+    return configured_count

cli/infrastructure/renderers/entity_renderer.py

@@ -0,0 +1,77 @@
+"""Entity renderer for displaying single entity details.
+
+Renders single Pydantic model instances using configured field formatters.
+"""
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+from pydantic import BaseModel
+
+from cli.infrastructure.console import get_console
+from cli.infrastructure.formatters.base import Formatter
+
+
+@dataclass
+class FieldConfig:
+    """Configuration for a single field to render.
+
+    Attributes:
+        source_field: Attribute name on the Pydantic model
+        display_label: Human-readable label for display
+        formatter: Optional function to format the field value
+    """
+
+    source_field: str
+    display_label: str
+    formatter: Callable[[Any], str] | None = None
+
+
+class EntityRenderer:
+    """Renders single entity details using a formatter.
+
+    Extracts data from Pydantic models according to field configurations
+    and renders using the provided formatter.
+    """
+
+    def __init__(self, formatter: Formatter):
+        """Initialize renderer with a formatter.
+
+        Args:
+            formatter: Formatter instance (CompactFormatter, JsonFormatter, etc.)
+        """
+        self.formatter = formatter
+
+    def render(
+        self, entity: BaseModel, title: str | None, fields: list[FieldConfig]
+    ) -> None:
+        """Render entity details to console.
+
+        Args:
+            entity: Pydantic model instance to render
+            title: Display title for the entity (optional)
+            fields: List of field configurations defining what to show
+        """
+        # Extract data from entity using field configs
+        data: dict[str, Any] = {}
+        for field_config in fields:
+            # Safely extract field value using getattr
+            value = getattr(entity, field_config.source_field, None)
+
+            # Apply formatter if provided
+            if field_config.formatter:
+                value = field_config.formatter(value)
+            elif value is not None:
+                value = str(value)
+            # If value is None and no formatter, leave as None
+            # (formatter will handle it with "(not set)" placeholder)
+
+            data[field_config.display_label] = value
+
+        # Format using the configured formatter
+        output = self.formatter.format_entity(data, title)
+
+        # Print using shared console
+        # Output can be a Rich renderable (Table, Panel, etc.) or a string
+        console = get_console()
+        console.print(output)

cli/infrastructure/renderers/list_renderer.py

@@ -0,0 +1,114 @@
+"""List renderer for displaying collections with pagination.
+
+Renders lists of Pydantic model instances using configured column formatters.
+"""
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import Any, Callable
+
+from pydantic import BaseModel
+
+from cli.infrastructure.console import get_console
+from cli.infrastructure.formatters.base import ColumnMeta, Formatter
+
+
+@dataclass
+class ColumnConfig:
+    """Configuration for a table column.
+
+    Attributes:
+        source_field: Attribute name on the Pydantic model
+        header_label: Column header text
+        formatter: Optional function to format the column value
+        width: Optional fixed column width
+        align: Text alignment - "left", "center", or "right"
+        compact_line: For compact format - 1 = primary line (metadata),
+                      2 = detail line (content/description). Default is 1.
+        compact_style: Rich style for compact format (e.g., "cyan bold", "dim")
+    """
+
+    source_field: str
+    header_label: str
+    formatter: Callable[[Any], str] | None = None
+    width: int | None = None
+    align: str = "left"
+    compact_line: int = 1
+    compact_style: str | None = None
+
+
+class ListRenderer:
+    """Renders lists/collections with pagination support.
+
+    Extracts data from lists of Pydantic models according to column configurations
+    and renders using the provided formatter.
+    """
+
+    def __init__(self, formatter: Formatter):
+        """Initialize renderer with a formatter.
+
+        Args:
+            formatter: Formatter instance (CompactFormatter, JsonFormatter, etc.)
+        """
+        self.formatter = formatter
+
+    def render(
+        self,
+        items: Sequence[BaseModel],
+        columns: list[ColumnConfig],
+        title: str | None = None,
+        cursor: str | None = None,
+        total_count: int | None = None,
+    ) -> None:
+        """Render paginated list to console.
+
+        Args:
+            items: Sequence of Pydantic model instances to render
+            columns: Column configurations defining what to show
+            title: Optional table title
+            cursor: Pagination cursor for next page
+            total_count: Total items across all pages
+        """
+        # Extract data from items using column configs
+        rows: list[dict[str, Any]] = []
+        for item in items:
+            row: dict[str, Any] = {}
+            for col in columns:
+                # Safely extract column value using getattr
+                value = getattr(item, col.source_field, None)
+
+                # Apply formatter if provided
+                if col.formatter:
+                    value = col.formatter(value)
+                elif value is not None:
+                    value = str(value)
+                # If value is None and no formatter, leave as None
+                # (formatter will handle it with "(not set)" placeholder)
+
+                row[col.header_label] = value
+            rows.append(row)
+
+        # Build column metadata for formatters that need layout info
+        column_meta = [
+            ColumnMeta(
+                label=col.header_label,
+                compact_line=col.compact_line,
+                compact_style=col.compact_style,
+                width=col.width,
+            )
+            for col in columns
+        ]
+
+        # Format the list using the configured formatter
+        output = self.formatter.format_list(rows, title, column_meta)
+
+        # Print using shared console
+        # Output can be a Rich renderable (Table) or a string
+        console = get_console()
+        console.print(output)
+
+        # Show pagination info if available
+        if cursor:
+            console.print(f"[dim]Next page cursor: {cursor}[/dim]")
+        if total_count:
+            console.print(f"[dim]Showing {len(items)} of {total_count} total[/dim]")

cli/infrastructure/scope_utils.py

@@ -0,0 +1,47 @@
+"""Common formatting utilities for CLI display."""
+
+from alloy_runtime_types.enums.ownership_scope import OwnershipScope
+from textual.widgets import RadioSet
+
+
+def format_scope_label(
+    organization_id: str | None,
+    user_id: str | None,
+) -> str:
+    """Format ownership scope as human-readable label.
+
+    Args:
+        organization_id: Organization UUID if org-owned
+        user_id: User UUID if user-owned
+
+    Returns:
+        Scope string: "User", "Org", or "Global"
+    """
+    if user_id:
+        return "User"
+    elif organization_id:
+        return "Org"
+    return "Global"
+
+
+def get_scope_from_radioset(
+    radioset: RadioSet,
+    user_id: str = "scope-user",
+    org_id: str = "scope-org",
+) -> OwnershipScope:
+    """Extract OwnershipScope from a RadioSet widget.
+
+    Args:
+        radioset: The RadioSet containing scope radio buttons
+        user_id: ID of the user scope radio button
+        org_id: ID of the org scope radio button
+
+    Returns:
+        OwnershipScope enum value
+    """
+    pressed = radioset.pressed_button
+    if pressed is None or pressed.id == user_id:
+        return OwnershipScope.USER
+    elif pressed.id == org_id:
+        return OwnershipScope.ORGANIZATION
+    return OwnershipScope.GLOBAL

cli/infrastructure/spinner.py

@@ -0,0 +1,101 @@
+"""Reusable loading spinner component for async operations.
+
+Provides a context manager for displaying a spinner while waiting for
+server responses or other async operations.
+"""
+
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from types import TracebackType
+
+from rich.console import Console
+from rich.status import Status
+
+from cli.infrastructure.console import get_console
+
+
+class Spinner:
+    """A loading spinner for async operations.
+
+    Usage:
+        async with Spinner("Processing...") as spinner:
+            result = await some_async_operation()
+            spinner.update("Almost done...")
+
+        # Or with the module-level context manager:
+        async with spinner("Loading data..."):
+            data = await fetch_data()
+    """
+
+    def __init__(
+        self,
+        message: str = "Processing...",
+        spinner_style: str = "dots",
+        console: Console | None = None,
+    ):
+        """Initialize the spinner.
+
+        Args:
+            message: Initial status message to display
+            spinner_style: Rich spinner style (dots, line, dots2, etc.)
+            console: Optional console instance (uses global if not provided)
+        """
+        self.message = message
+        self.spinner_style = spinner_style
+        self._console = console or get_console()
+        self._status: Status | None = None
+
+    async def __aenter__(self) -> "Spinner":
+        """Start the spinner."""
+        self._status = self._console.status(
+            f"[dim]{self.message}[/]",
+            spinner=self.spinner_style,
+            spinner_style="cyan",
+        )
+        self._status.start()
+        return self
+
+    async def __aexit__(
+        self,
+        _exc_type: type[BaseException] | None,
+        _exc_val: BaseException | None,
+        _exc_tb: TracebackType | None,
+    ) -> None:
+        """Stop the spinner."""
+        if self._status:
+            self._status.stop()
+            self._status = None
+
+    def update(self, message: str) -> None:
+        """Update the spinner message.
+
+        Args:
+            message: New status message to display
+        """
+        if self._status:
+            self._status.update(f"[dim]{message}[/]")
+
+
+@asynccontextmanager
+async def spinner(
+    message: str = "Processing...",
+    spinner_style: str = "dots",
+) -> AsyncIterator[Spinner]:
+    """Context manager for displaying a loading spinner.
+
+    Usage:
+        async with spinner("Fetching data...") as s:
+            data = await fetch_data()
+            s.update("Processing response...")
+            result = process(data)
+
+    Args:
+        message: Initial status message to display
+        spinner_style: Rich spinner style
+
+    Yields:
+        Spinner instance for updating the message
+    """
+    s = Spinner(message=message, spinner_style=spinner_style)
+    async with s:
+        yield s

cli/infrastructure/tui/clipboard.py

@@ -0,0 +1,41 @@
+"""Clipboard utilities for TUI applications."""
+
+import pyperclip
+from typing import Literal, Protocol
+
+
+SeverityLevel = Literal["information", "warning", "error"]
+
+
+class SupportsNotify(Protocol):
+    """Minimal app protocol for clipboard notifications."""
+
+    def notify(
+        self,
+        message: str,
+        *,
+        title: str = "",
+        severity: SeverityLevel = "information",
+        timeout: float | None = None,
+        markup: bool = True,
+    ) -> None: ...
+
+
+def copy_to_clipboard(app: SupportsNotify, text: str, label: str = "ID") -> bool:
+    """Copy text to clipboard with user notification.
+
+    Args:
+        app: The Textual app instance (for notifications)
+        text: The text to copy
+        label: Label for the notification message (e.g., "ID", "Version ID")
+
+    Returns:
+        True if copy succeeded, False otherwise
+    """
+    try:
+        pyperclip.copy(text)
+        app.notify(f"Copied {label}: {text}", severity="information")
+        return True
+    except Exception as e:
+        app.notify(f"Copy failed: {e}", severity="error")
+        return False