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

cli/commands/models/list/command.py

@@ -0,0 +1,84 @@
+"""Models list command implementation."""
+
+from enum import Enum
+from typing import Optional
+
+import typer
+
+from cli.commands.models.list.presenter import present_models_list
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+class DisplayColumn(str, Enum):
+    """Column display options."""
+
+    MODEL = "model"
+    PROVIDER = "provider"
+
+
+def models_list_command(
+    search: Optional[str] = typer.Option(
+        None,
+        "-s",
+        "--search",
+        help="Fuzzy search terms",
+    ),
+    provider_filter: Optional[str] = typer.Option(
+        None,
+        "-p",
+        "--provider",
+        help="Filter by provider",
+    ),
+    configured_only: bool = typer.Option(
+        False,
+        "--configured",
+        help="Only show models with credentials",
+    ),
+    display: DisplayColumn | None = typer.Option(
+        None,
+        "--display",
+        help="Show only: model or provider",
+    ),
+    extra_fields: bool = typer.Option(
+        False,
+        "--extra",
+        help="Show detailed table",
+    ),
+) -> None:
+    """List available AI models.
+
+    Examples:
+        ai models list
+        ai models list -s "claude sonnet"
+        ai models list -p anthropic
+        ai models list --configured
+        ai models list --display model
+        ai models list --extra
+    """
+    _execute_list(
+        search=search,
+        provider_filter=provider_filter,
+        configured_only=configured_only,
+        display=display,
+        extra_fields=extra_fields,
+    )
+
+
+@async_command
+async def _execute_list(
+    search: Optional[str],
+    provider_filter: Optional[str],
+    configured_only: bool,
+    display: DisplayColumn | None,
+    extra_fields: bool,
+) -> None:
+    """Execute list models operation."""
+    async with authenticated_client() as (_config, client):
+        response = await client.list_models(
+            search=search,
+            provider_filter=provider_filter,
+            configured_only=configured_only,
+            limit=100,
+        )
+
+    present_models_list(response, display_column=display, extra_fields=extra_fields)

cli/commands/models/list/presenter.py

@@ -0,0 +1,114 @@
+"""Presenter for models list command output."""
+
+from typing import TYPE_CHECKING
+
+from alloy_runtime_types.dtos.models import ListModelsResponse
+
+from cli.infrastructure.output import OutputService
+from cli.infrastructure.renderers.list_renderer import ColumnConfig
+
+if TYPE_CHECKING:
+    from cli.commands.models.list.command import DisplayColumn
+
+
+def present_models_list(
+    response: ListModelsResponse,
+    *,
+    display_column: "DisplayColumn | None" = None,
+    extra_fields: bool = False,
+) -> None:
+    """Present list of models with Rich table formatting.
+
+    Args:
+        response: List models response from server
+        display_column: If set, only show that specific column. None = all columns.
+        extra_fields: If True, show detailed table with all fields. Default is simple one-line format.
+    """
+    # Import here to avoid circular import
+    from cli.commands.models.list.command import DisplayColumn
+
+    output = OutputService.get()
+
+    if not response.models:
+        output.info("No models found")
+        return
+
+    # If display_column is set, show single column
+    if display_column == DisplayColumn.PROVIDER:
+        columns = [
+            ColumnConfig(
+                source_field="provider_key",
+                header_label="Provider",
+                compact_line=1,
+                compact_style="green",
+            ),
+        ]
+    elif display_column == DisplayColumn.MODEL:
+        columns = [
+            ColumnConfig(
+                source_field="provider_model_name",
+                header_label="Model Name",
+                compact_line=1,
+                compact_style="cyan",
+            ),
+        ]
+    # If extra_fields is True, show detailed table with compact layout
+    elif extra_fields:
+        # Line 1 (primary): Provider, model name, context window - identifiers
+        # Line 2 (detail): Max output, modalities - technical details
+        columns = [
+            ColumnConfig(
+                source_field="provider_key",
+                header_label="Provider",
+                compact_line=1,
+                compact_style="green",
+            ),
+            ColumnConfig(
+                source_field="provider_model_name",
+                header_label="Model Name",
+                compact_line=1,
+                compact_style="cyan",
+            ),
+            ColumnConfig(
+                source_field="context_window",
+                header_label="Context",
+                formatter=lambda x: f"{x:,}" if x else "-",
+                align="right",
+                compact_line=1,
+                compact_style="yellow",
+            ),
+            ColumnConfig(
+                source_field="max_output_tokens",
+                header_label="Max Output",
+                formatter=lambda x: f"{x:,}" if x else "-",
+                align="right",
+                compact_line=2,
+                compact_style="dim",
+            ),
+            ColumnConfig(
+                source_field="input_modalities",
+                header_label="Input",
+                formatter=lambda x: ", ".join(sorted(x)) if x else "-",
+                compact_line=2,
+                compact_style="dim",
+            ),
+            ColumnConfig(
+                source_field="output_modalities",
+                header_label="Output",
+                formatter=lambda x: ", ".join(sorted(x)) if x else "-",
+                compact_line=2,
+                compact_style="dim",
+            ),
+        ]
+    else:
+        # Default: simple one-line format (provider/model)
+        for model in response.models:
+            output.console.print(f"{model.provider_key}/{model.provider_model_name}")
+        return
+
+    # Render table (cast needed due to list invariance)
+    output.table(
+        items=response.models,  # type: ignore[arg-type]
+        title=f"Available Models ({response.total_count})",
+        columns=columns,
+    )

cli/commands/organizations/create/command.py

@@ -0,0 +1,32 @@
+"""Organizations create command implementation."""
+
+import typer
+
+from cli.commands.organizations.create.presenter import present_create_result
+from cli.infrastructure.command import async_command, authenticated_client
+from alloy_runtime_types.dtos.organizations import CreateOrganizationRequest
+
+
+def organizations_create_command(
+    name: str = typer.Option(
+        ...,
+        "-n",
+        "--name",
+        help="Organization name",
+    ),
+) -> None:
+    """Create a new organization.
+
+    Examples:
+        ai organizations create --name "My Company"
+    """
+    _execute_create(name=name)
+
+
+@async_command
+async def _execute_create(name: str) -> None:
+    request = CreateOrganizationRequest(name=name)
+    async with authenticated_client() as (_config, client):
+        response = await client.create_organization(request)
+
+    present_create_result(response)

cli/commands/organizations/create/presenter.py

@@ -0,0 +1,9 @@
+"""Presenter for organizations create command output."""
+
+from cli.infrastructure.output import OutputService
+from alloy_runtime_types.dtos.organizations import OrganizationResponse
+
+
+def present_create_result(response: OrganizationResponse) -> None:
+    output = OutputService.get()
+    output.success(f"Created organization: {response.name}")

cli/commands/pipelines/__init__.py

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

cli/commands/pipelines/approvals/__init__.py

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

cli/commands/pipelines/approvals/decide_command.py

@@ -0,0 +1,77 @@
+"""Pipeline approval checkpoint decide command implementation."""
+
+import json
+from typing import Any, Optional
+from uuid import UUID
+
+import typer
+
+from cli.commands.flag_utils import validate_uuid
+from cli.commands.pipelines.approvals.presenter import present_approval_checkpoint
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def pipelines_approvals_decide_command(
+    execution_id: str = typer.Argument(
+        ...,
+        help="Pipeline execution UUID",
+    ),
+    approval_key: str = typer.Argument(
+        ...,
+        help="Approval checkpoint key",
+    ),
+    approve: bool = typer.Option(
+        ...,
+        "--approve/--reject",
+        help="Approve or reject the checkpoint",
+    ),
+    data: Optional[str] = typer.Option(
+        None,
+        "-d",
+        "--data",
+        help='Decision data as JSON string (e.g. \'{"reason": "looks good"}\')',
+    ),
+) -> None:
+    """Submit a decision on an approval checkpoint.
+
+    Examples:
+        ai pipelines approvals decide 123e4567... pe:123:approval:review --approve
+        ai pipelines approvals decide 123e4567... pe:123:approval:review --reject
+        ai pipelines approvals decide 123e4567... pe:123:approval:review --approve -d '{"reason": "LGTM"}'
+    """
+    e_uuid = validate_uuid(execution_id, "execution")
+
+    decision_data: dict[str, Any] | None = None
+    if data:
+        try:
+            decision_data = json.loads(data)
+        except json.JSONDecodeError as e:
+            raise typer.BadParameter(f"Invalid JSON for --data: {e}")
+        if not isinstance(decision_data, dict):
+            raise typer.BadParameter("--data must be a JSON object")
+
+    _execute_decide(
+        execution_id=e_uuid,
+        approval_key=approval_key,
+        approved=approve,
+        decision_data=decision_data,
+    )
+
+
+@async_command
+async def _execute_decide(
+    execution_id: UUID,
+    approval_key: str,
+    approved: bool,
+    decision_data: dict[str, Any] | None,
+) -> None:
+    """Execute decide approval checkpoint operation."""
+    async with authenticated_client() as (_config, client):
+        checkpoint = await client.decide_approval(
+            execution_id,
+            approval_key,
+            approved=approved,
+            decision_data=decision_data,
+        )
+
+    present_approval_checkpoint(checkpoint)

cli/commands/pipelines/approvals/get_command.py

@@ -0,0 +1,44 @@
+"""Pipeline approval checkpoint get command implementation."""
+
+from uuid import UUID
+
+import typer
+
+from cli.commands.flag_utils import validate_uuid
+from cli.commands.pipelines.approvals.presenter import (
+    present_approval_checkpoint,
+    present_approval_not_found,
+)
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def pipelines_approvals_get_command(
+    execution_id: str = typer.Argument(
+        ...,
+        help="Pipeline execution UUID",
+    ),
+    approval_key: str = typer.Argument(
+        ...,
+        help="Approval checkpoint key",
+    ),
+) -> None:
+    """Get details of an approval checkpoint.
+
+    Examples:
+        ai pipelines approvals get 123e4567... pe:123:approval:review_step
+    """
+    e_uuid = validate_uuid(execution_id, "execution")
+    _execute_get(execution_id=e_uuid, approval_key=approval_key)
+
+
+@async_command
+async def _execute_get(execution_id: UUID, approval_key: str) -> None:
+    """Execute get approval checkpoint operation."""
+    async with authenticated_client() as (_config, client):
+        checkpoint = await client.get_approval_checkpoint(execution_id, approval_key)
+
+    if checkpoint is None:
+        present_approval_not_found(str(execution_id), approval_key)
+        raise typer.Exit(code=1)
+
+    present_approval_checkpoint(checkpoint)

cli/commands/pipelines/approvals/presenter.py

@@ -0,0 +1,56 @@
+"""Presenters for pipeline approval checkpoint command output."""
+
+import json
+
+from alloy_runtime_sdk.pipeline.types import ApprovalCheckpoint
+
+from cli.infrastructure.formatting.fields import format_optional
+from cli.infrastructure.output import OutputService
+from cli.infrastructure.renderers.entity_renderer import FieldConfig
+
+
+def _format_status(status: str) -> str:
+    """Format approval status for display."""
+    return status
+
+
+def _format_approved(approved: bool | None) -> str:
+    """Format approved boolean for display."""
+    if approved is None:
+        return "(pending)"
+    return "Yes" if approved else "No"
+
+
+def present_approval_checkpoint(checkpoint: ApprovalCheckpoint) -> None:
+    """Present a single approval checkpoint with Rich formatting."""
+    output = OutputService.get()
+
+    fields = [
+        FieldConfig("id", "Checkpoint ID", str),
+        FieldConfig("pipeline_execution_id", "Execution ID", str),
+        FieldConfig("approval_key", "Approval Key"),
+        FieldConfig("status", "Status", _format_status),
+        FieldConfig("approved", "Approved", _format_approved),
+        FieldConfig(
+            "decided_by_user_id", "Decided By", lambda v: format_optional(v, str)
+        ),
+        FieldConfig("decided_at", "Decided At", format_optional),
+        FieldConfig("created_at", "Created At"),
+    ]
+
+    output.entity(checkpoint, f"Approval: {checkpoint.status}", fields)
+
+    if checkpoint.decision_data:
+        data_str = json.dumps(checkpoint.decision_data, indent=2)
+        if len(data_str) > 500:
+            data_str = data_str[:500] + "\n..."
+        output.info(f"Decision Data:\n{data_str}")
+
+
+def present_approval_not_found(execution_id: str, approval_key: str) -> None:
+    """Present a not-found message for an approval checkpoint."""
+    output = OutputService.get()
+    output.warning(
+        f"No approval checkpoint found for execution {execution_id} "
+        f"with key '{approval_key}'"
+    )

cli/commands/pipelines/costs/__init__.py

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

cli/commands/pipelines/costs/command.py

@@ -0,0 +1,57 @@
+"""Pipeline costs command implementation."""
+
+from typing import Optional
+from uuid import UUID
+
+import typer
+
+from cli.commands.flag_utils import validate_uuid
+from cli.commands.pipelines.costs.presenter import present_pipeline_costs
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def pipelines_costs_command(
+    pipeline_id: str = typer.Argument(
+        ...,
+        help="Pipeline UUID",
+    ),
+    start_date: Optional[str] = typer.Option(
+        None,
+        "--start",
+        help="Start date (ISO 8601, defaults to 30 days ago)",
+    ),
+    end_date: Optional[str] = typer.Option(
+        None,
+        "--end",
+        help="End date (ISO 8601, defaults to now)",
+    ),
+) -> None:
+    """Get cost summary for a pipeline.
+
+    Examples:
+        ai pipelines costs 123e4567-89ab...
+        ai pipelines costs 123e4567-89ab... --start 2026-01-01 --end 2026-01-31
+    """
+    pipeline_uuid = validate_uuid(pipeline_id, "pipeline")
+    _execute_costs(
+        pipeline_id=pipeline_uuid,
+        start_date=start_date,
+        end_date=end_date,
+    )
+
+
+@async_command
+async def _execute_costs(
+    pipeline_id: UUID,
+    start_date: Optional[str],
+    end_date: Optional[str],
+) -> None:
+    """Execute get pipeline costs operation."""
+    async with authenticated_client() as (_config, client):
+        response = await client.get_pipeline_costs(
+            pipeline_id,
+            start_date=start_date,
+            end_date=end_date,
+        )
+
+    present_pipeline_costs(response)

cli/commands/pipelines/costs/daily_command.py

@@ -0,0 +1,54 @@
+"""Pipeline daily costs command implementation."""
+
+from uuid import UUID
+
+import typer
+
+from cli.commands.flag_utils import validate_uuid
+from cli.commands.pipelines.costs.daily_presenter import present_pipeline_daily_costs
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def pipeline_costs_daily_command(
+    pipeline_id: str = typer.Argument(
+        ...,
+        help="Pipeline UUID",
+    ),
+    start_date: str = typer.Option(
+        ...,
+        "--from",
+        help="Start date (ISO 8601, required)",
+    ),
+    end_date: str = typer.Option(
+        ...,
+        "--to",
+        help="End date (ISO 8601, required)",
+    ),
+) -> None:
+    """Get daily cost breakdown for a pipeline.
+
+    Examples:
+        ai pipelines costs daily 123e4567-89ab... --from 2026-01-01 --to 2026-01-31
+    """
+    pipeline_uuid = validate_uuid(pipeline_id, "pipeline")
+    _execute_daily_costs(
+        pipeline_id=pipeline_uuid,
+        start_date=start_date,
+        end_date=end_date,
+    )
+
+
+@async_command
+async def _execute_daily_costs(
+    pipeline_id: UUID,
+    start_date: str,
+    end_date: str,
+) -> None:
+    async with authenticated_client() as (_config, client):
+        response = await client.get_pipeline_costs_daily(
+            pipeline_id,
+            start_date=start_date,
+            end_date=end_date,
+        )
+
+    present_pipeline_daily_costs(response)

cli/commands/pipelines/costs/daily_presenter.py

@@ -0,0 +1,59 @@
+"""Presenter for pipeline daily costs command output."""
+
+from decimal import Decimal
+
+from alloy_runtime_types.dtos.pipeline_costs import DailyCostEntry
+
+from cli.infrastructure.output import OutputService
+from cli.infrastructure.renderers.list_renderer import ColumnConfig
+
+
+def _format_cost(cost: Decimal | None) -> str:
+    if cost is None:
+        return "-"
+    return f"${cost:.4f}"
+
+
+def present_pipeline_daily_costs(entries: list[DailyCostEntry]) -> None:
+    output = OutputService.get()
+
+    if not entries:
+        output.info("No daily cost data found for the specified period")
+        return
+
+    columns = [
+        ColumnConfig(
+            source_field="date",
+            header_label="Date",
+            formatter=str,
+            compact_line=1,
+            compact_style="cyan",
+        ),
+        ColumnConfig(
+            source_field="execution_count",
+            header_label="Executions",
+            formatter=str,
+            compact_line=1,
+            compact_style="white",
+        ),
+        ColumnConfig(
+            source_field="total_cost_usd",
+            header_label="Total Cost",
+            formatter=_format_cost,
+            compact_line=1,
+            compact_style="green bold",
+        ),
+        ColumnConfig(
+            source_field="avg_cost_usd",
+            header_label="Avg Cost",
+            formatter=_format_cost,
+            compact_line=2,
+            compact_style="dim",
+        ),
+    ]
+
+    output.table(
+        items=entries,  # type: ignore[arg-type]
+        title=f"Daily Costs ({len(entries)} days)",
+        columns=columns,
+    )

cli/commands/pipelines/costs/presenter.py

@@ -0,0 +1,37 @@
+"""Presenter for pipeline costs command output."""
+
+from alloy_runtime_types.dtos.pipeline_costs import PipelineDefinitionCostSummary
+
+from cli.infrastructure.output import OutputService
+from cli.infrastructure.renderers.entity_renderer import FieldConfig
+
+
+def _format_period(response: PipelineDefinitionCostSummary) -> str:
+    """Format period dates for display."""
+    return f"{response.period_start.strftime('%Y-%m-%d')} to {response.period_end.strftime('%Y-%m-%d')}"
+
+
+def _format_cost(cost: float | None) -> str:
+    """Format cost for display."""
+    if cost is None:
+        return "-"
+    return f"${cost:.4f}"
+
+
+def present_pipeline_costs(response: PipelineDefinitionCostSummary) -> None:
+    """Present pipeline cost summary."""
+    output = OutputService.get()
+
+    fields = [
+        FieldConfig("pipeline_definition_id", "Pipeline ID", str),
+        FieldConfig("period", "Period", lambda _: _format_period(response)),
+        FieldConfig("execution_count", "Total Executions", str),
+        FieldConfig("completed_count", "Completed", str),
+        FieldConfig("failed_count", "Failed", str),
+        FieldConfig("total_cost_usd", "Total Cost", _format_cost),
+        FieldConfig("avg_cost_usd", "Avg Cost", _format_cost),
+        FieldConfig("min_cost_usd", "Min Cost", _format_cost),
+        FieldConfig("max_cost_usd", "Max Cost", _format_cost),
+    ]
+
+    output.entity(response, "Pipeline Cost Summary", fields)

cli/commands/pipelines/create/__init__.py

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