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

cli/infrastructure/formatters/lines_formatter.py

@@ -0,0 +1,102 @@
+"""Lines formatter for easy-to-copy terminal output.
+
+Outputs each field on its own line, making individual values easy to copy
+without table formatting artifacts.
+"""
+
+from typing import Any
+
+from cli.infrastructure.formatters.base import ColumnMeta, Formatter
+
+
+class LinesFormatter(Formatter):
+    """Formatter that outputs each field on its own line for easy copying."""
+
+    def format_entity(self, data: dict[str, Any], title: str | None = None) -> str:
+        """Format entity as key-value lines.
+
+        Args:
+            data: Dictionary mapping field labels to values
+            title: Optional title displayed above the data
+
+        Returns:
+            String with each field on its own line
+        """
+        lines: list[str] = []
+
+        if title:
+            lines.append(title)
+            lines.append("-" * len(title))
+
+        for field, value in data.items():
+            display_value = "(not set)" if value is None else str(value)
+            lines.append(f"{field}: {display_value}")
+
+        return "\n".join(lines)
+
+    def format_list(
+        self,
+        items: list[dict[str, Any]],
+        title: str | None = None,
+        columns: list[ColumnMeta] | None = None,
+    ) -> str:
+        """Format list as blocks of key-value lines.
+
+        Args:
+            items: List of dictionaries, each representing one item
+            title: Optional title displayed above the list
+
+        Returns:
+            String with each item as a block separated by blank lines
+        """
+        if not items:
+            return self.format_info("No items to display")
+
+        lines: list[str] = []
+
+        if title:
+            lines.append(title)
+            lines.append("=" * len(title))
+            lines.append("")
+
+        for i, item in enumerate(items, start=1):
+            lines.append(f"--- Item {i} ---")
+            for field, value in item.items():
+                display_value = "(not set)" if value is None else str(value)
+                lines.append(f"{field}: {display_value}")
+            lines.append("")  # Blank line between items
+
+        return "\n".join(lines).rstrip()
+
+    def format_success(self, message: str) -> str:
+        """Format success message with prefix.
+
+        Args:
+            message: Success message text
+
+        Returns:
+            Prefixed success message
+        """
+        return f"[OK] {message}"
+
+    def format_info(self, message: str) -> str:
+        """Format info message with prefix.
+
+        Args:
+            message: Info message text
+
+        Returns:
+            Prefixed info message
+        """
+        return f"[INFO] {message}"
+
+    def format_warning(self, message: str) -> str:
+        """Format warning message with prefix.
+
+        Args:
+            message: Warning message text
+
+        Returns:
+            Prefixed warning message
+        """
+        return f"[WARN] {message}"

cli/infrastructure/formatting/fields.py

@@ -0,0 +1,193 @@
+"""Field formatting utilities for common data types.
+
+Provides reusable formatters for UUIDs, dates, currency, tokens, etc.
+"""
+
+from datetime import datetime
+from decimal import Decimal
+from typing import Any, Callable
+from uuid import UUID
+
+
+def format_uuid(value: UUID | None, short: bool = True) -> str:
+    """Format UUID for display.
+
+    Args:
+        value: UUID to format (None returns placeholder)
+        short: If True, show first 8 characters with "...". If False, show full UUID.
+
+    Returns:
+        Formatted UUID string or "(not set)" for None
+    """
+    if value is None:
+        return "(not set)"
+
+    if short:
+        return str(value)[:8] + "..."
+    return str(value)
+
+
+def format_datetime(
+    value: datetime | None, mode: str = "absolute", include_time: bool = True
+) -> str:
+    """Format datetime for display.
+
+    Args:
+        value: Datetime to format (None returns placeholder)
+        mode: Format mode - "absolute", "iso", or "date_only"
+        include_time: Whether to include time component
+
+    Returns:
+        Formatted datetime string or "(not set)" for None
+    """
+    if value is None:
+        return "(not set)"
+
+    if mode == "iso":
+        return value.isoformat()
+    elif mode == "date_only":
+        return value.strftime("%Y-%m-%d")
+    else:  # absolute
+        if include_time:
+            return value.strftime("%Y-%m-%d %H:%M:%S UTC")
+        return value.strftime("%Y-%m-%d")
+
+
+def format_cost(amount: Decimal | float, currency: str = "USD") -> str:
+    """Format monetary amount.
+
+    Args:
+        amount: Decimal or float amount
+        currency: Currency code (default USD, reserved for future use)
+
+    Returns:
+        Formatted currency string
+    """
+    _ = currency  # Reserved for future multi-currency support
+    # Convert float to Decimal for precision
+    if isinstance(amount, float):
+        amount = Decimal(str(amount))
+
+    # Format with full precision (no rounding for small amounts)
+    return f"${amount}"
+
+
+def format_tokens(count: int) -> str:
+    """Format token count with thousands separator.
+
+    Args:
+        count: Number of tokens
+
+    Returns:
+        Formatted token count string
+    """
+    return f"{count:,}"
+
+
+def format_boolean(value: bool, mode: str = "text") -> str:
+    """Format boolean value for display.
+
+    Args:
+        value: Boolean value to format
+        mode: Format mode - "text", "emoji", or "raw"
+
+    Returns:
+        Formatted boolean string
+    """
+    if mode == "emoji":
+        return "✓" if value else "✗"
+    elif mode == "raw":
+        return str(value)
+    else:  # text
+        return "Yes" if value else "No"
+
+
+def format_optional(
+    value: Any | None,
+    formatter: Callable[[Any], str] | None = None,
+    placeholder: str = "(not set)",
+) -> str:
+    """Format optional value with placeholder for None.
+
+    Args:
+        value: Value to format (may be None)
+        formatter: Optional formatter function to apply if value is not None
+        placeholder: Text to display when value is None
+
+    Returns:
+        Formatted value or placeholder
+    """
+    if value is None:
+        return placeholder
+    if formatter:
+        return formatter(value)
+    return str(value)
+
+
+def format_enum(value: Any, capitalize: bool = True) -> str:
+    """Format enum value for display.
+
+    Args:
+        value: Enum value (expected to have .value attribute)
+        capitalize: Whether to capitalize the output
+
+    Returns:
+        Formatted enum string
+    """
+    if hasattr(value, "value"):
+        text = str(value.value)
+    else:
+        text = str(value)
+
+    if capitalize:
+        return text.capitalize()
+    return text
+
+
+def format_percentage(value: float, decimals: int = 1) -> str:
+    """Format percentage value.
+
+    Args:
+        value: Percentage as float (e.g., 0.85 for 85%)
+        decimals: Number of decimal places
+
+    Returns:
+        Formatted percentage string
+    """
+    return f"{value * 100:.{decimals}f}%"
+
+
+def format_file_size(bytes_count: int) -> str:
+    """Format file size in human-readable format.
+
+    Args:
+        bytes_count: Size in bytes
+
+    Returns:
+        Formatted size string (e.g., "1.5 MB")
+    """
+    size = float(bytes_count)
+    for unit in ["B", "KB", "MB", "GB", "TB"]:
+        if size < 1024.0:
+            return f"{size:.1f} {unit}"
+        size /= 1024.0
+    return f"{size:.1f} PB"
+
+
+def format_duration_ms(milliseconds: int) -> str:
+    """Format duration in milliseconds to human-readable format.
+
+    Args:
+        milliseconds: Duration in milliseconds
+
+    Returns:
+        Formatted duration string
+    """
+    if milliseconds < 1000:
+        return f"{milliseconds}ms"
+    elif milliseconds < 60000:
+        seconds = milliseconds / 1000
+        return f"{seconds:.2f}s"
+    else:
+        minutes = milliseconds / 60000
+        return f"{minutes:.2f}min"

cli/infrastructure/forms/agent_picker.py

@@ -0,0 +1,123 @@
+"""Agent picker component for selecting base agents.
+
+A specialized search picker that uses the ApiClient to fetch agents
+and returns the selected agent's ID.
+"""
+
+from typing import Any
+
+from alloy_runtime_sdk.api_client.client import ApiClient
+
+from cli.infrastructure.forms.base_picker import SingleSelectPicker
+
+
+def _format_agent(agent: dict[str, Any]) -> str:
+    """Format an agent for display in the picker."""
+    name = agent.get("name", "Unknown")
+    description = agent.get("description")
+    model_count = agent.get("model_count", 0)
+
+    parts = [name]
+    if model_count:
+        parts.append(f"({model_count} model{'s' if model_count != 1 else ''})")
+    if description:
+        # Truncate long descriptions
+        if len(description) > 40:
+            description = description[:37] + "..."
+        parts.append(f"- {description}")
+
+    return " ".join(parts)
+
+
+class AgentPicker(SingleSelectPicker[dict[str, Any]]):
+    """Agent picker for selecting base agents.
+
+    Searches agents via the ApiClient and returns the selected agent's ID.
+    User sees friendly agent names, not UUIDs.
+
+    Usage:
+        yield AgentPicker(
+            client=server_client,
+            id="base-agent",
+        )
+
+        # Get selected agent ID
+        picker = self.query_one("#base-agent", AgentPicker)
+        agent_id = picker.selected_agent_id  # UUID string or None
+    """
+
+    def __init__(
+        self,
+        client: ApiClient,
+        placeholder: str = "Search agents (e.g., my writer agent)...",
+        empty_message: str = "No base agent selected (optional)",
+        fetch_on_mount: bool = True,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the agent picker.
+
+        Args:
+            client: ApiClient instance for API calls
+            placeholder: Placeholder text for search input
+            empty_message: Message shown when nothing is selected
+            fetch_on_mount: If True, show recent agents when picker opens (default True)
+        """
+        super().__init__(
+            client=client,
+            placeholder=placeholder,
+            empty_message=empty_message,
+            fetch_on_mount=fetch_on_mount,
+            **kwargs,
+        )
+
+    @property
+    def selected_agent_id(self) -> str | None:
+        """Alias for selected_id - returns the agent UUID."""
+        return self.selected_id
+
+    @property
+    def selected_agent_name(self) -> str | None:
+        """Get the name of the selected agent."""
+        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 agents matching query from the API.
+
+        When query is empty, returns recent agents sorted by updated_at.
+        """
+        response = await self._client.list_agents(
+            search=query if query else None,
+            limit=10 if not query else 50,
+        )
+        return [agent.model_dump() for agent in response.agents]
+
+    def _format_item(self, item: dict[str, Any]) -> str:
+        """Format agent for display in option list."""
+        return _format_agent(item)
+
+    def _get_item_id(self, item: dict[str, Any]) -> str:
+        """Get unique identifier for an agent."""
+        return str(item.get("id", ""))
+
+    def set_initial_agent(self, agent: dict[str, Any]) -> None:
+        """Pre-populate the picker with an existing agent selection.
+
+        Args:
+            agent: Agent dict with at least 'id' and 'name' keys
+        """
+        self.set_initial_selection(agent)
+
+    def set_initial_agent_by_id(
+        self, agent_id: str, name: str = "Selected Agent"
+    ) -> None:
+        """Pre-populate the picker with an agent by its ID.
+
+        Use this when you only have the agent ID and not the full agent data.
+
+        Args:
+            agent_id: The agent UUID
+            name: Display name for the agent
+        """
+        self.set_initial_selection({"id": agent_id, "name": name})