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

cli/commands/tags/delete/presenter.py

@@ -0,0 +1,10 @@
+"""Presenter for tag delete command output."""
+
+from cli.infrastructure.output import OutputService
+from alloy_runtime_types.dtos.tags import DeleteTagResponse
+
+
+def present_delete_result(response: DeleteTagResponse) -> None:
+    """Present tag deletion result."""
+    output = OutputService.get()
+    output.success(f"Deleted tag: {response.deleted_tag.tag_path}")

cli/commands/tags/get/command.py

@@ -0,0 +1,31 @@
+"""Tags get command implementation."""
+
+from uuid import UUID
+import typer
+
+from cli.commands.tags.get.presenter import present_tag_details
+from cli.commands.flag_utils import validate_uuid
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def tags_get_command(
+    tag_id: str = typer.Argument(
+        ...,
+        help="Tag UUID",
+    ),
+) -> None:
+    """Get details of a single tag.
+
+    Examples:
+        ai tags get 123e4567-89ab-cdef-0123-456789abcdef
+    """
+    tag_uuid = validate_uuid(tag_id, "tag")
+    _execute_get(tag_id=tag_uuid)
+
+
+@async_command
+async def _execute_get(tag_id: UUID) -> None:
+    async with authenticated_client() as (_config, client):
+        response = await client.get_tag(tag_id)
+
+    present_tag_details(response)

cli/commands/tags/get/presenter.py

@@ -0,0 +1,23 @@
+"""Presenter for tags get command output."""
+
+from rich.table import Table
+
+from cli.infrastructure.output import OutputService
+from alloy_runtime_types.dtos.tags import GetTagResponse
+
+
+def present_tag_details(response: GetTagResponse) -> None:
+    output = OutputService.get()
+
+    output.success(f"Retrieved tag: {response.tag.tag_path}")
+
+    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.tag.id))
+    table.add_row("Tag Path", response.tag.tag_path)
+    table.add_row("Display Name", response.tag.display_name or "-")
+    table.add_row("Description", response.tag.description or "-")
+
+    output.console.print(table)

cli/commands/tags/list/__init__.py

@@ -0,0 +1 @@
+# Empty per project convention - import directly from submodules

cli/commands/tags/list/command.py

@@ -0,0 +1,52 @@
+"""Tags list command implementation."""
+
+from typing import Optional
+
+import typer
+
+from cli.commands.tags.list.presenter import present_tags_list
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def tags_list_command(
+    search: Optional[str] = typer.Option(
+        None,
+        "-s",
+        "--search",
+        help="Fuzzy search terms",
+    ),
+    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 tags in your organization.
+
+    Examples:
+        ai tags list
+        ai tags list -s "marketing"
+    """
+    _execute_list(search=search, limit=limit, offset=offset)
+
+
+@async_command
+async def _execute_list(search: Optional[str], limit: int, offset: int) -> None:
+    """Execute list tags operation."""
+    async with authenticated_client() as (_config, client):
+        response = await client.list_tags(
+            search=search,
+            limit=limit,
+            offset=offset,
+        )
+
+    present_tags_list(response)

cli/commands/tags/list/presenter.py

@@ -0,0 +1,49 @@
+"""Presenter for tags list command output."""
+
+from alloy_runtime_types.dtos.tags import ListTagsResponse
+
+from cli.infrastructure.output import OutputService
+from cli.infrastructure.renderers.list_renderer import ColumnConfig
+
+
+def present_tags_list(response: ListTagsResponse) -> None:
+    """Present list of tags with Rich table formatting."""
+    output = OutputService.get()
+
+    if not response.tags:
+        output.info("No tags found")
+        return
+
+    columns = [
+        ColumnConfig(
+            source_field="id",
+            header_label="ID",
+            compact_line=1,
+            compact_style="cyan",
+        ),
+        ColumnConfig(
+            source_field="tag_path",
+            header_label="Path",
+            compact_line=1,
+            compact_style="green",
+        ),
+        ColumnConfig(
+            source_field="display_name",
+            header_label="Display Name",
+            compact_line=2,
+            compact_style="white bold",
+        ),
+        ColumnConfig(
+            source_field="description",
+            header_label="Description",
+            formatter=lambda x: x[:60] + "..." if x and len(x) > 60 else (x or "-"),
+            compact_line=2,
+            compact_style="dim",
+        ),
+    ]
+
+    output.table(
+        items=response.tags,  # type: ignore[arg-type]
+        title=f"Tags ({response.total})",
+        columns=columns,
+    )

cli/commands/tags/update/command.py

@@ -0,0 +1,64 @@
+"""Tags update command implementation."""
+
+from typing import Optional
+from uuid import UUID
+
+import typer
+
+from cli.commands.tags.update.presenter import present_update_result
+from cli.commands.flag_utils import validate_uuid, require_update_flags
+from cli.infrastructure.command import async_command, authenticated_client
+from alloy_runtime_types.dtos.tags import UpdateTagRequest
+
+
+def tags_update_command(
+    tag_id: str = typer.Argument(
+        ...,
+        help="Tag UUID",
+    ),
+    display_name: Optional[str] = typer.Option(
+        None,
+        "-n",
+        "--display-name",
+        help="New display name",
+    ),
+    description: Optional[str] = typer.Option(
+        None,
+        "-d",
+        "--description",
+        help="New description",
+    ),
+) -> None:
+    """Update a tag's display name or description.
+
+    Examples:
+        ai tags update 123e4567-89ab... -n "New Name"
+        ai tags update 123e4567-89ab... -d "New description"
+    """
+    require_update_flags(
+        ("--display-name", display_name),
+        ("--description", description),
+    )
+
+    tag_uuid = validate_uuid(tag_id, "tag")
+    _execute_update(
+        tag_id=tag_uuid,
+        display_name=display_name,
+        description=description,
+    )
+
+
+@async_command
+async def _execute_update(
+    tag_id: UUID,
+    display_name: Optional[str],
+    description: Optional[str],
+) -> None:
+    request = UpdateTagRequest(
+        display_name=display_name,
+        description=description,
+    )
+    async with authenticated_client() as (_config, client):
+        response = await client.update_tag(tag_id, request)
+
+    present_update_result(response)

cli/commands/tags/update/presenter.py

@@ -0,0 +1,9 @@
+"""Presenter for tags update command output."""
+
+from cli.infrastructure.output import OutputService
+from alloy_runtime_types.dtos.tags import UpdateTagResponse
+
+
+def present_update_result(response: UpdateTagResponse) -> None:
+    output = OutputService.get()
+    output.success(f"Updated tag: {response.tag.tag_path}")

cli/commands/templates/create/command.py

@@ -0,0 +1,152 @@
+"""Template create command implementation."""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from cli.commands.flag_utils import (
+    parse_tags_required,
+    require_one_of,
+    validate_template_content_type,
+    validate_visibility,
+)
+from cli.commands.templates.create.presenter import present_template_create_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 CreateTemplateRequest
+
+
+def templates_create_command(
+    name: str = typer.Option(
+        ...,
+        "-n",
+        "--name",
+        help="Template name",
+    ),
+    content_type: str = typer.Option(
+        ...,
+        "--type",
+        help="Type: system_instruction, user_message, fragment",
+    ),
+    visibility: str = typer.Option(
+        ...,
+        "-V",
+        "--visibility",
+        help="Visibility: private, organization, public",
+    ),
+    tags: str = typer.Option(
+        ...,
+        "-t",
+        "--tags",
+        help="Comma-separated tags",
+    ),
+    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 (or @file)",
+    ),
+    description: Optional[str] = typer.Option(
+        None,
+        "-d",
+        "--description",
+        help="Template description",
+    ),
+    upsert: bool = typer.Option(
+        False,
+        "--upsert",
+        help="Return existing if name exists",
+    ),
+    escape_jinja: bool = typer.Option(
+        False,
+        "--escape-jinja",
+        help="Escape Jinja syntax as literals",
+    ),
+) -> None:
+    """Create a new template.
+
+    Examples:
+        ai templates create -n my-template --type system_instruction -V private -f template.jinja2 -t "email"
+        ai templates create -n greeting --type fragment -V private -c "Hello, {{ name }}!" -t "greeting"
+        ai tpl create -n email.header --type fragment -V organization -f header.jinja2 -d "Email header" -t "email,header"
+    """
+    require_one_of(("--file", content_file), ("--content", content))
+
+    _execute_create_from_flags(
+        name=name,
+        content_type=content_type,
+        visibility=visibility,
+        content_file=content_file,
+        content=content,
+        description=description,
+        tags=tags,
+        upsert=upsert,
+        escape_jinja=escape_jinja,
+    )
+
+
+@async_command
+async def _execute_create(request: CreateTemplateRequest) -> None:
+    """Execute the template creation with the given request."""
+    async with authenticated_client() as (_config, client):
+        response = await client.create_template(request)
+
+    present_template_create_success(response)
+
+
+def _execute_create_from_flags(
+    name: str,
+    content_type: str,
+    visibility: str,
+    content_file: Optional[Path],
+    content: Optional[str],
+    description: Optional[str],
+    tags: str,
+    upsert: bool,
+    escape_jinja: bool,
+) -> None:
+    """Build and execute template creation from command flags."""
+    # Resolve @file references in content
+    try:
+        content = resolve_content(content)
+    except FileContentError as e:
+        raise typer.BadParameter(str(e))
+
+    # Validate enums
+    content_type_enum = validate_template_content_type(content_type)
+    visibility_enum = validate_visibility(visibility)
+
+    # 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 = parse_tags_required(tags)
+
+    # Build request
+    request = CreateTemplateRequest(
+        name=name,
+        content_type=content_type_enum,
+        visibility=visibility_enum,
+        initial_content=template_content,
+        tag_paths=tag_paths,
+        description=description,
+        upsert=upsert,
+        escape_jinja=escape_jinja,
+    )
+
+    _execute_create(request)

cli/commands/templates/create/presenter.py

@@ -0,0 +1,86 @@
+"""Presenter for template creation 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 CreateTemplateResponse
+
+
+def present_template_create_success(response: CreateTemplateResponse) -> None:
+    """Present successful template creation.
+
+    Args:
+        response: Template creation response from server
+    """
+    output = OutputService.get()
+
+    template = response.template
+    version = response.version
+    dependencies = response.dependencies
+
+    output.success("Template created 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)")
+
+    # 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))
+
+    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/delete/command.py

@@ -0,0 +1,47 @@
+"""Templates delete command implementation."""
+
+import typer
+
+from cli.commands.templates.delete.presenter import present_delete_result
+from cli.infrastructure.command import async_command, authenticated_client
+from cli.infrastructure.console import Confirm
+
+
+def templates_delete_command(
+    template: str = typer.Argument(
+        ...,
+        help="Template name or UUID",
+    ),
+    yes: bool = typer.Option(
+        False,
+        "-y",
+        "--yes",
+        help="Skip confirmation",
+    ),
+) -> None:
+    """Delete a template.
+
+    Permanently removes the template and all versions.
+    Templates referenced by others cannot be deleted.
+
+    Examples:
+        ai templates delete my-template
+        ai tpl delete email.welcome -y
+    """
+    _execute_delete(template_identifier=template, skip_confirm=yes)
+
+
+@async_command
+async def _execute_delete(template_identifier: str, skip_confirm: bool) -> None:
+    """Execute delete template operation."""
+    if not skip_confirm:
+        confirmed = Confirm.ask(
+            f"[yellow]Delete template '{template_identifier}'?[/yellow] This cannot be undone"
+        )
+        if not confirmed:
+            raise typer.Abort()
+
+    async with authenticated_client() as (_config, client):
+        response = await client.delete_template(template_identifier)
+
+    present_delete_result(response)

cli/commands/templates/delete/presenter.py

@@ -0,0 +1,16 @@
+"""Presenter for template delete command output."""
+
+from cli.infrastructure.output import OutputService
+from alloy_runtime_types.dtos.templates import DeleteTemplateResponse
+
+
+def present_delete_result(response: DeleteTemplateResponse) -> None:
+    """Present template deletion result.
+
+    Args:
+        response: DeleteTemplateResponse from server
+    """
+    output = OutputService.get()
+    deleted = response.deleted_template
+
+    output.success(f"Template '{deleted.name}' deleted successfully")

cli/commands/templates/get/command.py

@@ -0,0 +1,52 @@
+"""Templates get command implementation."""
+
+from typing import Optional
+
+import typer
+
+from cli.commands.templates.get.presenter import present_template_details
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def templates_get_command(
+    template: str = typer.Argument(
+        ...,
+        help="Template name or UUID",
+    ),
+    version: Optional[int] = typer.Option(
+        None,
+        "--version",
+        min=1,
+        help="Specific version number",
+    ),
+    full: bool = typer.Option(
+        False,
+        "--full",
+        help="Show full content (no truncation)",
+    ),
+    copy: bool = typer.Option(
+        False,
+        "--copy",
+        help="Copy content to clipboard",
+    ),
+) -> None:
+    """Get template details.
+
+    Examples:
+        ai templates get my-template
+        ai tpl get email.welcome --version 2
+        ai tpl get my-template --full
+        ai tpl get my-template --copy
+    """
+    _execute_get(template_identifier=template, version=version, full=full, copy=copy)
+
+
+@async_command
+async def _execute_get(
+    template_identifier: str, version: Optional[int], full: bool, copy: bool
+) -> None:
+    """Execute get template operation."""
+    async with authenticated_client() as (_config, client):
+        response = await client.get_template(template_identifier, version)
+
+    present_template_details(response, full=full, copy=copy)