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

cli/commands/templates/render/presenter.py

@@ -0,0 +1,276 @@
+"""Presenter for template render output."""
+
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Any
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from cli.infrastructure.editor import EditorError, get_editor
+from cli.infrastructure.formatting.fields import format_uuid
+from cli.infrastructure.macro_parser import extract_jinja_syntax
+from cli.infrastructure.output import OutputService
+from alloy_runtime_types.dtos.templates import RenderTemplateResponse
+
+# Import pyperclip at module level for easier mocking in tests
+pyperclip: Any | None = None
+try:
+    import pyperclip as _pyperclip
+except ImportError:
+    pass
+else:
+    pyperclip = _pyperclip
+
+PYPERCLIP_AVAILABLE = pyperclip is not None
+
+
+def present_render_result(
+    response: RenderTemplateResponse,
+    template_name: str,
+    output_mode: str = "console",
+    output_file: str | None = None,
+    print_escaped: bool = False,
+) -> bool:
+    """Present the rendered template result.
+
+    Args:
+        response: Render response from server
+        template_name: Name of the rendered template
+        output_mode: Output destination - 'console', 'clipboard', 'file', or 'editor'
+        output_file: File path for 'file' output mode
+        print_escaped: If True, print Jinja syntax found in rendered output
+
+    Returns:
+        True if output was successful, False if output failed
+    """
+    output = OutputService.get()
+
+    if output_mode == "clipboard":
+        result = _copy_to_clipboard(response.rendered_text, template_name, output)
+    elif output_mode == "file":
+        result = _save_to_file(response, template_name, output_file, output)
+    elif output_mode == "editor":
+        result = _open_in_editor(response.rendered_text, template_name, output)
+    else:
+        result = _display_to_console(response, template_name, output)
+
+    # Print escaped Jinja syntax after output if requested
+    if print_escaped:
+        _print_escaped_jinja(response.rendered_text, output)
+
+    return result
+
+
+def _print_escaped_jinja(rendered_text: str, output: OutputService) -> None:
+    """Print Jinja syntax found in rendered output.
+
+    Extracts and prints {{ }}, {% %}, and {# #} blocks that remain
+    in the rendered output (typically from {% raw %} blocks).
+
+    Args:
+        rendered_text: The rendered template content
+        output: Output service for printing
+    """
+    matches = extract_jinja_syntax(rendered_text)
+
+    if not matches:
+        output.info("No escaped Jinja syntax found in rendered output")
+        return
+
+    # Print to stderr so it doesn't interfere with piped output
+    stderr_console = Console(file=sys.stderr, force_terminal=True)
+    stderr_console.print(
+        f"\n[bold cyan]Escaped Jinja Syntax[/bold cyan] ({len(matches)} found):"
+    )
+
+    for match in matches:
+        # Print the full content of each match
+        stderr_console.print(match.content)
+
+    stderr_console.print()  # Blank line after
+
+
+def _display_to_console(
+    response: RenderTemplateResponse,
+    template_name: str,
+    _output: OutputService,
+) -> bool:
+    """Display rendered template to console.
+
+    Metadata and status messages are printed to stderr for piping support.
+    The actual rendered content is printed to stdout without formatting.
+    """
+    # Create a console for stderr output (for metadata/status)
+    stderr_console = Console(file=sys.stderr, force_terminal=True)
+
+    # Print success message to stderr (directly, not through output service)
+    stderr_console.print(
+        f"[green]✓[/green] Template '{template_name}' rendered successfully"
+    )
+
+    # Metadata table - print to stderr
+    meta_table = Table(show_header=False, box=None, padding=(0, 1))
+    meta_table.add_column("Field", style="dim")
+    meta_table.add_column("Value")
+
+    meta_table.add_row("Character Count", f"{response.character_count:,}")
+    meta_table.add_row(
+        "Version ID", format_uuid(response.template_version_id, short=True)
+    )
+    meta_table.add_row("Content Hash", response.content_hash[:16] + "...")
+    meta_table.add_row("Render Log ID", format_uuid(response.render_log_id, short=True))
+
+    meta_panel = Panel(meta_table, title="Render Metadata", border_style="blue")
+    stderr_console.print(meta_panel)
+
+    # Print the actual rendered content to stdout (for piping)
+    # No formatting, no panel - just the raw content
+    print(response.rendered_text, file=sys.stdout)
+
+    return True
+
+
+def _save_to_file(
+    response: RenderTemplateResponse,
+    template_name: str,
+    output_file: str | None,
+    output: OutputService,
+) -> bool:
+    """Save rendered template to a file.
+
+    Returns True on success, False on failure.
+    """
+    if not output_file:
+        output.warning("No output file specified")
+        return False
+
+    try:
+        file_path = Path(output_file).expanduser().resolve()
+
+        # Ensure parent directory exists
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Write the content to the file
+        file_path.write_text(response.rendered_text, encoding="utf-8")
+
+        output.success(
+            f"Template '{template_name}' rendered and saved to {file_path} "
+            f"({response.character_count:,} characters)"
+        )
+        return True
+    except PermissionError:
+        output.warning(f"Permission denied: Cannot write to '{output_file}'")
+        return False
+    except OSError as e:
+        output.warning(f"Failed to save file: {e}")
+        return False
+
+
+def _copy_to_clipboard(
+    rendered_text: str,
+    template_name: str,
+    output: OutputService,
+) -> bool:
+    """Copy rendered template to clipboard.
+
+    All output goes to stderr since clipboard mode doesn't output the content to stdout.
+
+    Returns True on success, False on failure.
+    """
+    if not PYPERCLIP_AVAILABLE or pyperclip is None:
+        output.warning("pyperclip not installed. Install with: pip install pyperclip")
+        output.info("Falling back to console output...")
+        # Fallback: print to stdout for piping
+        print(rendered_text, file=sys.stdout)
+        return False
+
+    try:
+        pyperclip.copy(rendered_text)
+        output.success(
+            f"Template '{template_name}' rendered and copied to clipboard "
+            f"({len(rendered_text):,} characters)"
+        )
+        return True
+    except Exception as e:
+        output.warning(f"Failed to copy to clipboard: {e}")
+        output.info("Falling back to console output...")
+        # Fallback: print to stdout for piping
+        print(rendered_text, file=sys.stdout)
+        return False
+
+
+def _open_in_editor(
+    rendered_text: str,
+    template_name: str,
+    output: OutputService,
+) -> bool:
+    """Open rendered template in the user's $EDITOR.
+
+    Creates a temporary file, opens it in the editor, and waits for the editor
+    to close. The temporary file is cleaned up afterward.
+
+    Returns True on success, False on failure.
+    """
+    try:
+        editor = get_editor()
+    except EditorError:
+        output.warning(
+            "No editor found. Set $EDITOR environment variable or install nano/vim."
+        )
+        output.info("Falling back to console output...")
+        print(rendered_text, file=sys.stdout)
+        return False
+
+    # Create temp file with .txt extension
+    try:
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            suffix=".txt",
+            delete=False,
+            encoding="utf-8",
+        ) as f:
+            f.write(rendered_text)
+            temp_path = Path(f.name)
+    except OSError as e:
+        output.warning(f"Failed to create temporary file: {e}")
+        output.info("Falling back to console output...")
+        print(rendered_text, file=sys.stdout)
+        return False
+
+    try:
+        # 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:
+            output.warning(f"Editor exited with non-zero status: {result}")
+            return False
+
+        output.success(
+            f"Template '{template_name}' rendered and opened in editor "
+            f"({len(rendered_text):,} characters)"
+        )
+        return True
+
+    except FileNotFoundError:
+        output.warning(f"Editor '{editor}' not found")
+        output.info("Falling back to console output...")
+        print(rendered_text, file=sys.stdout)
+        return False
+    except OSError as e:
+        output.warning(f"Failed to open editor: {e}")
+        output.info("Falling back to console output...")
+        print(rendered_text, file=sys.stdout)
+        return False
+    finally:
+        # Clean up temp file
+        try:
+            temp_path.unlink()
+        except OSError:
+            pass  # Best effort cleanup

cli/commands/templates/update/command.py

@@ -0,0 +1,199 @@
+"""Template update command implementation."""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from cli.commands.flag_utils import (
+    parse_tags,
+    require_exclusive,
+    require_update_flags,
+    validate_template_content_type,
+    validate_visibility,
+)
+from cli.commands.templates.update.presenter import present_template_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.templates import UpdateTemplateRequest
+from alloy_runtime_types.enums.template_enums import (
+    TemplateContentType,
+    TemplateVisibility,
+)
+from alloy_runtime_sdk.exceptions.errors import NotFoundError
+
+
+def templates_update_command(
+    template: str = typer.Argument(..., help="Template name or UUID"),
+    name: Optional[str] = typer.Option(
+        None,
+        "-n",
+        "--name",
+        help="New name",
+    ),
+    description: Optional[str] = typer.Option(
+        None,
+        "-d",
+        "--description",
+        help="New description",
+    ),
+    content_type: Optional[str] = typer.Option(
+        None,
+        "--type",
+        help="New type: system_instruction, user_message, fragment",
+    ),
+    visibility: Optional[str] = typer.Option(
+        None,
+        "-V",
+        "--visibility",
+        help="New visibility: private, organization, public",
+    ),
+    content: Optional[str] = typer.Option(
+        None,
+        "-c",
+        "--content",
+        help="New content (or @file)",
+    ),
+    content_file: Optional[Path] = typer.Option(
+        None,
+        "-f",
+        "--file",
+        help="Read new content from file",
+        exists=True,
+        readable=True,
+    ),
+    tags: Optional[str] = typer.Option(
+        None,
+        "-t",
+        "--tags",
+        help="Replace tags (comma-separated)",
+    ),
+    clear_description: bool = typer.Option(
+        False,
+        "--clear-description",
+        help="Clear description",
+    ),
+    clear_tags: bool = typer.Option(
+        False,
+        "--clear-tags",
+        help="Remove all tags",
+    ),
+) -> None:
+    """Update an existing template.
+
+    Only specified fields are updated. Content updates only allowed for single-version templates.
+
+    Examples:
+        ai templates update my-template -n new-name
+        ai tpl update my-template -d "New description"
+        ai tpl update my-template --clear-description
+        ai tpl update my-template -f template.jinja2
+        ai tpl update my-template -V public -t "new.tag"
+    """
+    # Validate exclusive flags
+    require_exclusive(("--file", content_file), ("--content", content))
+    require_exclusive(
+        ("--description", description), ("--clear-description", clear_description)
+    )
+    require_exclusive(("--tags", tags), ("--clear-tags", clear_tags))
+
+    # Check at least one update flag provided
+    require_update_flags(
+        ("--name", name),
+        ("--description", description),
+        ("--type", content_type),
+        ("--visibility", visibility),
+        ("--content", content),
+        ("--file", content_file),
+        ("--tags", tags),
+        ("--clear-description", clear_description),
+        ("--clear-tags", clear_tags),
+    )
+
+    _execute_update(
+        template_identifier=template,
+        name=name,
+        description=description,
+        content_type=content_type,
+        visibility=visibility,
+        content=content,
+        content_file=content_file,
+        tags=tags,
+        clear_description=clear_description,
+        clear_tags=clear_tags,
+    )
+
+
+@async_command
+async def _execute_update(
+    template_identifier: str,
+    name: Optional[str],
+    description: Optional[str],
+    content_type: Optional[str],
+    visibility: Optional[str],
+    content: Optional[str],
+    content_file: Optional[Path],
+    tags: Optional[str],
+    clear_description: bool,
+    clear_tags: bool,
+) -> None:
+    """Execute the template update operation."""
+    # Resolve @file references
+    try:
+        content = resolve_content(content)
+    except FileContentError as e:
+        raise typer.BadParameter(str(e))
+
+    # Get content from file if specified
+    template_content: Optional[str] = None
+    if content_file is not None:
+        template_content = content_file.read_text()
+    elif content is not None:
+        template_content = content
+
+    # Validate enums
+    content_type_enum: Optional[TemplateContentType] = None
+    if content_type is not None:
+        content_type_enum = validate_template_content_type(content_type)
+
+    visibility_enum: Optional[TemplateVisibility] = None
+    if visibility is not None:
+        visibility_enum = validate_visibility(visibility)
+
+    # Handle tags
+    tag_paths: Optional[list[str]] = None
+    if clear_tags:
+        tag_paths = []
+    elif tags is not None:
+        tag_paths = parse_tags(tags)
+        if not tag_paths:
+            raise typer.BadParameter("--tags must contain at least one tag")
+
+    # Handle description
+    final_description: Optional[str] = description
+    if clear_description:
+        final_description = ""
+
+    # Build update request
+    request = UpdateTemplateRequest(
+        name=name,
+        description=final_description
+        if (description is not None or clear_description)
+        else None,
+        content_type=content_type_enum,
+        visibility=visibility_enum,
+        content=template_content,
+        tag_paths=tag_paths,
+    )
+
+    async with authenticated_client() as (_config, client):
+        try:
+            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."
+            )
+
+        response = await client.update_template(template_identifier, request)
+
+    present_template_update_success(response)

cli/commands/templates/update/presenter.py

@@ -0,0 +1,94 @@
+"""Presenter for template update output."""
+
+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 UpdateTemplateResponse
+
+
+def present_template_update_success(response: UpdateTemplateResponse) -> None:
+    """Present successful template update.
+
+    Args:
+        response: Template update response from server
+    """
+    output = OutputService.get()
+
+    template = response.template
+    version = response.version
+    dependencies = response.dependencies
+
+    output.success("Template updated successfully")
+
+    # Build a table for template display
+    table = Table(show_header=False, box=None, padding=(0, 1))
+    table.add_column("Field", style="dim")
+    table.add_column("Value")
+
+    # Template info
+    table.add_row("ID", format_uuid(template.id, short=False))
+    table.add_row("Name", template.name)
+    table.add_row("Content Type", template.content_type_id)
+    table.add_row("Visibility", template.visibility_id)
+    table.add_row("Description", format_optional(template.description))
+
+    # Version info
+    table.add_row("Version", str(version.version))
+    table.add_row("Version ID", format_uuid(version.id, short=True))
+    table.add_row("Content Length", f"{len(version.content)} chars")
+
+    # Tags
+    if template.tags:
+        tag_str = ", ".join(t.tag_path for t in template.tags)
+        table.add_row("Tags", tag_str)
+    else:
+        table.add_row("Tags", "(none)")
+
+    # Dependencies
+    if dependencies:
+        dep_str = ", ".join(d.child_template_name for d in dependencies)
+        table.add_row("Dependencies", dep_str)
+    else:
+        table.add_row("Dependencies", "(none)")
+
+    # Variables
+    if version.required_variables:
+        vars_str = ", ".join(version.required_variables)
+        table.add_row("Required Variables", vars_str)
+    else:
+        table.add_row("Required Variables", "(none)")
+
+    # Ownership
+    table.add_row(
+        "Organization ID",
+        format_optional(template.organization_id, lambda x: format_uuid(x, short=True)),
+    )
+    table.add_row(
+        "User ID",
+        format_optional(template.user_id, lambda x: format_uuid(x, short=True)),
+    )
+    table.add_row("Created At", format_datetime(template.created_at))
+    table.add_row("Updated At", format_datetime(template.updated_at))
+
+    panel = Panel(table, title=f"Template: {template.name}", border_style="green")
+    output.console.print(panel)
+
+    # Show content preview
+    if version.content:
+        content_preview = version.content
+        if len(content_preview) > 500:
+            content_preview = content_preview[:500] + "\n... (truncated)"
+
+        content_panel = Panel(
+            Text(content_preview, style="dim"),
+            title="Content Preview",
+            border_style="blue",
+        )
+        output.console.print(content_panel)

cli/commands/templates/version/__init__.py

@@ -0,0 +1 @@
+

cli/commands/templates/version/command.py

@@ -0,0 +1,116 @@
+"""Template version create command implementation."""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from cli.commands.flag_utils import parse_tags, require_one_of
+from cli.commands.templates.version.presenter import present_version_create_success
+from cli.infrastructure.command import async_command, authenticated_client
+from alloy_runtime_types.dtos.templates import CreateTemplateVersionRequest
+
+
+def templates_version_command(
+    template: str = typer.Argument(
+        ...,
+        help="Template name or UUID",
+    ),
+    content_file: Optional[Path] = typer.Option(
+        None,
+        "-f",
+        "--file",
+        help="Read content from file",
+        exists=True,
+        readable=True,
+    ),
+    content: Optional[str] = typer.Option(
+        None,
+        "-c",
+        "--content",
+        help="Inline content",
+    ),
+    tags: Optional[str] = typer.Option(
+        None,
+        "-t",
+        "--tags",
+        help="Replace tags (comma-separated)",
+    ),
+    clear_tags: bool = typer.Option(
+        False,
+        "--clear-tags",
+        help="Remove all tags",
+    ),
+) -> None:
+    """Create a new version of a template.
+
+    Examples:
+        ai templates version my-template -c "Updated content"
+        ai tpl version my-template -f updated.jinja2
+        ai tpl version my-template -c "New content" -t "email,v2"
+        ai tpl version my-template -c "New content" --clear-tags
+    """
+    require_one_of(("--file", content_file), ("--content", content))
+
+    _execute_version_from_flags(
+        template_identifier=template,
+        content_file=content_file,
+        content=content,
+        tags=tags,
+        clear_tags=clear_tags,
+    )
+
+
+def _execute_version_from_flags(
+    template_identifier: str,
+    content_file: Optional[Path],
+    content: Optional[str],
+    tags: Optional[str],
+    clear_tags: bool,
+) -> None:
+    """Build and execute version creation from command flags."""
+    # Get content from file or inline
+    if content_file:
+        template_content = content_file.read_text()
+    else:
+        template_content = content or ""
+
+    if not template_content.strip():
+        raise typer.BadParameter("Template content cannot be empty")
+
+    # Parse tags
+    tag_paths: list[str] | None = None
+    if clear_tags:
+        tag_paths = []
+    elif tags:
+        tag_paths = parse_tags(tags)
+
+    # Build request
+    request = CreateTemplateVersionRequest(
+        content=template_content,
+        tag_paths=tag_paths,
+    )
+
+    _resolve_and_create_version(template_identifier, request)
+
+
+@async_command
+async def _resolve_and_create_version(
+    template_identifier: str, request: CreateTemplateVersionRequest
+) -> None:
+    """Resolve template identifier and create version."""
+    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."
+            )
+
+        response = await client.create_template_version(
+            template_data.template.id, request
+        )
+
+    present_version_create_success(response)