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

cli/commands/templates/version/presenter.py

@@ -0,0 +1,100 @@
+"""Presenter for template version 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 CreateTemplateVersionResponse
+
+
+def present_version_create_success(response: CreateTemplateVersionResponse) -> None:
+    """Present successful template version creation.
+
+    Args:
+        response: Template version creation response from server
+    """
+    output = OutputService.get()
+
+    template = response.template
+    version = response.version
+    dependencies = response.dependencies
+
+    output.success(f"Template version {version.version} 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("Template 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("", "")  # Spacer
+    table.add_row("New Version", str(version.version))
+    table.add_row("Version ID", format_uuid(version.id, short=True))
+    table.add_row("Is Latest", "Yes" if version.is_latest else "No")
+    table.add_row("Content Length", f"{len(version.content)} chars")
+
+    # Required 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)")
+
+    # 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("", "")  # Spacer
+    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("Version Created At", format_datetime(version.created_at))
+
+    panel = Panel(
+        table,
+        title=f"Template Version: {template.name} v{version.version}",
+        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/tool_configs/create/command.py

@@ -0,0 +1,118 @@
+"""Tool config create command implementation."""
+
+import json
+from typing import Any, Optional, cast
+
+import typer
+
+from cli.commands.flag_utils import validate_scope
+from cli.commands.tool_configs.create.presenter import (
+    present_tool_config_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.tool_configs import CreateToolConfigRequest
+from alloy_runtime_types.enums.ownership_scope import OwnershipScope
+
+
+def tool_configs_create_command(
+    name: str = typer.Option(
+        ...,
+        "-n",
+        "--name",
+        help="Human-readable name for this tool config",
+    ),
+    tool_id: str = typer.Option(
+        ...,
+        "--tool-id",
+        help="Tool implementation ID (e.g., 'rag_search', 'web_search')",
+    ),
+    config: str = typer.Option(
+        ...,
+        "-c",
+        "--config",
+        help="Tool configuration as JSON (or @file.json to read from file)",
+    ),
+    description: Optional[str] = typer.Option(
+        None,
+        "-d",
+        "--description",
+        help="Optional description of what this config is for",
+    ),
+    scope: Optional[str] = typer.Option(
+        None,
+        "--scope",
+        help="Scope: user (default), organization, global",
+    ),
+) -> None:
+    """Create a reusable tool configuration.
+
+    Tool configs store validated configurations that can be referenced by multiple
+    agents, eliminating duplication.
+
+    Examples:
+        ai tool-configs create -n "RAG with HyDE" --tool-id rag_search -c '{"top_k": 10}'
+        ai tool-configs create -n "Web Search" --tool-id web_search -c @config.json
+        ai tc create -n "Search" --tool-id rag_search -c '{}' --scope organization
+    """
+    _execute_create_from_flags(
+        name=name,
+        tool_id=tool_id,
+        config=config,
+        description=description,
+        scope=scope,
+    )
+
+
+@async_command
+async def _execute_create(request: CreateToolConfigRequest) -> None:
+    """Execute the tool config creation with the given request."""
+    async with authenticated_client() as (_config, client):
+        response = await client.create_tool_config(request)
+
+    present_tool_config_create_success(response)
+
+
+def _execute_create_from_flags(
+    name: str,
+    tool_id: str,
+    config: str,
+    description: Optional[str],
+    scope: Optional[str],
+) -> None:
+    """Build and execute tool config creation from command flags."""
+    # Resolve @file reference for config
+    try:
+        config_content = resolve_content(config)
+    except FileContentError as e:
+        raise typer.BadParameter(str(e))
+
+    if not config_content:
+        raise typer.BadParameter("Config cannot be empty")
+
+    # Parse config as JSON
+    try:
+        config_dict_raw = json.loads(config_content)
+    except json.JSONDecodeError as e:
+        raise typer.BadParameter(f"Invalid JSON in config: {e}")
+
+    if not isinstance(config_dict_raw, dict):
+        raise typer.BadParameter("Config must be a JSON object")
+
+    config_dict = cast(dict[str, Any], config_dict_raw)
+
+    # Parse scope
+    ownership_scope = OwnershipScope.USER
+    if scope:
+        ownership_scope = validate_scope(scope)
+
+    # Build request
+    request = CreateToolConfigRequest(
+        name=name,
+        tool_id=tool_id,
+        config=config_dict,
+        description=description,
+        scope=ownership_scope,
+    )
+
+    _execute_create(request)

cli/commands/tool_configs/create/presenter.py

@@ -0,0 +1,53 @@
+"""Presenter for tool config creation output."""
+
+import json
+
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.table import Table
+
+from cli.infrastructure.formatting.fields import (
+    format_optional,
+    format_uuid,
+)
+from cli.infrastructure.output import OutputService
+from alloy_runtime_types.dtos.tool_configs import CreateToolConfigResponse
+
+
+def present_tool_config_create_success(response: CreateToolConfigResponse) -> None:
+    """Present successful tool config creation.
+
+    Args:
+        response: Tool config creation response from server
+    """
+    output = OutputService.get()
+
+    output.success("Tool config created successfully")
+
+    # Build a simple table for entity display
+    table = Table(show_header=False, box=None, padding=(0, 1))
+    table.add_column("Field", style="dim")
+    table.add_column("Value")
+
+    table.add_row("ID", format_uuid(response.id, short=False))
+    table.add_row("Slug", response.slug)
+    table.add_row("Name", response.name)
+    table.add_row("Tool ID", response.tool_id)
+    table.add_row("Description", format_optional(response.description))
+
+    # Format ownership
+    if response.user_id:
+        table.add_row("Scope", "User")
+    elif response.organization_id:
+        table.add_row("Scope", "Organization")
+    else:
+        table.add_row("Scope", "Global")
+
+    panel = Panel(table, title=f"Tool Config: {response.name}", border_style="green")
+    output.console.print(panel)
+
+    # Display config as syntax-highlighted JSON
+    config_json = json.dumps(response.config, indent=2)
+    syntax = Syntax(config_json, "json", theme="monokai", word_wrap=True)
+    config_panel = Panel(syntax, title="Configuration", border_style="blue")
+    output.console.print(config_panel)

cli/commands/tool_configs/delete/command.py

@@ -0,0 +1,47 @@
+"""Tool config delete command implementation."""
+
+import typer
+
+from cli.commands.tool_configs.delete.presenter import present_tool_config_delete_result
+from cli.infrastructure.command import async_command, authenticated_client
+from cli.infrastructure.console import Confirm
+
+
+def tool_configs_delete_command(
+    identifier: str = typer.Argument(
+        ...,
+        help="Tool config UUID or slug",
+    ),
+    yes: bool = typer.Option(
+        False,
+        "-y",
+        "--yes",
+        help="Skip confirmation",
+    ),
+) -> None:
+    """Delete a tool config.
+
+    Deletion fails if the tool config is currently referenced by any agent.
+
+    Examples:
+        ai tool-configs delete my-config
+        ai tool-configs delete 550e8400-e29b-41d4-a716-446655440000 -y
+        ai tc delete my-config -y
+    """
+    _execute_delete(identifier=identifier, skip_confirm=yes)
+
+
+@async_command
+async def _execute_delete(identifier: str, skip_confirm: bool) -> None:
+    """Execute delete tool config operation."""
+    if not skip_confirm:
+        confirmed = Confirm.ask(
+            f"[yellow]Delete tool config '{identifier}'?[/yellow] This cannot be undone"
+        )
+        if not confirmed:
+            raise typer.Abort()
+
+    async with authenticated_client() as (_config, client):
+        response = await client.delete_tool_config(identifier)
+
+    present_tool_config_delete_result(response)

cli/commands/tool_configs/delete/presenter.py

@@ -0,0 +1,18 @@
+"""Presenter for tool config delete command output."""
+
+from cli.infrastructure.output import OutputService
+from alloy_runtime_types.dtos.tool_configs import DeleteToolConfigResponse
+
+
+def present_tool_config_delete_result(response: DeleteToolConfigResponse) -> None:
+    """Present tool config deletion result.
+
+    Args:
+        response: DeleteToolConfigResponse from server
+    """
+    output = OutputService.get()
+
+    output.success(
+        f"Tool config '{response.deleted_tool_config.name}' "
+        f"(slug: {response.deleted_tool_config.slug}) deleted successfully"
+    )

cli/commands/tool_configs/get/command.py

@@ -0,0 +1,31 @@
+"""Tool config get command implementation."""
+
+import typer
+
+from cli.commands.tool_configs.get.presenter import present_tool_config_details
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def tool_configs_get_command(
+    identifier: str = typer.Argument(
+        ...,
+        help="Tool config UUID or slug",
+    ),
+) -> None:
+    """Get tool config details.
+
+    Examples:
+        ai tool-configs get rag-with-hyde
+        ai tool-configs get 550e8400-e29b-41d4-a716-446655440000
+        ai tc get my-search-config
+    """
+    _execute_get(identifier=identifier)
+
+
+@async_command
+async def _execute_get(identifier: str) -> None:
+    """Execute get tool config operation."""
+    async with authenticated_client() as (_config, client):
+        response = await client.get_tool_config(identifier)
+
+    present_tool_config_details(response)

cli/commands/tool_configs/get/presenter.py

@@ -0,0 +1,62 @@
+"""Presenter for tool config get command output."""
+
+import json
+
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.table import Table
+
+from cli.infrastructure.formatting.fields import (
+    format_datetime,
+    format_optional,
+    format_uuid,
+)
+from cli.infrastructure.output import OutputService
+from alloy_runtime_types.dtos.tool_configs import GetToolConfigResponse
+
+
+def present_tool_config_details(response: GetToolConfigResponse) -> None:
+    """Present tool config details with Rich formatting.
+
+    Args:
+        response: GetToolConfigResponse from server
+    """
+    output = OutputService.get()
+
+    table = Table(show_header=False, box=None, padding=(0, 1))
+    table.add_column("Field", style="dim")
+    table.add_column("Value")
+
+    table.add_row("ID", format_uuid(response.id, short=False))
+    table.add_row("Slug", response.slug)
+    table.add_row("Name", response.name)
+    table.add_row("Tool ID", response.tool_id)
+    table.add_row("Description", format_optional(response.description))
+
+    # Format ownership
+    if response.user_id:
+        table.add_row("Scope", "User")
+        table.add_row("User ID", format_uuid(response.user_id, short=True))
+    elif response.organization_id:
+        table.add_row("Scope", "Organization")
+        table.add_row(
+            "Organization ID", format_uuid(response.organization_id, short=True)
+        )
+    else:
+        table.add_row("Scope", "Global")
+
+    table.add_row("Created At", format_datetime(response.created_at))
+    table.add_row("Updated At", format_datetime(response.updated_at))
+
+    panel = Panel(
+        table,
+        title=f"Tool Config: {response.name}",
+        border_style="green",
+    )
+    output.console.print(panel)
+
+    # Display config as syntax-highlighted JSON
+    config_json = json.dumps(response.config, indent=2)
+    syntax = Syntax(config_json, "json", theme="monokai", word_wrap=True)
+    config_panel = Panel(syntax, title="Configuration", border_style="blue")
+    output.console.print(config_panel)

cli/commands/tool_configs/list/command.py

@@ -0,0 +1,59 @@
+"""Tool configs list command implementation."""
+
+from typing import Optional
+
+import typer
+
+from cli.commands.tool_configs.list.presenter import present_tool_configs_list
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def tool_configs_list_command(
+    search: Optional[str] = typer.Option(
+        None,
+        "-s",
+        "--search",
+        help="Fuzzy search by name or description",
+    ),
+    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 tool configs accessible to you.
+
+    Shows tool configs owned by you, your organization, or global configs.
+
+    Examples:
+        ai tool-configs list
+        ai tool-configs list -s "rag"
+        ai tc list -l 20
+    """
+    _execute_list(search=search, limit=limit, offset=offset)
+
+
+@async_command
+async def _execute_list(
+    search: Optional[str],
+    limit: int,
+    offset: int,
+) -> None:
+    """Execute list tool configs operation."""
+    async with authenticated_client() as (_config, client):
+        response = await client.list_tool_configs(
+            search=search,
+            limit=limit,
+            offset=offset,
+        )
+
+    present_tool_configs_list(response)

cli/commands/tool_configs/list/presenter.py

@@ -0,0 +1,60 @@
+"""Presenter for tool configs list command output."""
+
+from alloy_runtime_types.dtos.tool_configs import ListToolConfigsResponse
+
+from cli.infrastructure.output import OutputService
+from cli.infrastructure.renderers.list_renderer import ColumnConfig
+
+
+def present_tool_configs_list(response: ListToolConfigsResponse) -> None:
+    """Present list of tool configs with Rich table formatting.
+
+    Args:
+        response: List tool configs response from server
+    """
+    output = OutputService.get()
+
+    if not response.tool_configs:
+        output.info("No tool configs found")
+        return
+
+    columns = [
+        ColumnConfig(
+            source_field="slug",
+            header_label="Slug",
+            compact_line=1,
+            compact_style="cyan",
+        ),
+        ColumnConfig(
+            source_field="tool_id",
+            header_label="Tool",
+            compact_line=1,
+            compact_style="green",
+        ),
+        ColumnConfig(
+            source_field="updated_at",
+            header_label="Updated",
+            formatter=lambda x: x.strftime("%Y-%m-%d") if x else "-",
+            compact_line=1,
+            compact_style="dim",
+        ),
+        ColumnConfig(
+            source_field="name",
+            header_label="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.tool_configs,  # type: ignore[arg-type]
+        title=f"Tool Configs ({response.total})",
+        columns=columns,
+    )