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

cli/commands/pipelines/executions/costs_by_step/presenter.py

@@ -0,0 +1,72 @@
+"""Presenter for pipeline execution costs by step command output."""
+
+from decimal import Decimal
+
+from alloy_runtime_types.dtos.pipeline_costs import StepCostBreakdown
+
+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_execution_costs_by_step(entries: list[StepCostBreakdown]) -> None:
+    output = OutputService.get()
+
+    if not entries:
+        output.info("No cost data by step found for this execution")
+        return
+
+    columns = [
+        ColumnConfig(
+            source_field="step_order",
+            header_label="Order",
+            formatter=str,
+            compact_line=1,
+            compact_style="cyan",
+        ),
+        ColumnConfig(
+            source_field="step_name",
+            header_label="Step Name",
+            compact_line=1,
+            compact_style="green",
+        ),
+        ColumnConfig(
+            source_field="execution_count",
+            header_label="Executions",
+            formatter=str,
+            compact_line=1,
+            compact_style="white",
+        ),
+        ColumnConfig(
+            source_field="llm_cost_usd",
+            header_label="LLM Cost",
+            formatter=_format_cost,
+            compact_line=2,
+            compact_style="dim",
+        ),
+        ColumnConfig(
+            source_field="rag_cost_usd",
+            header_label="RAG Cost",
+            formatter=_format_cost,
+            compact_line=2,
+            compact_style="dim",
+        ),
+        ColumnConfig(
+            source_field="total_cost_usd",
+            header_label="Total Cost",
+            formatter=_format_cost,
+            compact_line=1,
+            compact_style="green bold",
+        ),
+    ]
+
+    output.table(
+        items=entries,  # type: ignore[arg-type]
+        title=f"Costs by Step ({len(entries)} steps)",
+        columns=columns,
+    )

cli/commands/pipelines/executions/get_command.py

@@ -0,0 +1,38 @@
+"""Pipeline execution get command implementation."""
+
+from uuid import UUID
+
+import typer
+
+from cli.commands.flag_utils import validate_uuid
+from cli.commands.pipelines.executions.presenter import present_execution_detail
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def pipelines_executions_get_command(
+    pipeline_id: str = typer.Argument(
+        ...,
+        help="Pipeline UUID",
+    ),
+    execution_id: str = typer.Argument(
+        ...,
+        help="Execution UUID",
+    ),
+) -> None:
+    """Get details of a pipeline execution.
+
+    Examples:
+        ai pipelines executions get 123e4567... 456e7890...
+    """
+    p_uuid = validate_uuid(pipeline_id, "pipeline")
+    e_uuid = validate_uuid(execution_id, "execution")
+    _execute_get(pipeline_id=p_uuid, execution_id=e_uuid)
+
+
+@async_command
+async def _execute_get(pipeline_id: UUID, execution_id: UUID) -> None:
+    """Execute get execution operation."""
+    async with authenticated_client() as (_config, client):
+        response = await client.get_pipeline_execution(pipeline_id, execution_id)
+
+    present_execution_detail(response)

cli/commands/pipelines/executions/list_command.py

@@ -0,0 +1,123 @@
+"""Pipeline executions list command implementation."""
+
+import json
+from typing import Annotated, Optional
+from uuid import UUID
+
+import typer
+
+from cli.commands.flag_utils import validate_uuid
+from cli.commands.pipelines.executions.presenter import present_executions_list
+from cli.infrastructure.command import async_command, authenticated_client
+from cli.infrastructure.file_content import FileContentError, resolve_content
+
+
+def pipelines_executions_list_command(
+    pipeline_id: str = typer.Argument(
+        ...,
+        help="Pipeline UUID",
+    ),
+    status: Optional[str] = typer.Option(
+        None,
+        "--status",
+        help="Filter by status (pending, running, completed, failed)",
+    ),
+    external_id: Optional[str] = typer.Option(
+        None,
+        "--external-id",
+        help="Filter by exact external_id",
+    ),
+    search: Optional[str] = typer.Option(
+        None,
+        "-s",
+        "--search",
+        help="Fuzzy search on external_id",
+    ),
+    tag: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--tag",
+            help="Filter by tag path (repeatable, e.g., --tag pipeline.test)",
+        ),
+    ] = None,
+    metadata_filter: Optional[str] = typer.Option(
+        None,
+        "--metadata-filter",
+        help="Filter by metadata as JSON string or @file.json",
+    ),
+    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 executions for a pipeline.
+
+    Examples:
+        ai pipelines executions list 123e4567-89ab...
+        ai pipelines executions list 123e4567-89ab... --status completed
+        ai pipelines executions list 123e4567-89ab... --tag pipeline.test --tag batch.weekly
+        ai pipelines executions list 123e4567-89ab... --metadata-filter '{"env": "prod"}'
+    """
+    pipeline_uuid = validate_uuid(pipeline_id, "pipeline")
+
+    # Parse metadata_filter if provided
+    metadata_filter_str: str | None = None
+    if metadata_filter:
+        try:
+            resolved = resolve_content(metadata_filter)
+        except FileContentError as e:
+            raise typer.BadParameter(str(e))
+        if resolved:
+            try:
+                json.loads(resolved)
+            except json.JSONDecodeError as e:
+                raise typer.BadParameter(f"Invalid JSON: {e}")
+            metadata_filter_str = resolved
+
+    _execute_list(
+        pipeline_id=pipeline_uuid,
+        status=status,
+        external_id=external_id,
+        search=search,
+        tag_paths=tag,
+        metadata_filter=metadata_filter_str,
+        limit=limit,
+        offset=offset,
+    )
+
+
+@async_command
+async def _execute_list(
+    pipeline_id: UUID,
+    status: Optional[str],
+    external_id: Optional[str],
+    search: Optional[str],
+    tag_paths: Optional[list[str]],
+    metadata_filter: Optional[str],
+    limit: int,
+    offset: int,
+) -> None:
+    """Execute list executions operation."""
+    async with authenticated_client() as (_config, client):
+        response = await client.list_pipeline_executions(
+            pipeline_id,
+            status=status,
+            external_id=external_id,
+            search=search,
+            tag_paths=tag_paths,
+            metadata_filter=metadata_filter,
+            limit=limit,
+            offset=offset,
+        )
+
+    present_executions_list(response)

cli/commands/pipelines/executions/presenter.py

@@ -0,0 +1,131 @@
+"""Presenters for pipeline executions command output."""
+
+import json
+from typing import cast
+
+from pydantic import BaseModel
+
+from alloy_runtime_types.dtos.pipeline import (
+    GetPipelineExecutionResponse,
+    ListPipelineExecutionsResponse,
+    PipelineExecutionDetail,
+)
+
+from cli.infrastructure.formatting.fields import format_datetime, format_optional
+from cli.infrastructure.output import OutputService
+from cli.infrastructure.renderers.entity_renderer import FieldConfig
+from cli.infrastructure.renderers.list_renderer import ColumnConfig
+
+
+def _format_status(status: str) -> str:
+    """Format status with color hints."""
+    return status
+
+
+def _format_duration(duration_ms: int | None) -> str:
+    """Format duration in human-readable format."""
+    if not duration_ms:
+        return "-"
+    if duration_ms < 1000:
+        return f"{duration_ms}ms"
+    return f"{duration_ms / 1000:.1f}s"
+
+
+def present_executions_list(response: ListPipelineExecutionsResponse) -> None:
+    """Present list of executions with Rich table formatting."""
+    output = OutputService.get()
+
+    if not response.executions:
+        output.info("No executions found")
+        return
+
+    columns = [
+        ColumnConfig(
+            source_field="id",
+            header_label="ID",
+            compact_line=1,
+            compact_style="cyan",
+        ),
+        ColumnConfig(
+            source_field="status",
+            header_label="Status",
+            formatter=_format_status,
+            compact_line=1,
+            compact_style="yellow",
+        ),
+        ColumnConfig(
+            source_field="total_duration_ms",
+            header_label="Duration",
+            formatter=_format_duration,
+            compact_line=1,
+            compact_style="green",
+        ),
+        ColumnConfig(
+            source_field="queued_at",
+            header_label="Queued",
+            formatter=lambda x: x.strftime("%Y-%m-%d %H:%M") if x else "-",
+            compact_line=2,
+            compact_style="blue",
+        ),
+        ColumnConfig(
+            source_field="external_id",
+            header_label="External ID",
+            formatter=lambda x: x or "-",
+            compact_line=2,
+            compact_style="dim",
+        ),
+    ]
+
+    output.table(
+        items=cast(list[BaseModel], response.executions),
+        title=f"Executions ({response.total})",
+        columns=columns,
+    )
+
+
+def _format_tags_from_execution(execution: PipelineExecutionDetail) -> str:
+    """Format tags for display."""
+    if not execution.tags:
+        return "(none)"
+    return ", ".join(t.tag_path for t in execution.tags)
+
+
+def present_execution_detail(response: GetPipelineExecutionResponse) -> None:
+    """Present execution details with Rich formatting."""
+    output = OutputService.get()
+    execution = response.execution
+
+    fields = [
+        FieldConfig("id", "Execution ID", str),
+        FieldConfig("pipeline_definition_id", "Pipeline ID", str),
+        FieldConfig("status", "Status"),
+        FieldConfig("external_id", "External ID", format_optional),
+        FieldConfig("queued_at", "Queued At", format_datetime),
+        FieldConfig(
+            "started_at", "Started At", lambda v: format_optional(v, format_datetime)
+        ),
+        FieldConfig(
+            "completed_at",
+            "Completed At",
+            lambda v: format_optional(v, format_datetime),
+        ),
+        FieldConfig("total_duration_ms", "Duration", lambda v: _format_duration(v)),
+        FieldConfig("error_message", "Error", format_optional),
+        FieldConfig("tags", "Tags", lambda _: _format_tags_from_execution(execution)),
+    ]
+
+    output.entity(execution, f"Execution: {execution.status}", fields)
+
+    # Show result data if present
+    if execution.result_data:
+        result_str = json.dumps(execution.result_data, indent=2)
+        if len(result_str) > 1000:
+            result_str = result_str[:1000] + "\n..."
+        output.info(f"Result:\n{result_str}")
+
+    # Show stdout/stderr if present
+    if execution.execution_stdout:
+        output.info(f"Stdout:\n{execution.execution_stdout[:500]}")
+
+    if execution.execution_stderr:
+        output.warning(f"Stderr:\n{execution.execution_stderr[:500]}")

cli/commands/pipelines/executions/rerun_command.py

@@ -0,0 +1,41 @@
+"""Pipeline execution rerun command implementation."""
+
+from uuid import UUID
+
+import typer
+
+from cli.commands.flag_utils import validate_uuid
+from cli.commands.pipelines.execute.presenter import present_execution_result
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def pipelines_executions_rerun_command(
+    pipeline_id: str = typer.Argument(
+        ...,
+        help="Pipeline UUID",
+    ),
+    execution_id: str = typer.Argument(
+        ...,
+        help="Execution UUID to rerun",
+    ),
+) -> None:
+    """Re-run a failed or paused pipeline execution.
+
+    Completed steps are automatically skipped via idempotent cache-hits.
+    Use after approving a checkpoint to resume pipeline execution.
+
+    Examples:
+        ai pipelines executions rerun 123e4567... 456e7890...
+    """
+    p_uuid = validate_uuid(pipeline_id, "pipeline")
+    e_uuid = validate_uuid(execution_id, "execution")
+    _execute_rerun(pipeline_id=p_uuid, execution_id=e_uuid)
+
+
+@async_command
+async def _execute_rerun(pipeline_id: UUID, execution_id: UUID) -> None:
+    """Execute rerun pipeline operation."""
+    async with authenticated_client() as (_config, client):
+        response = await client.rerun_pipeline_execution(pipeline_id, execution_id)
+
+    present_execution_result(response)

cli/commands/pipelines/executions/update/__init__.py

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

cli/commands/pipelines/executions/update/command.py

@@ -0,0 +1,110 @@
+"""Pipeline execution update command implementation."""
+
+import json
+from typing import Any, Optional, cast
+from uuid import UUID
+
+import typer
+
+from alloy_runtime_types.dtos.pipeline import UpdatePipelineExecutionRequest
+
+from cli.commands.flag_utils import (
+    parse_tags,
+    require_exclusive,
+    require_update_flags,
+    validate_uuid,
+)
+from cli.commands.pipelines.executions.update.presenter import present_execution_update
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def pipeline_execution_update_command(
+    pipeline_id: str = typer.Argument(
+        ...,
+        help="Pipeline UUID",
+    ),
+    execution_id: str = typer.Argument(
+        ...,
+        help="Execution UUID",
+    ),
+    metadata: Optional[str] = typer.Option(
+        None,
+        "--metadata",
+        help='Replace metadata with JSON (e.g. \'{"key": "value"}\')',
+    ),
+    metadata_merge: Optional[str] = typer.Option(
+        None,
+        "--metadata-merge",
+        help="Merge these JSON keys into existing metadata",
+    ),
+    tags: Optional[str] = typer.Option(
+        None,
+        "--tags",
+        help="Replace tags (comma-separated, e.g. 'reviewed,approved')",
+    ),
+) -> None:
+    """Update a pipeline execution's metadata or tags.
+
+    Examples:
+        ai pipelines executions update 123e... 456e... --metadata '{"status": "reviewed"}'
+        ai pipelines executions update 123e... 456e... --metadata-merge '{"step": 2}'
+        ai pipelines executions update 123e... 456e... --tags reviewed,approved
+    """
+    pipeline_uuid = validate_uuid(pipeline_id, "pipeline")
+    execution_uuid = validate_uuid(execution_id, "execution")
+
+    require_exclusive(
+        ("--metadata", metadata),
+        ("--metadata-merge", metadata_merge),
+    )
+
+    require_update_flags(
+        ("--metadata", metadata),
+        ("--metadata-merge", metadata_merge),
+        ("--tags", tags),
+    )
+
+    parsed_metadata = _parse_json(metadata) if metadata else None
+    parsed_metadata_merge = _parse_json(metadata_merge) if metadata_merge else None
+    parsed_tags = parse_tags(tags) if tags else None
+
+    _execute_update(
+        pipeline_id=pipeline_uuid,
+        execution_id=execution_uuid,
+        metadata=parsed_metadata,
+        metadata_merge=parsed_metadata_merge,
+        tags=parsed_tags,
+    )
+
+
+def _parse_json(value: str) -> dict[str, Any]:
+    try:
+        result = json.loads(value)
+        if not isinstance(result, dict):
+            raise typer.BadParameter("JSON must be an object")
+        return cast(dict[str, Any], result)
+    except json.JSONDecodeError as e:
+        raise typer.BadParameter(f"Invalid JSON: {e}")
+
+
+@async_command
+async def _execute_update(
+    pipeline_id: UUID,
+    execution_id: UUID,
+    metadata: dict[str, Any] | None,
+    metadata_merge: dict[str, Any] | None,
+    tags: list[str] | None,
+) -> None:
+    async with authenticated_client() as (_config, client):
+        request = UpdatePipelineExecutionRequest(
+            metadata=metadata,
+            metadata_merge=metadata_merge,
+            tags=tags,
+        )
+        response = await client.update_pipeline_execution(
+            pipeline_id,
+            execution_id,
+            request,
+        )
+
+    present_execution_update(response)

cli/commands/pipelines/executions/update/presenter.py

@@ -0,0 +1,28 @@
+"""Presenter for pipeline execution update command output."""
+
+from alloy_runtime_types.dtos.pipeline import UpdatePipelineExecutionResponse
+
+from cli.infrastructure.output import OutputService
+from cli.infrastructure.renderers.entity_renderer import FieldConfig
+
+
+def present_execution_update(response: UpdatePipelineExecutionResponse) -> None:
+    output = OutputService.get()
+    execution = response.execution
+
+    fields = [
+        FieldConfig("id", "Execution ID", str),
+        FieldConfig("pipeline_definition_id", "Pipeline ID", str),
+        FieldConfig("status", "Status"),
+    ]
+
+    output.entity(execution, "Execution Updated", fields)
+
+    if execution.tags:
+        tag_paths = ", ".join(t.tag_path for t in execution.tags)
+        output.info(f"Tags: {tag_paths}")
+    else:
+        output.info("Tags: (none)")
+
+    if execution.metadata:
+        output.info(f"Metadata: {execution.metadata}")

cli/commands/pipelines/get/__init__.py

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

cli/commands/pipelines/get/command.py

@@ -0,0 +1,33 @@
+"""Pipeline get command implementation."""
+
+from uuid import UUID
+
+import typer
+
+from cli.commands.flag_utils import validate_uuid
+from cli.commands.pipelines.get.presenter import present_pipeline
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def pipelines_get_command(
+    pipeline_id: str = typer.Argument(
+        ...,
+        help="Pipeline UUID",
+    ),
+) -> None:
+    """Get details of a pipeline.
+
+    Examples:
+        ai pipelines get 123e4567-89ab-cdef-0123-456789abcdef
+    """
+    pipeline_uuid = validate_uuid(pipeline_id, "pipeline")
+    _execute_get(pipeline_id=pipeline_uuid)
+
+
+@async_command
+async def _execute_get(pipeline_id: UUID) -> None:
+    """Execute get pipeline operation."""
+    async with authenticated_client() as (_config, client):
+        response = await client.get_pipeline(pipeline_id)
+
+    present_pipeline(response)

cli/commands/pipelines/get/presenter.py

@@ -0,0 +1,48 @@
+"""Presenter for pipeline get command output."""
+
+import json
+from typing import Any
+
+from rich.panel import Panel
+from rich.syntax import Syntax
+
+from alloy_runtime_types.dtos.pipeline import GetPipelineResponse
+
+from cli.infrastructure.formatting.fields import format_datetime, format_optional
+from cli.infrastructure.output import OutputService
+from cli.infrastructure.renderers.entity_renderer import FieldConfig
+
+
+def _format_input_schema(schema: dict[str, Any] | None) -> str:
+    """Format input schema for display."""
+    if not schema:
+        return "(none)"
+    schema_str = json.dumps(schema, indent=2)
+    return schema_str[:100] + "..." if len(schema_str) > 100 else schema_str
+
+
+def present_pipeline(response: GetPipelineResponse) -> None:
+    """Present pipeline details with Rich formatting."""
+    output = OutputService.get()
+
+    fields = [
+        FieldConfig("id", "ID", str),
+        FieldConfig("name", "Name"),
+        FieldConfig("description", "Description", format_optional),
+        FieldConfig("is_public", "Public", lambda v: "Yes" if v else "No"),
+        FieldConfig("created_at", "Created", format_datetime),
+        FieldConfig("updated_at", "Updated", format_datetime),
+        FieldConfig("input_schema", "Input Schema", _format_input_schema),
+    ]
+
+    output.entity(response, f"Pipeline: {response.name}", fields)
+
+    # Show module content if available (only for owners)
+    if response.module_content:
+        syntax = Syntax(
+            response.module_content,
+            "python",
+            theme="monokai",
+            line_numbers=True,
+        )
+        output.console.print(Panel(syntax, title="Module Content"))

cli/commands/pipelines/list/__init__.py

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

cli/commands/pipelines/list/command.py

@@ -0,0 +1,53 @@
+"""Pipelines list command implementation."""
+
+from typing import Optional
+
+import typer
+
+from cli.commands.pipelines.list.presenter import present_pipelines_list
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def pipelines_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 pipelines accessible to you.
+
+    Examples:
+        ai pipelines list
+        ai pipelines list -s "content"
+        ai pipelines 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 pipelines operation."""
+    async with authenticated_client() as (_config, client):
+        response = await client.list_pipelines(
+            search=search,
+            limit=limit,
+            offset=offset,
+        )
+
+    present_pipelines_list(response)