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

cli/commands/templates/get/presenter.py

@@ -0,0 +1,233 @@
+"""Presenter for template get command output."""
+
+import pyperclip
+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 cli.infrastructure.output import OutputService
+from alloy_runtime_types.dtos.templates import (
+    GetTemplateResponse,
+    TagResponse,
+    TemplateDependencyResponse,
+    TemplateVersionResponse,
+)
+
+
+def _format_tags(tags: list[TagResponse]) -> str:
+    """Format tags for display.
+
+    Args:
+        tags: List of tag responses
+
+    Returns:
+        Formatted tags string or "(none)" if empty
+    """
+    if not tags:
+        return "(none)"
+    return ", ".join(t.tag_path for t in tags)
+
+
+def _format_dependencies(dependencies: list[TemplateDependencyResponse]) -> str:
+    """Format dependencies for display.
+
+    Args:
+        dependencies: List of dependency responses
+
+    Returns:
+        Formatted dependencies string or "(none)" if empty
+    """
+    if not dependencies:
+        return "(none)"
+    return ", ".join(d.child_template_name for d in dependencies)
+
+
+def _format_variables(variables: list[str]) -> str:
+    """Format required variables for display.
+
+    Args:
+        variables: List of variable names
+
+    Returns:
+        Formatted variables string or "(none)" if empty
+    """
+    if not variables:
+        return "(none)"
+    return ", ".join(variables)
+
+
+def _truncate_content(content: str, max_length: int = 500) -> str:
+    """Truncate content for preview display.
+
+    Args:
+        content: Content string to truncate
+        max_length: Maximum length before truncation
+
+    Returns:
+        Truncated content with indicator if truncated
+    """
+    if len(content) <= max_length:
+        return content
+    return content[:max_length] + "\n... (truncated)"
+
+
+def _copy_to_clipboard(content: str, console: Console) -> bool:
+    """Copy content to clipboard.
+
+    Args:
+        content: Text to copy
+        console: Console for output messages
+
+    Returns:
+        True if successful, False otherwise
+    """
+    try:
+        pyperclip.copy(content)
+        console.print("[green]✓[/green] Content copied to clipboard")
+        return True
+    except pyperclip.PyperclipException as e:
+        console.print(f"[red]✗[/red] Failed to copy to clipboard: {e}")
+        return False
+
+
+def present_template_details(
+    response: GetTemplateResponse, full: bool = False, copy: bool = False
+) -> None:
+    """Present template details with Rich formatting.
+
+    Args:
+        response: GetTemplateResponse from server
+        full: Whether to print full content instead of preview
+        copy: Whether to copy content to clipboard
+    """
+    output = OutputService.get()
+    template = response.template
+    versions = response.versions
+    dependencies = response.dependencies
+
+    # Find latest version for required variables
+    latest_version = next((v for v in versions if v.is_latest), None)
+    required_variables = latest_version.required_variables if latest_version else []
+
+    # Build metadata table
+    metadata_table = Table(show_header=False, box=None, padding=(0, 1))
+    metadata_table.add_column("Field", style="dim")
+    metadata_table.add_column("Value")
+
+    metadata_table.add_row("ID", format_uuid(template.id, short=False))
+    metadata_table.add_row("Name", template.name)
+    metadata_table.add_row("Content Type", template.content_type_id)
+    metadata_table.add_row("Visibility", template.visibility_id)
+    metadata_table.add_row("Description", format_optional(template.description))
+    metadata_table.add_row("Tags", _format_tags(template.tags))
+    metadata_table.add_row("Dependencies", _format_dependencies(dependencies))
+    metadata_table.add_row("Required Variables", _format_variables(required_variables))
+    metadata_table.add_row(
+        "Organization ID",
+        format_optional(template.organization_id, lambda x: format_uuid(x, short=True)),
+    )
+    metadata_table.add_row(
+        "User ID",
+        format_optional(template.user_id, lambda x: format_uuid(x, short=True)),
+    )
+    metadata_table.add_row("Created At", format_datetime(template.created_at))
+    metadata_table.add_row("Updated At", format_datetime(template.updated_at))
+
+    # Display metadata panel
+    metadata_panel = Panel(
+        metadata_table,
+        title=f"Template: {template.name}",
+        border_style="green",
+    )
+    output.console.print(metadata_panel)
+
+    # Build versions table
+    if versions:
+        _present_versions_table(output, versions)
+
+    # Handle content display based on flags
+    if latest_version and latest_version.content:
+        content = latest_version.content
+
+        # Copy to clipboard if requested
+        if copy:
+            _copy_to_clipboard(content, output.console)
+
+        # Show full content or preview
+        if full:
+            _present_full_content(output, latest_version)
+        else:
+            _present_content_preview(output, latest_version)
+
+
+def _present_versions_table(
+    output: OutputService, versions: list[TemplateVersionResponse]
+) -> None:
+    """Present versions as a table.
+
+    Args:
+        output: OutputService instance
+        versions: List of template versions
+    """
+    versions_table = Table(
+        title=f"Versions ({len(versions)})",
+        show_header=True,
+        header_style="bold",
+    )
+    versions_table.add_column("Version", justify="right")
+    versions_table.add_column("Latest")
+    versions_table.add_column("Content Length", justify="right")
+    versions_table.add_column("Variables")
+    versions_table.add_column("Created At")
+
+    for v in versions:
+        versions_table.add_row(
+            f"v{v.version}",
+            "Yes" if v.is_latest else "-",
+            f"{len(v.content)} chars",
+            _format_variables(v.required_variables) if v.is_latest else "-",
+            format_datetime(v.created_at),
+        )
+
+    output.console.print(versions_table)
+
+
+def _present_content_preview(
+    output: OutputService, version: TemplateVersionResponse
+) -> None:
+    """Present content preview for a version.
+
+    Args:
+        output: OutputService instance
+        version: Template version to preview
+    """
+    content_preview = _truncate_content(version.content)
+    content_panel = Panel(
+        Text(content_preview, style="dim"),
+        title=f"Content Preview (v{version.version})",
+        border_style="blue",
+    )
+    output.console.print(content_panel)
+
+
+def _present_full_content(
+    output: OutputService, version: TemplateVersionResponse
+) -> None:
+    """Present full content for a version.
+
+    Args:
+        output: OutputService instance
+        version: Template version to display
+    """
+    content_panel = Panel(
+        Text(version.content),
+        title=f"Content (v{version.version}) - {len(version.content)} chars",
+        border_style="blue",
+    )
+    output.console.print(content_panel)

cli/commands/templates/get_by_version/command.py

@@ -0,0 +1,32 @@
+"""Templates get_by_version command implementation."""
+
+from uuid import UUID
+
+import typer
+
+from cli.commands.templates.get_by_version.presenter import present_template_details
+from cli.commands.flag_utils import validate_uuid
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def templates_get_by_version_command(
+    version_id: str = typer.Argument(
+        ...,
+        help="Template version UUID",
+    ),
+) -> None:
+    """Get a template by its version ID.
+
+    Examples:
+        ai templates get-by-version 123e4567-89ab-cdef-0123-456789abcdef
+    """
+    version_uuid = validate_uuid(version_id, "template version")
+    _execute_get(version_id=version_uuid)
+
+
+@async_command
+async def _execute_get(version_id: UUID) -> None:
+    async with authenticated_client() as (_config, client):
+        response = await client.get_template_by_version(version_id)
+
+    present_template_details(response)

cli/commands/templates/get_by_version/presenter.py

@@ -0,0 +1,30 @@
+"""Presenter for templates get_by_version command output."""
+
+from rich.table import Table
+
+from cli.infrastructure.output import OutputService
+from alloy_runtime_types.dtos.templates import GetTemplateResponse
+
+
+def present_template_details(response: GetTemplateResponse) -> None:
+    output = OutputService.get()
+
+    output.success(f"Retrieved template: {response.template.name}")
+
+    table = Table(show_header=False, box=None, padding=(0, 1))
+    table.add_column("Field", style="dim", width=20)
+    table.add_column("Value")
+
+    table.add_row("ID", str(response.template.id))
+    table.add_row("Name", response.template.name)
+    table.add_row("Description", response.template.description or "-")
+    table.add_row("Content Type", response.template.content_type_id)
+    table.add_row("Visibility", response.template.visibility_id)
+    table.add_row(
+        "Tags",
+        ", ".join(t.tag_path for t in response.template.tags)
+        if response.template.tags
+        else "-",
+    )
+
+    output.console.print(table)

cli/commands/templates/list/__init__.py

@@ -0,0 +1 @@
+

cli/commands/templates/list/command.py

@@ -0,0 +1,102 @@
+"""Templates list command implementation."""
+
+from typing import Optional
+
+import typer
+
+from cli.commands.flag_utils import validate_template_content_type, validate_visibility
+from cli.commands.templates.list.presenter import present_templates_list
+from cli.infrastructure.command import async_command, authenticated_client
+from alloy_runtime_types.enums.template_enums import (
+    TemplateContentType,
+    TemplateVisibility,
+)
+
+
+def templates_list_command(
+    search: Optional[str] = typer.Option(
+        None,
+        "-s",
+        "--search",
+        help="Fuzzy search terms",
+    ),
+    content_type: Optional[str] = typer.Option(
+        None,
+        "--type",
+        help="Filter by type: system_instruction, user_message, fragment",
+    ),
+    visibility: Optional[str] = typer.Option(
+        None,
+        "-V",
+        "--visibility",
+        help="Filter by: private, organization, public",
+    ),
+    tag_path: Optional[str] = typer.Option(
+        None,
+        "-t",
+        "--tag",
+        help="Filter by tag pattern (e.g., '*.email.*')",
+    ),
+    limit: int = typer.Option(
+        50,
+        "-l",
+        "--limit",
+        min=1,
+        max=100,
+        help="Max results",
+    ),
+    cursor: Optional[str] = typer.Option(
+        None,
+        "--cursor",
+        help="Pagination cursor",
+    ),
+) -> None:
+    """List templates.
+
+    Examples:
+        ai templates list
+        ai tpl list -s "email newsletter"
+        ai tpl list --type system_instruction
+        ai tpl list -V organization -t "*.email.*"
+        ai tpl list -l 20
+    """
+    # Parse and validate enums
+    content_type_enum: Optional[TemplateContentType] = None
+    if content_type:
+        content_type_enum = validate_template_content_type(content_type)
+
+    visibility_enum: Optional[TemplateVisibility] = None
+    if visibility:
+        visibility_enum = validate_visibility(visibility)
+
+    _execute_list(
+        search=search,
+        content_type=content_type_enum,
+        visibility=visibility_enum,
+        tag_path=tag_path,
+        limit=limit,
+        cursor=cursor,
+    )
+
+
+@async_command
+async def _execute_list(
+    search: Optional[str],
+    content_type: Optional[TemplateContentType],
+    visibility: Optional[TemplateVisibility],
+    tag_path: Optional[str],
+    limit: int,
+    cursor: Optional[str],
+) -> None:
+    """Execute list templates operation."""
+    async with authenticated_client() as (_config, client):
+        response = await client.list_templates(
+            search=search,
+            content_type=content_type,
+            visibility=visibility,
+            tag_path=tag_path,
+            limit=limit,
+            cursor=cursor,
+        )
+
+    present_templates_list(response)

cli/commands/templates/list/presenter.py

@@ -0,0 +1,93 @@
+"""Presenter for templates list command output."""
+
+from alloy_runtime_types.dtos.templates import ListTemplatesResponse, TagResponse
+
+from cli.infrastructure.output import OutputService
+from cli.infrastructure.renderers.list_renderer import ColumnConfig
+
+
+def _format_tags(tags: list[TagResponse]) -> str:
+    """Format tags for display, truncating if too many.
+
+    Args:
+        tags: List of tag responses
+
+    Returns:
+        Formatted tags string
+    """
+    if not tags:
+        return "-"
+    tag_paths = [t.tag_path for t in tags[:3]]
+    result = ", ".join(tag_paths)
+    if len(tags) > 3:
+        result += f" (+{len(tags) - 3})"
+    return result
+
+
+def present_templates_list(response: ListTemplatesResponse) -> None:
+    """Present list of templates with Rich table formatting.
+
+    Args:
+        response: List templates response from server
+    """
+    output = OutputService.get()
+
+    if not response.templates:
+        output.info("No templates found")
+        return
+
+    # Define table columns with compact layout configuration
+    # Line 1 (primary): ID, type, visibility, version - machine-readable data
+    # Line 2 (detail): Name, tags - human-readable content
+    columns = [
+        ColumnConfig(
+            source_field="id",
+            header_label="UUID",
+            compact_line=1,
+            compact_style="cyan",
+        ),
+        ColumnConfig(
+            source_field="content_type_id",
+            header_label="Type",
+            compact_line=1,
+            compact_style="magenta",
+        ),
+        ColumnConfig(
+            source_field="visibility_id",
+            header_label="Visibility",
+            compact_line=1,
+            compact_style="dim",
+        ),
+        ColumnConfig(
+            source_field="latest_version_number",
+            header_label="Version",
+            formatter=lambda x: f"v{x}" if x else "-",
+            align="right",
+            compact_line=1,
+            compact_style="yellow",
+        ),
+        ColumnConfig(
+            source_field="name",
+            header_label="Name",
+            compact_line=2,
+            compact_style="white bold",
+        ),
+        ColumnConfig(
+            source_field="tags",
+            header_label="Tags",
+            formatter=_format_tags,
+            compact_line=2,
+            compact_style="dim italic",
+        ),
+    ]
+
+    # Render table
+    output.table(
+        items=response.templates,  # type: ignore[arg-type]
+        title=f"Templates ({response.total_count})",
+        columns=columns,
+    )
+
+    # Show pagination info if there's a next page
+    if response.cursor:
+        output.status(f"Next page: ai templates list --cursor '{response.cursor}'")

cli/commands/templates/render/command.py

@@ -0,0 +1,115 @@
+"""Template render command implementation."""
+
+from typing import Annotated, Any, Optional
+
+import typer
+
+from cli.commands.flag_utils import validate_output_mode
+from cli.commands.templates.render.presenter import present_render_result
+from cli.infrastructure.command import async_command, authenticated_client
+from cli.infrastructure.kv_parser import parse_kv_pairs
+from alloy_runtime_types.dtos.templates import RenderTemplateRequest
+
+
+def templates_render_command(
+    template: str = typer.Option(
+        ...,
+        "-T",
+        "--template",
+        help="Template name or UUID",
+    ),
+    variables: Annotated[
+        Optional[list[str]],
+        typer.Option(
+            "-v",
+            "--var",
+            help="Variable (key=value or key:=json). Repeatable.",
+        ),
+    ] = None,
+    output: str = typer.Option(
+        "console",
+        "-o",
+        "--output",
+        help="Output: console, clipboard, file, editor",
+    ),
+    output_file: Optional[str] = typer.Option(
+        None,
+        "-O",
+        "--output-file",
+        help="Output file path (for --output file)",
+    ),
+    print_escaped: bool = typer.Option(
+        False,
+        "--print-escaped",
+        help="Print remaining Jinja syntax (from raw blocks)",
+    ),
+) -> None:
+    """Render a template with variables.
+
+    Examples:
+        ai templates render -T my-template -v name=World -v greeting=Hello
+        ai tpl render -T email.welcome -v user=John -o clipboard
+        ai tpl render -T my-template -v count:=5 -v active:=true
+        ai tpl render -T my-template -o file -O output.txt
+    """
+    validate_output_mode(
+        output, output_file, ("console", "clipboard", "file", "editor")
+    )
+
+    variables_dict = parse_kv_pairs(variables)
+
+    _execute_render_from_flags(
+        template_identifier=template,
+        variables_dict=variables_dict,
+        output_mode=output,
+        output_file=output_file,
+        print_escaped=print_escaped,
+    )
+
+
+def _execute_render_from_flags(
+    template_identifier: str,
+    variables_dict: dict[str, Any] | None,
+    output_mode: str,
+    output_file: str | None = None,
+    print_escaped: bool = False,
+) -> None:
+    """Execute template rendering from command flags."""
+    _execute_render(
+        template_identifier=template_identifier,
+        variables=variables_dict,
+        output_mode=output_mode,
+        output_file=output_file,
+        print_escaped=print_escaped,
+    )
+
+
+@async_command
+async def _execute_render(
+    template_identifier: str,
+    variables: dict[str, Any] | None,
+    output_mode: str,
+    output_file: str | None = None,
+    print_escaped: bool = False,
+) -> None:
+    """Execute the template render API call."""
+    from alloy_runtime_sdk.exceptions.errors import NotFoundError
+
+    async with authenticated_client() as (_config, client):
+        try:
+            template_data = await client.get_template(template_identifier)
+        except NotFoundError:
+            raise typer.BadParameter(
+                f"Template '{template_identifier}' not found. Use 'ai templates list' to see available templates."
+            )
+
+        request = RenderTemplateRequest(variables=variables or {})
+        response = await client.render_template(template_data.template.id, request)
+
+    present_render_result(
+        response,
+        template_data.template.name,
+        output_mode,
+        output_file=output_file,
+        print_escaped=print_escaped,
+    )