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

cli/commands/pipelines/create/command.py

@@ -0,0 +1,103 @@
+"""Pipeline create command implementation."""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from cli.commands.pipelines.create.presenter import present_pipeline_create_success
+from cli.infrastructure.command import async_command, authenticated_client
+from alloy_runtime_types.dtos.pipeline import CreatePipelineRequest
+
+
+def pipelines_create_command(
+    name: str = typer.Option(
+        ...,
+        "--name",
+        "-n",
+        help="Pipeline name",
+    ),
+    description: Optional[str] = typer.Option(
+        None,
+        "--description",
+        "-d",
+        help="Pipeline description",
+    ),
+    file: Path = typer.Option(
+        ...,
+        "--file",
+        "-f",
+        help="Python file containing @pipeline decorated function",
+        exists=True,
+        readable=True,
+    ),
+    function_name: Optional[str] = typer.Option(
+        None,
+        "--function-name",
+        help="Name of the @pipeline function to run (uses first/only if not specified)",
+    ),
+    public: bool = typer.Option(
+        False,
+        "--public/--no-public",
+        help="Make pipeline publicly accessible",
+    ),
+) -> None:
+    """Create a new pipeline from a Python file.
+
+    The file must contain a @pipeline decorated function.
+
+    Examples:
+        ai pipelines create --name my-pipeline --file pipeline.py
+        ai pipelines create -n my-pipeline -f pipeline.py --public
+        ai pipelines create -n my-pipeline -f pipeline.py --function-name main_pipeline
+    """
+    _validate_file_extension(file)
+    _execute_create(
+        name=name,
+        description=description,
+        file=file,
+        function_name=function_name,
+        public=public,
+    )
+
+
+def _validate_file_extension(file: Path) -> None:
+    """Validate file has .py extension."""
+    if file.suffix != ".py":
+        raise typer.BadParameter(
+            f"File must have .py extension, got: {file.suffix}",
+            param_hint="--file",
+        )
+
+
+def _execute_create(
+    name: str,
+    description: Optional[str],
+    file: Path,
+    function_name: Optional[str],
+    public: bool,
+) -> None:
+    """Build and execute pipeline creation from command flags."""
+    module_content = file.read_text()
+
+    if not module_content.strip():
+        raise typer.BadParameter("Pipeline file cannot be empty", param_hint="--file")
+
+    request = CreatePipelineRequest(
+        name=name,
+        description=description,
+        module_content=module_content,
+        pipeline_function_name=function_name,
+        is_public=public,
+    )
+
+    _create_pipeline(request)
+
+
+@async_command
+async def _create_pipeline(request: CreatePipelineRequest) -> None:
+    """Create pipeline via API."""
+    async with authenticated_client() as (_config, client):
+        response = await client.create_pipeline(request)
+
+    present_pipeline_create_success(response)

cli/commands/pipelines/create/presenter.py

@@ -0,0 +1,22 @@
+"""Presenter for pipeline create command output."""
+
+from alloy_runtime_types.dtos.pipeline import CreatePipelineResponse
+
+from cli.infrastructure.formatting.fields import format_datetime
+from cli.infrastructure.output import OutputService
+from cli.infrastructure.renderers.entity_renderer import FieldConfig
+
+
+def present_pipeline_create_success(response: CreatePipelineResponse) -> None:
+    """Present pipeline creation success with Rich formatting."""
+    output = OutputService.get()
+
+    fields = [
+        FieldConfig("id", "ID", str),
+        FieldConfig("name", "Name"),
+        FieldConfig("description", "Description", lambda v: v or "(none)"),
+        FieldConfig("is_public", "Public", lambda v: "Yes" if v else "No"),
+        FieldConfig("created_at", "Created", format_datetime),
+    ]
+
+    output.entity(response, f"Pipeline Created: {response.name}", fields)

cli/commands/pipelines/env_vars/__init__.py

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

cli/commands/pipelines/env_vars/command.py

@@ -0,0 +1,51 @@
+from uuid import UUID
+from typing import Annotated
+
+import typer
+
+from cli.commands.flag_utils import validate_uuid
+from cli.commands.pipelines.env_vars.presenter import present_set_env_vars_result
+from cli.infrastructure.command import async_command, authenticated_client
+from cli.infrastructure.kv_parser import parse_kv_pairs
+
+from alloy_runtime_types.dtos.pipeline import SetPipelineEnvVarsRequest
+
+
+def pipelines_env_vars_command(
+    pipeline_id: str = typer.Argument(
+        ...,
+        help="Pipeline UUID",
+    ),
+    env: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--env",
+            "-e",
+            help="Environment variable in KEY=VALUE format (repeatable). Pass no values to clear all.",
+        ),
+    ] = None,
+) -> None:
+    """Set environment variables on a pipeline.
+
+    Environment variables are encrypted at rest and injected into pipeline
+    executions. They can be overridden at execution time.
+
+    Examples:
+        ai pipelines env-vars 123e4567... --env API_KEY=secret
+        ai pipelines env-vars 123e4567... -e KEY1=val1 -e KEY2=val2
+        ai pipelines env-vars 123e4567... --env PORT:=8080
+        ai pipelines env-vars 123e4567...
+    """
+    pipeline_uuid = validate_uuid(pipeline_id, "pipeline")
+    env_vars = parse_kv_pairs(env)
+
+    _execute_set(pipeline_id=pipeline_uuid, env_vars=env_vars)
+
+
+@async_command
+async def _execute_set(pipeline_id: UUID, env_vars: dict[str, str]) -> None:
+    async with authenticated_client() as (_config, client):
+        request = SetPipelineEnvVarsRequest(env_vars=env_vars)
+        response = await client.set_pipeline_env_vars(pipeline_id, request)
+
+    present_set_env_vars_result(response)

cli/commands/pipelines/env_vars/presenter.py

@@ -0,0 +1,16 @@
+from alloy_runtime_types.dtos.pipeline import SetPipelineEnvVarsResponse
+
+from cli.infrastructure.output import OutputService
+
+
+def present_set_env_vars_result(response: SetPipelineEnvVarsResponse) -> None:
+    output = OutputService.get()
+
+    if not response.env_var_keys:
+        output.success(f"Cleared all env vars for pipeline {response.pipeline_id}")
+        return
+
+    output.info(f"Set env vars for pipeline {response.pipeline_id}:")
+    for key in response.env_var_keys:
+        masked = response.masked_values.get(key, "***")
+        output.info(f"  {key}: {masked}")

cli/commands/pipelines/execute/__init__.py

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

cli/commands/pipelines/execute/command.py

@@ -0,0 +1,142 @@
+"""Pipeline execute command implementation."""
+
+import json
+from typing import Annotated, Any, Optional, cast
+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
+from cli.infrastructure.file_content import FileContentError, resolve_content
+from cli.infrastructure.kv_parser import parse_kv_pairs
+
+from alloy_runtime_types.dtos.pipeline import ExecutePipelineRequest
+
+
+def pipelines_execute_command(
+    pipeline_id: str = typer.Argument(
+        ...,
+        help="Pipeline UUID",
+    ),
+    config: Optional[str] = typer.Option(
+        None,
+        "-c",
+        "--config",
+        help="Pipeline config as JSON string or @file.json",
+    ),
+    timeout: Optional[int] = typer.Option(
+        None,
+        "-t",
+        "--timeout",
+        help="Execution timeout in seconds",
+    ),
+    external_id: Optional[str] = typer.Option(
+        None,
+        "--external-id",
+        help="External identifier for tracking",
+    ),
+    tags: Optional[str] = typer.Option(
+        None,
+        "--tags",
+        help="Comma-separated tag paths",
+    ),
+    env: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--env",
+            "-e",
+            help="Environment variable in KEY=VALUE format (repeatable)",
+        ),
+    ] = None,
+    metadata: Optional[str] = typer.Option(
+        None,
+        "--metadata",
+        help="Metadata as JSON string or @file.json",
+    ),
+) -> None:
+    """Execute a pipeline with optional configuration.
+
+    Examples:
+        ai pipelines execute 123e4567-89ab... -c '{"topic": "AI"}'
+        ai pipelines execute 123e4567-89ab... -c @config.json
+        ai pipelines execute 123e4567-89ab... --timeout 300
+        ai pipelines execute 123e4567-89ab... -e API_KEY=secret -e REGION=us-west
+        ai pipelines execute 123e4567-89ab... --metadata '{"run_id": "abc123"}'
+    """
+    pipeline_uuid = validate_uuid(pipeline_id, "pipeline")
+
+    # Parse config if provided
+    config_dict: dict[str, Any] = {}
+    if config:
+        try:
+            resolved = resolve_content(config)
+        except FileContentError as e:
+            raise typer.BadParameter(str(e))
+        if resolved is None:
+            raise typer.BadParameter("Could not resolve config content")
+        try:
+            config_dict = cast(dict[str, Any], json.loads(resolved))
+        except json.JSONDecodeError as e:
+            raise typer.BadParameter(f"Invalid JSON config: {e}")
+
+    # Parse tags if provided
+    tag_list: list[str] | None = None
+    if tags:
+        tag_list = [t.strip() for t in tags.split(",") if t.strip()]
+
+    # Parse env vars if provided
+    env_vars_dict: dict[str, str] | None = None
+    if env:
+        env_vars_dict = parse_kv_pairs(env)
+
+    # Parse metadata if provided
+    metadata_dict: dict[str, Any] | None = None
+    if metadata:
+        try:
+            resolved = resolve_content(metadata)
+        except FileContentError as e:
+            raise typer.BadParameter(str(e))
+        if resolved is None:
+            raise typer.BadParameter("Could not resolve metadata content")
+        try:
+            metadata_dict = cast(dict[str, Any], json.loads(resolved))
+        except json.JSONDecodeError as e:
+            raise typer.BadParameter(f"Invalid JSON metadata: {e}")
+
+    _execute_pipeline(
+        pipeline_id=pipeline_uuid,
+        config_dict=config_dict,
+        timeout=timeout,
+        external_id=external_id,
+        tags=tag_list,
+        env_vars=env_vars_dict,
+        metadata=metadata_dict,
+    )
+
+
+@async_command
+async def _execute_pipeline(
+    pipeline_id: UUID,
+    config_dict: dict[str, Any],
+    timeout: Optional[int],
+    external_id: Optional[str],
+    tags: Optional[list[str]],
+    env_vars: Optional[dict[str, str]],
+    metadata: Optional[dict[str, Any]],
+) -> None:
+    """Execute the pipeline."""
+    async with authenticated_client() as (_config, client):
+        request = ExecutePipelineRequest(
+            config=config_dict,
+            timeout_seconds=timeout,
+            external_id=external_id,
+            tags=tags,
+            env_vars=env_vars,
+            metadata=metadata,
+        )
+
+        response = await client.execute_pipeline(pipeline_id, request)
+
+    present_execution_result(response)

cli/commands/pipelines/execute/presenter.py

@@ -0,0 +1,47 @@
+"""Presenter for pipeline execute command output."""
+
+import json
+
+from alloy_runtime_types.dtos.pipeline import ExecutePipelineResponse
+
+from cli.infrastructure.formatting.fields import format_optional
+from cli.infrastructure.output import OutputService
+from cli.infrastructure.renderers.entity_renderer import FieldConfig
+
+
+def _format_tags(response: ExecutePipelineResponse) -> str:
+    """Format tags for display."""
+    if not response.tags:
+        return "(none)"
+    return ", ".join(t.tag_path for t in response.tags)
+
+
+def _format_duration(duration_ms: int | None) -> str:
+    """Format duration for display."""
+    if not duration_ms:
+        return "-"
+    return f"{duration_ms}ms"
+
+
+def present_execution_result(response: ExecutePipelineResponse) -> None:
+    """Present pipeline execution result."""
+    output = OutputService.get()
+
+    fields = [
+        FieldConfig("execution_id", "Execution ID", str),
+        FieldConfig("pipeline_id", "Pipeline ID", str),
+        FieldConfig("status", "Status"),
+        FieldConfig("external_id", "External ID", format_optional),
+        FieldConfig("total_duration_ms", "Duration", _format_duration),
+        FieldConfig("error_message", "Error", format_optional),
+        FieldConfig("tags", "Tags", lambda _: _format_tags(response)),
+    ]
+
+    output.entity(response, f"Execution: {response.status}", fields)
+
+    # Show result data if present
+    if response.result_data:
+        result_str = json.dumps(response.result_data, indent=2)
+        if len(result_str) > 500:
+            result_str = result_str[:500] + "\n..."
+        output.info(f"Result:\n{result_str}")

cli/commands/pipelines/executions/__init__.py

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

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

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

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

@@ -0,0 +1,48 @@
+"""Pipeline execution costs command implementation."""
+
+from uuid import UUID
+
+import typer
+
+from cli.commands.flag_utils import validate_uuid
+from cli.commands.pipelines.executions.costs.presenter import present_execution_costs
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def pipeline_execution_costs_command(
+    pipeline_id: str = typer.Argument(
+        ...,
+        help="Pipeline UUID",
+    ),
+    execution_id: str = typer.Argument(
+        ...,
+        help="Execution UUID",
+    ),
+) -> None:
+    """Get cost summary for a pipeline execution.
+
+    Shows LLM cost, RAG cost, and total cost breakdown.
+
+    Examples:
+        ai pipelines executions costs 123e... 456e...
+    """
+    pipeline_uuid = validate_uuid(pipeline_id, "pipeline")
+    execution_uuid = validate_uuid(execution_id, "execution")
+    _execute_costs(
+        pipeline_id=pipeline_uuid,
+        execution_id=execution_uuid,
+    )
+
+
+@async_command
+async def _execute_costs(
+    pipeline_id: UUID,
+    execution_id: UUID,
+) -> None:
+    async with authenticated_client() as (_config, client):
+        response = await client.get_execution_costs(
+            pipeline_id,
+            execution_id,
+        )
+
+    present_execution_costs(response)

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

@@ -0,0 +1,29 @@
+"""Presenter for pipeline execution costs command output."""
+
+from decimal import Decimal
+
+from alloy_runtime_types.dtos.pipeline_costs import PipelineExecutionCostSummary
+
+from cli.infrastructure.output import OutputService
+from cli.infrastructure.renderers.entity_renderer import FieldConfig
+
+
+def _format_cost(cost: Decimal | None) -> str:
+    if cost is None:
+        return "-"
+    return f"${cost:.4f}"
+
+
+def present_execution_costs(response: PipelineExecutionCostSummary) -> None:
+    output = OutputService.get()
+
+    fields = [
+        FieldConfig("pipeline_execution_id", "Execution ID", str),
+        FieldConfig("llm_cost_usd", "LLM Cost", _format_cost),
+        FieldConfig("rag_cost_usd", "RAG Cost", _format_cost),
+        FieldConfig("total_cost_usd", "Total Cost", _format_cost),
+        FieldConfig("agent_execution_count", "Agent Executions", str),
+        FieldConfig("retrieval_count", "RAG Retrievals", str),
+    ]
+
+    output.entity(response, "Execution Cost Summary", fields)

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

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

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

@@ -0,0 +1,50 @@
+"""Pipeline execution costs by model command implementation."""
+
+from uuid import UUID
+
+import typer
+
+from cli.commands.flag_utils import validate_uuid
+from cli.commands.pipelines.executions.costs_by_model.presenter import (
+    present_execution_costs_by_model,
+)
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def pipeline_execution_costs_by_model_command(
+    pipeline_id: str = typer.Argument(
+        ...,
+        help="Pipeline UUID",
+    ),
+    execution_id: str = typer.Argument(
+        ...,
+        help="Execution UUID",
+    ),
+) -> None:
+    """Get cost breakdown by model for a pipeline execution.
+
+    Shows costs grouped by provider and model.
+
+    Examples:
+        ai pipelines executions costs-by-model 123e... 456e...
+    """
+    pipeline_uuid = validate_uuid(pipeline_id, "pipeline")
+    execution_uuid = validate_uuid(execution_id, "execution")
+    _execute_costs_by_model(
+        pipeline_id=pipeline_uuid,
+        execution_id=execution_uuid,
+    )
+
+
+@async_command
+async def _execute_costs_by_model(
+    pipeline_id: UUID,
+    execution_id: UUID,
+) -> None:
+    async with authenticated_client() as (_config, client):
+        response = await client.get_execution_costs_by_model(
+            pipeline_id,
+            execution_id,
+        )
+
+    present_execution_costs_by_model(response)

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

@@ -0,0 +1,78 @@
+"""Presenter for pipeline execution costs by model command output."""
+
+from decimal import Decimal
+
+from alloy_runtime_types.dtos.pipeline_costs import ModelCostBreakdown
+
+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_model(entries: list[ModelCostBreakdown]) -> None:
+    output = OutputService.get()
+
+    if not entries:
+        output.info("No cost data by model found for this execution")
+        return
+
+    columns = [
+        ColumnConfig(
+            source_field="provider_key",
+            header_label="Provider",
+            compact_line=1,
+            compact_style="cyan",
+        ),
+        ColumnConfig(
+            source_field="model_name",
+            header_label="Model",
+            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="total_tokens",
+            header_label="Total Tokens",
+            formatter=lambda x: f"{x:,}",
+            compact_line=2,
+            compact_style="dim",
+        ),
+        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 Model ({len(entries)} models)",
+        columns=columns,
+    )

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

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

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

@@ -0,0 +1,50 @@
+"""Pipeline execution costs by step command implementation."""
+
+from uuid import UUID
+
+import typer
+
+from cli.commands.flag_utils import validate_uuid
+from cli.commands.pipelines.executions.costs_by_step.presenter import (
+    present_execution_costs_by_step,
+)
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def pipeline_execution_costs_by_step_command(
+    pipeline_id: str = typer.Argument(
+        ...,
+        help="Pipeline UUID",
+    ),
+    execution_id: str = typer.Argument(
+        ...,
+        help="Execution UUID",
+    ),
+) -> None:
+    """Get cost breakdown by step for a pipeline execution.
+
+    Shows costs grouped by pipeline step.
+
+    Examples:
+        ai pipelines executions costs-by-step 123e... 456e...
+    """
+    pipeline_uuid = validate_uuid(pipeline_id, "pipeline")
+    execution_uuid = validate_uuid(execution_id, "execution")
+    _execute_costs_by_step(
+        pipeline_id=pipeline_uuid,
+        execution_id=execution_uuid,
+    )
+
+
+@async_command
+async def _execute_costs_by_step(
+    pipeline_id: UUID,
+    execution_id: UUID,
+) -> None:
+    async with authenticated_client() as (_config, client):
+        response = await client.get_execution_costs_by_step(
+            pipeline_id,
+            execution_id,
+        )
+
+    present_execution_costs_by_step(response)