pragmatiks-cli 0.8.1__py3-none-any.whl → 0.12.5__py3-none-any.whl

pragma_cli/commands/auth.py

@@ -12,7 +12,7 @@ from pragma_sdk.config import load_credentials
 from rich import print
 from rich.console import Console
 
-from pragma_cli.config import CREDENTIALS_FILE, get_current_context, load_config
+from pragma_cli.config import CREDENTIALS_FILE, ContextConfig, get_current_context, load_config
 
 
 console = Console()
@@ -22,9 +22,29 @@ app = typer.Typer()
 
 CALLBACK_PORT = int(os.getenv("PRAGMA_AUTH_CALLBACK_PORT", "8765"))
 CALLBACK_PATH = os.getenv("PRAGMA_AUTH_CALLBACK_PATH", "/auth/callback")
-CLERK_FRONTEND_URL = os.getenv("PRAGMA_CLERK_FRONTEND_URL", "https://app.pragmatiks.io")
-CALLBACK_URL = f"http://localhost:{CALLBACK_PORT}{CALLBACK_PATH}"
-LOGIN_URL = f"{CLERK_FRONTEND_URL}/auth/callback?callback={CALLBACK_URL}"
+
+
+def _get_callback_url() -> str:
+    """Build the local callback URL for OAuth flow.
+
+    Returns:
+        Callback URL for the local OAuth server.
+    """
+    return f"http://localhost:{CALLBACK_PORT}{CALLBACK_PATH}"
+
+
+def _get_login_url(context_config: ContextConfig) -> str:
+    """Build the login URL for a given context.
+
+    Args:
+        context_config: The context configuration to get auth URL from.
+
+    Returns:
+        Full login URL with callback parameter.
+    """
+    auth_url = context_config.get_auth_url()
+    callback_url = _get_callback_url()
+    return f"{auth_url}/auth/callback?callback={callback_url}"
 
 
 class CallbackHandler(BaseHTTPRequestHandler):
@@ -142,41 +162,50 @@ def clear_credentials(context_name: str | None = None):
 
 
 @app.command()
-def login(context: str = typer.Option("default", help="Context to authenticate for")):
+def login(
+    context: str | None = typer.Option(None, help="Context to authenticate for (default: current)"),
+):
     """Authenticate with Pragma using browser-based Clerk login.
 
     Opens your default browser to Clerk authentication page. After successful
     login, your credentials are stored locally in ~/.config/pragma/credentials.
 
     Example:
-        pragma login
-        pragma login --context production
+        pragma auth login
+        pragma auth login --context production
 
     Raises:
         typer.Exit: If context not found or authentication fails/times out.
     """
     config = load_config()
+
+    # Use current context if not specified
+    if context is None:
+        context = config.current_context
+
     if context not in config.contexts:
         print(f"[red]\u2717[/red] Context '{context}' not found")
         print(f"Available contexts: {', '.join(config.contexts.keys())}")
         raise typer.Exit(1)
 
-    api_url = config.contexts[context].api_url
+    context_config = config.contexts[context]
+    auth_url = context_config.get_auth_url()
+    login_url = _get_login_url(context_config)
 
     print(f"[cyan]Authenticating for context:[/cyan] {context}")
-    print(f"[cyan]API URL:[/cyan] {api_url}")
+    print(f"[cyan]API URL:[/cyan] {context_config.api_url}")
     print()
 
     server = HTTPServer(("localhost", CALLBACK_PORT), CallbackHandler)
 
-    print(f"[yellow]Opening browser to:[/yellow] {CLERK_FRONTEND_URL}")
+    print(f"[yellow]Opening browser to:[/yellow] {auth_url}")
     print()
     print("[dim]If browser doesn't open automatically, visit:[/dim]")
-    print(f"[dim]{LOGIN_URL}[/dim]")
+    print(f"[dim]{login_url}[/dim]")
     print()
     print("[yellow]Waiting for authentication...[/yellow]")
 
-    webbrowser.open(LOGIN_URL)
+    webbrowser.open(login_url)
 
     server.timeout = 300
     server.handle_request()

pragma_cli/commands/completions.py

@@ -49,6 +49,31 @@ def completion_provider_ids(incomplete: str):
             yield provider.provider_id
 
 
+def completion_provider_versions(ctx: typer.Context, incomplete: str):
+    """Complete provider versions based on available builds.
+
+    Args:
+        ctx: Typer context containing parsed parameters including provider_id.
+        incomplete: Partial input to complete against available versions.
+
+    Yields:
+        Version strings matching the incomplete input.
+    """
+    client = _get_completion_client()
+    if client is None:
+        return
+    provider_id = ctx.params.get("provider_id")
+    if not provider_id:
+        return
+    try:
+        builds = client.list_builds(provider_id)
+    except Exception:
+        return
+    for build in builds:
+        if build.version.startswith(incomplete):
+            yield build.version
+
+
 def completion_resource_ids(incomplete: str):
     """Complete resource identifiers in provider/resource format based on existing resources.
 

pragma_cli/commands/config.py

@@ -44,18 +44,25 @@ def current_context():
     context_name, context_config = get_current_context()
     print(f"[bold]Current context:[/bold] [cyan]{context_name}[/cyan]")
     print(f"[bold]API URL:[/bold] {context_config.api_url}")
+    print(f"[bold]Auth URL:[/bold] {context_config.get_auth_url()}")
 
 
 @app.command()
 def set_context(
     name: str = typer.Argument(..., help="Context name"),
     api_url: str = typer.Option(..., help="API endpoint URL"),
+    auth_url: str | None = typer.Option(None, help="Auth endpoint URL (derived from api_url if not set)"),
 ):
     """Create or update a context."""
     config = load_config()
-    config.contexts[name] = ContextConfig(api_url=api_url)
+    config.contexts[name] = ContextConfig(api_url=api_url, auth_url=auth_url)
     save_config(config)
+
+    # Show the effective auth URL
+    effective_auth = config.contexts[name].get_auth_url()
     print(f"[green]\u2713[/green] Context '{name}' configured")
+    print(f"  API URL:  {api_url}")
+    print(f"  Auth URL: {effective_auth}")
 
 
 @app.command()

pragma_cli/commands/providers.py

@@ -15,7 +15,7 @@ import copier
 import httpx
 import typer
 from pragma_sdk import (
-    BuildResult,
+    BuildInfo,
     BuildStatus,
     DeploymentStatus,
     PragmaClient,
@@ -28,7 +28,8 @@ from rich.progress import Progress, SpinnerColumn, TextColumn
 from rich.table import Table
 
 from pragma_cli import get_client
-from pragma_cli.commands.completions import completion_provider_ids
+from pragma_cli.commands.completions import completion_provider_ids, completion_provider_versions
+from pragma_cli.helpers import OutputFormat, output_data
 
 
 app = typer.Typer(help="Provider management commands")
@@ -117,7 +118,9 @@ def get_template_source() -> str:
 
 
 @app.command("list")
-def list_providers():
+def list_providers(
+    output: Annotated[OutputFormat, typer.Option("--output", "-o", help="Output format")] = OutputFormat.TABLE,
+):
     """List all deployed providers.
 
     Shows providers with their deployment status. Displays:
@@ -126,8 +129,9 @@ def list_providers():
     - Status (running/stopped)
     - Last deployed timestamp
 
-    Example:
+    Examples:
         pragma providers list
+        pragma providers list -o json
 
     Raises:
         typer.Exit: If authentication is missing or API call fails.
@@ -158,7 +162,12 @@ def list_providers():
         console.print("[dim]No providers found.[/dim]")
         return
 
-    _print_providers_table(providers)
+    if output == OutputFormat.TABLE:
+        _print_providers_table(providers)
+    else:
+        # Convert Pydantic models to dicts for JSON/YAML output
+        data = [p.model_dump(mode="json") for p in providers]
+        output_data(data, output)
 
 
 def _print_providers_table(providers: list[ProviderInfo]) -> None:
@@ -422,7 +431,7 @@ def push(
     client = get_client()
 
     if client._auth is None:
-        console.print("[red]Error:[/red] Authentication required. Run 'pragma login' first.")
+        console.print("[red]Error:[/red] Authentication required. Run 'pragma auth login' first.")
         raise typer.Exit(1)
 
     try:
@@ -431,10 +440,10 @@ def push(
         if not wait:
             console.print()
             console.print("[dim]Build running in background. Check status with:[/dim]")
-            console.print(f"  pragma providers status {provider_id} --job {push_result.job_name}")
+            console.print(f"  pragma providers builds {provider_id} {push_result.version}")
             return
 
-        _wait_for_build(client, provider_id, push_result.job_name, logs)
+        _wait_for_build(client, provider_id, push_result.version, logs)
 
         if deploy:
             console.print()
@@ -455,7 +464,7 @@ def _upload_code(client: PragmaClient, provider_id: str, tarball: bytes) -> Push
         tarball: Gzipped tarball bytes of provider source.
 
     Returns:
-        PushResult with build job details.
+        PushResult with build details including version.
     """
     with Progress(
         SpinnerColumn(),
@@ -466,42 +475,42 @@ def _upload_code(client: PragmaClient, provider_id: str, tarball: bytes) -> Push
         progress.add_task("Uploading code...", total=None)
         push_result = client.push_provider(provider_id, tarball)
 
-    console.print(f"[green]Build started:[/green] {push_result.job_name}")
+    console.print(f"[green]Build started:[/green] {push_result.version}")
     return push_result
 
 
 def _wait_for_build(
     client: PragmaClient,
     provider_id: str,
-    job_name: str,
+    version: str,
     logs: bool,
-) -> BuildResult:
+) -> BuildInfo:
     """Wait for build to complete, optionally streaming logs.
 
     Args:
         client: SDK client instance.
         provider_id: Provider identifier.
-        job_name: Build job name.
+        version: CalVer version string.
         logs: Whether to stream build logs.
 
     Returns:
-        Final BuildResult.
+        Final BuildInfo.
 
     Raises:
         typer.Exit: On build failure or timeout.
     """
     if logs:
-        _stream_build_logs(client, provider_id, job_name)
+        _stream_build_logs(client, provider_id, version)
     else:
-        build_result = _poll_build_status(client, provider_id, job_name)
+        build_result = _poll_build_status(client, provider_id, version)
 
         if build_result.status == BuildStatus.FAILED:
             console.print(f"[red]Build failed:[/red] {build_result.error_message}")
             raise typer.Exit(1)
 
-        console.print(f"[green]Build successful:[/green] {build_result.image}")
+        console.print(f"[green]Build successful:[/green] {build_result.version}")
 
-    final_build = client.get_build_status(provider_id, job_name)
+    final_build = client.get_build_status(provider_id, version)
 
     if final_build.status != BuildStatus.SUCCESS:
         console.print(f"[red]Build failed:[/red] {final_build.error_message}")
@@ -510,16 +519,16 @@ def _wait_for_build(
     return final_build
 
 
-def _poll_build_status(client: PragmaClient, provider_id: str, job_name: str) -> BuildResult:
+def _poll_build_status(client: PragmaClient, provider_id: str, version: str) -> BuildInfo:
     """Poll build status until completion or timeout.
 
     Args:
         client: SDK client instance.
         provider_id: Provider identifier.
-        job_name: Build job name.
+        version: CalVer version string.
 
     Returns:
-        Final BuildResult.
+        Final BuildInfo.
 
     Raises:
         typer.Exit: If build times out.
@@ -535,7 +544,7 @@ def _poll_build_status(client: PragmaClient, provider_id: str, job_name: str) ->
         task = progress.add_task("Building...", total=None)
 
         while True:
-            build_result = client.get_build_status(provider_id, job_name)
+            build_result = client.get_build_status(provider_id, version)
 
             if build_result.status in (BuildStatus.SUCCESS, BuildStatus.FAILED):
                 return build_result
@@ -549,33 +558,31 @@ def _poll_build_status(client: PragmaClient, provider_id: str, job_name: str) ->
             time.sleep(BUILD_POLL_INTERVAL)
 
 
-def _stream_build_logs(client: PragmaClient, provider_id: str, job_name: str) -> None:
+def _stream_build_logs(client: PragmaClient, provider_id: str, version: str) -> None:
     """Stream build logs to console.
 
     Args:
         client: SDK client instance.
         provider_id: Provider identifier.
-        job_name: Build job name.
+        version: CalVer version string.
     """
     console.print()
     console.print("[bold]Build logs:[/bold]")
     console.print("-" * 40)
 
     try:
-        with client.stream_build_logs(provider_id, job_name) as response:
+        with client.stream_build_logs(provider_id, version) as response:
             for line in response.iter_lines():
                 console.print(line)
     except httpx.HTTPError as e:
         console.print(f"[yellow]Warning:[/yellow] Could not stream logs: {e}")
         console.print("[dim]Falling back to polling...[/dim]")
-        _poll_build_status(client, provider_id, job_name)
+        _poll_build_status(client, provider_id, version)
 
     console.print("-" * 40)
 
 
-def _deploy_provider(
-    client: PragmaClient, provider_id: str, version: str | None = None
-) -> None:
+def _deploy_provider(client: PragmaClient, provider_id: str, version: str | None = None) -> None:
     """Deploy the provider to a specific version.
 
     Args:
@@ -592,20 +599,27 @@ def _deploy_provider(
         progress.add_task("Deploying...", total=None)
         deploy_result = client.deploy_provider(provider_id, version)
 
-    console.print(f"[green]Deployment started:[/green] {deploy_result.deployment_name}")
-    console.print(f"[dim]Version:[/dim] {deploy_result.version}")
+    console.print(f"[green]Deployment started:[/green] {provider_id}")
+    if deploy_result.image:
+        console.print(f"[dim]Image:[/dim] {deploy_result.image}")
     console.print(f"[dim]Status:[/dim] {deploy_result.status.value}")
 
 
 @app.command()
 def deploy(
+    provider_id: Annotated[
+        str,
+        typer.Argument(
+            help="Provider ID to deploy (e.g., 'postgres', 'my-provider')",
+            autocompletion=completion_provider_ids,
+        ),
+    ],
     version: Annotated[
         str | None,
-        typer.Option("--version", "-v", help="Version to deploy (e.g., 20250115.120000). Defaults to latest."),
-    ] = None,
-    package: Annotated[
-        str | None,
-        typer.Option("--package", "-p", help="Provider package name (auto-detected if not specified)"),
+        typer.Argument(
+            help="Version to deploy (e.g., 20250115.120000). Defaults to latest.",
+            autocompletion=completion_provider_versions,
+        ),
     ] = None,
 ):
     """Deploy a provider to a specific version.
@@ -614,23 +628,14 @@ def deploy(
     the latest successful build. Use 'pragma providers builds' to see available versions.
 
     Deploy latest:
-        pragma providers deploy
+        pragma providers deploy postgres
 
     Deploy specific version:
-        pragma providers deploy --version 20250115.120000
+        pragma providers deploy postgres 20250115.120000
 
     Raises:
         typer.Exit: If deployment fails.
     """
-    provider_name = package or detect_provider_package()
-
-    if not provider_name:
-        console.print("[red]Error:[/red] Could not detect provider package.")
-        console.print("Run from a provider directory or specify --package")
-        raise typer.Exit(1)
-
-    provider_id = provider_name.replace("_", "-").removesuffix("-provider")
-
     console.print(f"[bold]Deploying provider:[/bold] {provider_id}")
     if version:
         console.print(f"[dim]Version:[/dim] {version}")
@@ -717,7 +722,7 @@ def delete(
     client = get_client()
 
     if client._auth is None:
-        console.print("[red]Error:[/red] Authentication required. Run 'pragma login' first.")
+        console.print("[red]Error:[/red] Authentication required. Run 'pragma auth login' first.")
         raise typer.Exit(1)
 
     console.print(f"[bold]Provider:[/bold] {provider_id}")
@@ -765,23 +770,12 @@ def _print_delete_result(result: ProviderDeleteResult) -> None:
     """
     console.print()
     console.print(f"[green]Provider deleted:[/green] {result.provider_id}")
-    console.print()
 
-    table = Table(show_header=True, header_style="bold")
-    table.add_column("Component")
-    table.add_column("Deleted", justify="right")
-
-    table.add_row("Builds Cancelled", str(result.builds_cancelled))
-    table.add_row("Source Archives", str(result.source_archives_deleted))
-    table.add_row("Deployment", "Yes" if result.deployment_deleted else "No (not found)")
-    table.add_row("Resources", str(result.resources_deleted))
-    table.add_row("Resource Definitions", str(result.resource_definitions_deleted))
-    table.add_row("Outbox Events", str(result.outbox_events_deleted))
-    table.add_row("Dead Letter Events", str(result.dead_letter_events_deleted))
-    table.add_row("NATS Messages Purged", str(result.messages_purged))
-    table.add_row("NATS Consumer", "Deleted" if result.consumer_deleted else "Not found")
+    if result.deployment_deleted:
+        console.print("[dim]Deployment stopped[/dim]")
 
-    console.print(table)
+    if result.resources_deleted > 0:
+        console.print(f"[dim]Resources deleted: {result.resources_deleted}[/dim]")
 
 
 @app.command()
@@ -793,6 +787,7 @@ def status(
             autocompletion=completion_provider_ids,
         ),
     ],
+    output: Annotated[OutputFormat, typer.Option("--output", "-o", help="Output format")] = OutputFormat.TABLE,
 ):
     """Check the deployment status of a provider.
 
@@ -802,9 +797,10 @@ def status(
     - Health status
     - Last updated timestamp
 
-    Example:
+    Examples:
         pragma providers status postgres
         pragma providers status my-provider
+        pragma providers status postgres -o json
 
     Raises:
         typer.Exit: If deployment not found or status check fails.
@@ -827,7 +823,13 @@ def status(
         console.print(f"[red]Error:[/red] {e}")
         raise typer.Exit(1)
 
-    _print_deployment_status(provider_id, result)
+    if output == OutputFormat.TABLE:
+        _print_deployment_status(provider_id, result)
+    else:
+        # Convert Pydantic model to dict for JSON/YAML output
+        data = result.model_dump(mode="json")
+        data["provider_id"] = provider_id  # Include provider_id in output
+        output_data(data, output)
 
 
 def _print_deployment_status(provider_id: str, result) -> None:
@@ -835,7 +837,7 @@ def _print_deployment_status(provider_id: str, result) -> None:
 
     Args:
         provider_id: Provider identifier.
-        result: ProviderStatus from the API.
+        result: DeploymentResult from the API.
     """
     status_colors = {
         "pending": "yellow",
@@ -855,10 +857,12 @@ def _print_deployment_status(provider_id: str, result) -> None:
 
     table.add_row("Status", f"[{status_color}]{result.status.value}[/{status_color}]")
 
-    if result.version:
-        table.add_row("Version", result.version)
+    if result.image:
+        table.add_row("Image", result.image)
 
-    healthy_display = "[green]yes[/green]" if result.healthy else "[red]no[/red]"
+    # Healthy is determined by having ready replicas
+    healthy = result.ready_replicas > 0
+    healthy_display = "[green]yes[/green]" if healthy else "[red]no[/red]"
     table.add_row("Healthy", healthy_display)
 
     if result.updated_at:
@@ -892,7 +896,7 @@ def builds(
     client = get_client()
 
     if client._auth is None:
-        console.print("[red]Error:[/red] Authentication required. Run 'pragma login' first.")
+        console.print("[red]Error:[/red] Authentication required. Run 'pragma auth login' first.")
         raise typer.Exit(1)
 
     try:

pragma_cli/commands/resources.py

@@ -6,24 +6,83 @@ import json
 from pathlib import Path
 from typing import Annotated
 
+import httpx
 import typer
 import yaml
 from rich import print
 from rich.console import Console
 from rich.markup import escape
+from rich.table import Table
 
 from pragma_cli import get_client
 from pragma_cli.commands.completions import (
     completion_resource_ids,
     completion_resource_names,
 )
-from pragma_cli.helpers import parse_resource_id
+from pragma_cli.helpers import OutputFormat, output_data, parse_resource_id
 
 
 console = Console()
 app = typer.Typer()
 
 
+def _format_api_error(error: httpx.HTTPStatusError) -> str:
+    """Format an API error response with structured details.
+
+    Returns:
+        Formatted error message with details extracted from JSON response.
+    """
+    try:
+        detail = error.response.json().get("detail", {})
+    except (json.JSONDecodeError, ValueError):
+        # Fall back to plain text if not JSON
+        return error.response.text or str(error)
+
+    # Handle simple string details
+    if isinstance(detail, str):
+        return detail
+
+    # Handle structured error responses
+    message = detail.get("message", str(error))
+    parts = [message]
+
+    # DependencyValidationError details
+    if missing := detail.get("missing_dependencies"):
+        parts.append("\n  Missing dependencies:")
+        for dep_id in missing:
+            parts.append(f"    - {dep_id}")
+    if not_ready := detail.get("not_ready_dependencies"):
+        parts.append("\n  Dependencies not ready:")
+        for item in not_ready:
+            if isinstance(item, dict):
+                parts.append(f"    - {item['id']} (state: {item['state']})")
+            else:
+                parts.append(f"    - {item}")
+
+    # FieldReferenceError details
+    if field := detail.get("field"):
+        ref_parts = [
+            detail.get("reference_provider", ""),
+            detail.get("reference_resource", ""),
+            detail.get("reference_name", ""),
+        ]
+        ref_id = "/".join(filter(None, ref_parts))
+        if ref_id:
+            parts.append(f"\n  Reference: {ref_id}#{field}")
+
+    # InvalidLifecycleTransitionError details
+    if current_state := detail.get("current_state"):
+        target_state = detail.get("target_state", "unknown")
+        parts.append(f"\n  Current state: {current_state}")
+        parts.append(f"  Target state: {target_state}")
+
+    # ResourceInProcessingError details
+    if resource_id := detail.get("resource_id"):
+        parts.append(f"\n  Resource: {resource_id}")
+
+    return "".join(parts)
+
+
 def resolve_file_references(resource: dict, base_dir: Path) -> dict:
     """Resolve file references in secret resource config.
 
@@ -55,7 +114,7 @@ def resolve_file_references(resource: dict, base_dir: Path) -> dict:
     resolved_data = {}
     for key, value in data.items():
         if isinstance(value, str) and value.startswith("@"):
-            file_path = Path(value[1:])
+            file_path = Path(value[1:]).expanduser()
             if not file_path.is_absolute():
                 file_path = base_dir / file_path
 
@@ -85,13 +144,76 @@ def format_state(state: str) -> str:
     return escape(f"[{state}]")
 
 
+def _print_resource_types_table(types: list[dict]) -> None:
+    """Print resource types in a formatted table.
+
+    Args:
+        types: List of resource type dictionaries to display.
+    """
+    console.print()
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("Provider")
+    table.add_column("Resource")
+    table.add_column("Description")
+
+    for resource_type in types:
+        description = resource_type.get("description") or "[dim]—[/dim]"
+        table.add_row(
+            resource_type["provider"],
+            resource_type["resource"],
+            description,
+        )
+
+    console.print(table)
+    console.print()
+
+
+@app.command("types")
+def list_resource_types(
+    provider: Annotated[str | None, typer.Option("--provider", "-p", help="Filter by provider")] = None,
+    output: Annotated[OutputFormat, typer.Option("--output", "-o", help="Output format")] = OutputFormat.TABLE,
+):
+    """List available resource types from deployed providers.
+
+    Displays resource definitions (types) that have been registered by providers.
+    Use this to discover what resources you can create.
+
+    Examples:
+        pragma resources types
+        pragma resources types --provider gcp
+        pragma resources types -o json
+
+    Raises:
+        typer.Exit: If an error occurs while fetching resource types.
+    """
+    client = get_client()
+    try:
+        types = client.list_resource_types(provider=provider)
+    except httpx.HTTPStatusError as e:
+        console.print(f"[red]Error:[/red] {_format_api_error(e)}")
+        raise typer.Exit(1)
+
+    if not types:
+        console.print("[dim]No resource types found.[/dim]")
+        return
+
+    output_data(types, output, table_renderer=_print_resource_types_table)
+
+
 @app.command("list")
 def list_resources(
     provider: Annotated[str | None, typer.Option("--provider", "-p", help="Filter by provider")] = None,
     resource: Annotated[str | None, typer.Option("--resource", "-r", help="Filter by resource type")] = None,
     tags: Annotated[list[str] | None, typer.Option("--tag", "-t", help="Filter by tags")] = None,
+    output: Annotated[OutputFormat, typer.Option("--output", "-o", help="Output format")] = OutputFormat.TABLE,
 ):
-    """List resources, optionally filtered by provider, resource type, or tags."""
+    """List resources, optionally filtered by provider, resource type, or tags.
+
+    Examples:
+        pragma resources list
+        pragma resources list --provider gcp
+        pragma resources list -o json
+    """
     client = get_client()
     resources = list(client.list_resources(provider=provider, resource=resource, tags=tags))
 
@@ -99,24 +221,211 @@ def list_resources(
         console.print("[dim]No resources found.[/dim]")
         return
 
+    output_data(resources, output, table_renderer=_print_resources_table)
+
+
+def _print_resources_table(resources: list[dict]) -> None:
+    """Print resources in a formatted table.
+
+    Args:
+        resources: List of resource dictionaries to display.
+    """
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("Provider")
+    table.add_column("Resource")
+    table.add_column("Name")
+    table.add_column("State")
+    table.add_column("Updated")
+
+    # Track failed resources to show errors after table
+    failed_resources: list[tuple[str, str]] = []
+
     for res in resources:
-        print(f"{res['provider']}/{res['resource']}/{res['name']} {format_state(res['lifecycle_state'])}")
+        state = _format_state_color(res["lifecycle_state"])
+        updated = res.get("updated_at", "[dim]-[/dim]")
+        if updated and updated != "[dim]-[/dim]":
+            # Truncate to datetime portion if it's a full ISO string
+            updated = updated[:19].replace("T", " ") if len(updated) > 19 else updated
+
+        table.add_row(
+            res["provider"],
+            res["resource"],
+            res["name"],
+            state,
+            updated,
+        )
+
+        # Track failed resources for error display
+        if res.get("lifecycle_state") == "failed" and res.get("error"):
+            resource_id = f"{res['provider']}/{res['resource']}/{res['name']}"
+            failed_resources.append((resource_id, res["error"]))
+
+    console.print(table)
+
+    # Show errors for failed resources below the table
+    for resource_id, error in failed_resources:
+        console.print(f"  [red]{resource_id}:[/red] {escape(error)}")
 
 
 @app.command()
 def get(
     resource_id: Annotated[str, typer.Argument(autocompletion=completion_resource_ids)],
     name: Annotated[str | None, typer.Argument(autocompletion=completion_resource_names)] = None,
+    output: Annotated[OutputFormat, typer.Option("--output", "-o", help="Output format")] = OutputFormat.TABLE,
 ):
-    """Get resources by provider/resource type, optionally filtered by name."""
+    """Get resources by provider/resource type, optionally filtered by name.
+
+    Examples:
+        pragma resources get gcp/secret
+        pragma resources get gcp/secret my-secret
+        pragma resources get gcp/secret my-secret -o json
+    """
     client = get_client()
     provider, resource = parse_resource_id(resource_id)
     if name:
         res = client.get_resource(provider=provider, resource=resource, name=name)
-        print(f"{resource_id}/{res['name']} {format_state(res['lifecycle_state'])}")
+        output_data([res], output, table_renderer=_print_resources_table)
     else:
-        for res in client.list_resources(provider=provider, resource=resource):
-            print(f"{resource_id}/{res['name']} {format_state(res['lifecycle_state'])}")
+        resources = list(client.list_resources(provider=provider, resource=resource))
+        if not resources:
+            console.print("[dim]No resources found.[/dim]")
+            return
+        output_data(resources, output, table_renderer=_print_resources_table)
+
+
+def _format_state_color(state: str) -> str:
+    """Format lifecycle state with color markup.
+
+    Returns:
+        State string wrapped in Rich color markup.
+    """
+    state_colors = {
+        "draft": "dim",
+        "pending": "yellow",
+        "processing": "cyan",
+        "ready": "green",
+        "failed": "red",
+    }
+    color = state_colors.get(state.lower(), "white")
+    return f"[{color}]{state}[/{color}]"
+
+
+def _format_config_value(value, *, redact_keys: set[str] | None = None) -> str:
+    """Format a config value, redacting sensitive fields.
+
+    Returns:
+        Formatted string representation with sensitive values masked.
+    """
+    redact_keys = redact_keys or {"credentials", "password", "secret", "token", "key", "data"}
+    if isinstance(value, dict):
+        # Check if this is a FieldReference
+        if "provider" in value and "resource" in value and "name" in value and "field" in value:
+            return f"{value['provider']}/{value['resource']}/{value['name']}#{value['field']}"
+        # Recursively format nested dicts
+        formatted = {}
+        for k, v in value.items():
+            if k.lower() in redact_keys:
+                formatted[k] = "********"
+            else:
+                formatted[k] = _format_config_value(v, redact_keys=redact_keys)
+        return str(formatted)
+    elif isinstance(value, list):
+        return str([_format_config_value(v, redact_keys=redact_keys) for v in value])
+    return str(value)
+
+
+def _print_resource_details(res: dict) -> None:
+    """Print resource details in a formatted table."""
+    resource_id = f"{res['provider']}/{res['resource']}/{res['name']}"
+
+    console.print()
+    console.print(f"[bold]Resource:[/bold] {resource_id}")
+    console.print()
+
+    # Main properties table
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("Property")
+    table.add_column("Value")
+
+    # State with color
+    table.add_row("State", _format_state_color(res["lifecycle_state"]))
+
+    # Error if failed
+    if res.get("error"):
+        table.add_row("Error", f"[red]{escape(res['error'])}[/red]")
+
+    # Timestamps
+    if res.get("created_at"):
+        table.add_row("Created", res["created_at"])
+    if res.get("updated_at"):
+        table.add_row("Updated", res["updated_at"])
+
+    console.print(table)
+
+    # Config section
+    config = res.get("config", {})
+    if config:
+        console.print()
+        console.print("[bold]Config:[/bold]")
+        for key, value in config.items():
+            formatted = _format_config_value(value)
+            console.print(f"  {key}: {formatted}")
+
+    # Outputs section
+    outputs = res.get("outputs", {})
+    if outputs:
+        console.print()
+        console.print("[bold]Outputs:[/bold]")
+        for key, value in outputs.items():
+            console.print(f"  {key}: {value}")
+
+    # Dependencies section
+    dependencies = res.get("dependencies", [])
+    if dependencies:
+        console.print()
+        console.print("[bold]Dependencies:[/bold]")
+        for dep in dependencies:
+            dep_id = f"{dep['provider']}/{dep['resource']}/{dep['name']}"
+            console.print(f"  - {dep_id}")
+
+    # Tags section
+    tags = res.get("tags", [])
+    if tags:
+        console.print()
+        console.print("[bold]Tags:[/bold]")
+        console.print(f"  {', '.join(tags)}")
+
+    console.print()
+
+
+@app.command()
+def describe(
+    resource_id: Annotated[str, typer.Argument(autocompletion=completion_resource_ids)],
+    name: Annotated[str, typer.Argument(autocompletion=completion_resource_names)],
+    output: Annotated[OutputFormat, typer.Option("--output", "-o", help="Output format")] = OutputFormat.TABLE,
+):
+    """Show detailed information about a resource.
+
+    Displays the resource's config, outputs, dependencies, and error messages.
+
+    Examples:
+        pragma resources describe gcp/secret my-test-secret
+        pragma resources describe postgres/database my-db
+        pragma resources describe gcp/secret my-secret -o json
+
+    Raises:
+        typer.Exit: If the resource is not found or an error occurs.
+    """
+    client = get_client()
+    provider, resource = parse_resource_id(resource_id)
+
+    try:
+        res = client.get_resource(provider=provider, resource=resource, name=name)
+    except httpx.HTTPStatusError as e:
+        console.print(f"[red]Error:[/red] {_format_api_error(e)}")
+        raise typer.Exit(1)
+
+    output_data(res, output, table_renderer=_print_resource_details)
 
 
 @app.command()
@@ -134,6 +443,9 @@ def apply(
     For pragma/secret resources, file references in config.data values
     are resolved before submission. Use '@path/to/file' syntax to inline
     file contents.
+
+    Raises:
+        typer.Exit: If the apply operation fails.
     """
     client = get_client()
     for f in file:
@@ -144,9 +456,14 @@ def apply(
             resource = resolve_file_references(resource, base_dir)
             if pending:
                 resource["lifecycle_state"] = "pending"
-            result = client.apply_resource(resource=resource)
-            res_id = f"{result['provider']}/{result['resource']}/{result['name']}"
-            print(f"Applied {res_id} {format_state(result['lifecycle_state'])}")
+            res_id = f"{resource.get('provider', '?')}/{resource.get('resource', '?')}/{resource.get('name', '?')}"
+            try:
+                result = client.apply_resource(resource=resource)
+                res_id = f"{result['provider']}/{result['resource']}/{result['name']}"
+                print(f"Applied {res_id} {format_state(result['lifecycle_state'])}")
+            except httpx.HTTPStatusError as e:
+                console.print(f"[red]Error applying {res_id}:[/red] {_format_api_error(e)}")
+                raise typer.Exit(1)
 
 
 @app.command()
@@ -154,52 +471,16 @@ def delete(
     resource_id: Annotated[str, typer.Argument(autocompletion=completion_resource_ids)],
     name: Annotated[str, typer.Argument(autocompletion=completion_resource_names)],
 ):
-    """Delete a resource."""
-    client = get_client()
-    provider, resource = parse_resource_id(resource_id)
-    client.delete_resource(provider=provider, resource=resource, name=name)
-    print(f"Deleted {resource_id}/{name}")
-
-
-@app.command()
-def register(
-    resource_id: Annotated[str, typer.Argument(help="Resource type in provider/resource format")],
-    description: Annotated[str | None, typer.Option("--description", "-d", help="Resource type description")] = None,
-    schema_file: Annotated[typer.FileText | None, typer.Option("--schema", "-s", help="JSON schema file")] = None,
-    tags: Annotated[list[str] | None, typer.Option("--tag", "-t", help="Tags for categorization")] = None,
-):
-    """Register a new resource type.
-
-    Registers a resource type so that resources of this type can be created.
-    Providers use this to declare what resources they can manage.
-    """
-    client = get_client()
-    provider, resource = parse_resource_id(resource_id)
-
-    schema = None
-    if schema_file:
-        schema = json.load(schema_file)
-
-    client.register_resource(
-        provider=provider,
-        resource=resource,
-        schema=schema,
-        description=description,
-        tags=tags,
-    )
-    print(f"Registered {resource_id}")
-
-
-@app.command()
-def unregister(
-    resource_id: Annotated[str, typer.Argument(autocompletion=completion_resource_ids)],
-):
-    """Unregister a resource type.
+    """Delete a resource.
 
-    Removes a resource type registration. Existing resources of this type
-    will no longer be manageable.
+    Raises:
+        typer.Exit: If the resource is not found or deletion fails.
     """
     client = get_client()
     provider, resource = parse_resource_id(resource_id)
-    client.unregister_resource(provider=provider, resource=resource)
-    print(f"Unregistered {resource_id}")
+    try:
+        client.delete_resource(provider=provider, resource=resource, name=name)
+        print(f"Deleted {resource_id}/{name}")
+    except httpx.HTTPStatusError as e:
+        console.print(f"[red]Error deleting {resource_id}/{name}:[/red] {_format_api_error(e)}")
+        raise typer.Exit(1)

pragma_cli/config.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import os
 from pathlib import Path
+from urllib.parse import urlparse
 
 import yaml
 from pydantic import BaseModel
@@ -30,6 +31,24 @@ class ContextConfig(BaseModel):
     """Configuration for a single CLI context."""
 
     api_url: str
+    auth_url: str | None = None
+
+    def get_auth_url(self) -> str:
+        """Get the auth URL, deriving from api_url if not explicitly set.
+
+        Returns:
+            Auth URL for Clerk authentication.
+        """
+        if self.auth_url:
+            return self.auth_url
+
+        # Handle localhost: default to port 3000 for web app
+        parsed = urlparse(self.api_url)
+        if parsed.hostname in ("localhost", "127.0.0.1"):
+            return "http://localhost:3000"
+
+        # Derive from api_url: api.pragmatiks.io -> app.pragmatiks.io
+        return self.api_url.replace("://api.", "://app.")
 
 
 class PragmaConfig(BaseModel):

pragma_cli/helpers.py

@@ -1,7 +1,46 @@
-"""CLI helper functions for parsing resource identifiers."""
+"""CLI helper functions for parsing resource identifiers and output formatting."""
 
 from __future__ import annotations
 
+import json
+from enum import StrEnum
+from typing import TYPE_CHECKING, Any
+
+import yaml
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+class OutputFormat(StrEnum):
+    """Output format options for CLI commands."""
+
+    TABLE = "table"
+    JSON = "json"
+    YAML = "yaml"
+
+
+def output_data(
+    data: list[dict[str, Any]] | dict[str, Any],
+    format: OutputFormat,
+    table_renderer: Callable[..., None] | None = None,
+) -> None:
+    """Output data in the specified format.
+
+    Args:
+        data: Data to output (list of dicts or single dict).
+        format: Output format (table, json, yaml).
+        table_renderer: Function to render table output. Required for TABLE format.
+    """
+    if format == OutputFormat.TABLE:
+        if table_renderer:
+            table_renderer(data)
+    elif format == OutputFormat.JSON:
+        print(json.dumps(data, indent=2, default=str))
+    elif format == OutputFormat.YAML:
+        print(yaml.dump(data, default_flow_style=False, sort_keys=False))
+
 
 def parse_resource_id(resource_id: str) -> tuple[str, str]:
     """Parse resource identifier into provider and resource type.

pragma_cli/main.py

@@ -1,5 +1,6 @@
 """CLI entry point with Typer application setup and command routing."""
 
+from importlib.metadata import version as get_version
 from typing import Annotated
 
 import typer
@@ -13,9 +14,34 @@ from pragma_cli.config import get_current_context
 app = typer.Typer()
 
 
+def _version_callback(value: bool) -> None:
+    """Print version and exit if --version flag is provided.
+
+    Args:
+        value: True if --version flag was provided.
+
+    Raises:
+        typer.Exit: Always exits after displaying version.
+    """
+    if value:
+        package_version = get_version("pragmatiks-cli")
+        typer.echo(f"pragma {package_version}")
+        raise typer.Exit()
+
+
 @app.callback()
 def main(
     ctx: typer.Context,
+    version: Annotated[
+        bool | None,
+        typer.Option(
+            "--version",
+            "-V",
+            help="Show version and exit",
+            callback=_version_callback,
+            is_eager=True,
+        ),
+    ] = None,
     context: Annotated[
         str | None,
         typer.Option(
@@ -37,14 +63,14 @@ def main(
     """Pragma CLI - Declarative resource management.
 
     Authentication (industry-standard pattern):
-      - CLI writes credentials: 'pragma login' stores tokens in ~/.config/pragma/credentials
+      - CLI writes credentials: 'pragma auth login' stores tokens in ~/.config/pragma/credentials
       - SDK reads credentials: Automatic token discovery via precedence chain
 
     Token Discovery Precedence:
       1. --token flag (explicit override)
       2. PRAGMA_AUTH_TOKEN_<CONTEXT> context-specific environment variable
       3. PRAGMA_AUTH_TOKEN environment variable
-      4. ~/.config/pragma/credentials file (from pragma login)
+      4. ~/.config/pragma/credentials file (from pragma auth login)
       5. No authentication
     """
     context_name, context_config = get_current_context(context)

{pragmatiks_cli-0.8.1.dist-info → pragmatiks_cli-0.12.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pragmatiks-cli
-Version: 0.8.1
+Version: 0.12.5
 Summary: Command-line interface for Pragmatiks
 Requires-Dist: typer>=0.15.3
 Requires-Dist: pragmatiks-sdk>=0.6.0

pragmatiks_cli-0.12.5.dist-info/RECORD

@@ -0,0 +1,17 @@
+pragma_cli/__init__.py,sha256=9REbOdKs9CeuOd-rxeFs17gWtou1dUdCogYU8G5Cz6c,682
+pragma_cli/commands/__init__.py,sha256=zltFPaCZgkeTdOH1YWrUEqqBF9Dg6tokgAFcmqP4_n4,24
+pragma_cli/commands/auth.py,sha256=ADpPH8jDbpwhyRzwvG_4PAg2oxVbt2vGx1LrAZNIq-I,9968
+pragma_cli/commands/completions.py,sha256=0SFfq1V0QLjLc4Kr6wcRvQF0UQpB9lZ6V5fU6SVtsbM,3610
+pragma_cli/commands/config.py,sha256=fq4G6DwgTaEZLZIcGdLXzEh4Zrv6M6_ew0IU7WytQk0,2648
+pragma_cli/commands/dead_letter.py,sha256=8Mh_QVZiwkbOA1fYkw1O9BeHgPdqepis6tSJOAY3vhA,6754
+pragma_cli/commands/ops.py,sha256=ztx0Gx2L2mEqJQpbgDHgfOUZ4uaD132NxgKohaPOWv8,361
+pragma_cli/commands/providers.py,sha256=Ab7Oh-WGYvl8CauGiG3e2bFJVFo4kB4NbHXsolsFNoo,29265
+pragma_cli/commands/resources.py,sha256=HpgxD-Rx8IWk1CBVwRcxuhEYd8xe0vqSrsPwfzotiJU,16533
+pragma_cli/config.py,sha256=2r9kcBrh700AWF0H3gMIpYX8uXFSe2Yk2T8tuXzjCaU,2984
+pragma_cli/helpers.py,sha256=lR-s_Q7YNuWcPeluHZO3RrsdpKq8ndwWYLSlzRvY35w,1681
+pragma_cli/main.py,sha256=_S2X3QLfuGcULBfwezp4RBK1_PFkHY_L_8j0hZbT2gk,2676
+pragma_cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pragmatiks_cli-0.12.5.dist-info/WHEEL,sha256=XV0cjMrO7zXhVAIyyc8aFf1VjZ33Fen4IiJk5zFlC3g,80
+pragmatiks_cli-0.12.5.dist-info/entry_points.txt,sha256=9xeQQlnHxq94dks6mlJ2I9LuMUKmqxuJzyKSZCb9iJM,48
+pragmatiks_cli-0.12.5.dist-info/METADATA,sha256=E8HFQsJjup_TPTswEsrHq8MFuKm8HpPdt5MoRCZWXF0,4466
+pragmatiks_cli-0.12.5.dist-info/RECORD,,

pragmatiks_cli-0.8.1.dist-info/RECORD

@@ -1,17 +0,0 @@
-pragma_cli/__init__.py,sha256=9REbOdKs9CeuOd-rxeFs17gWtou1dUdCogYU8G5Cz6c,682
-pragma_cli/commands/__init__.py,sha256=zltFPaCZgkeTdOH1YWrUEqqBF9Dg6tokgAFcmqP4_n4,24
-pragma_cli/commands/auth.py,sha256=HSv4mMuA-2QjYDYf69IQd-yXFANr8Uzw-oz3bAy_R0o,9311
-pragma_cli/commands/completions.py,sha256=DwiyVANoYfDIDSNKwgb4QV_tDH2k5RjXgt3Z7TNNi-A,2872
-pragma_cli/commands/config.py,sha256=Bow71Tg_zeprHlbn_6y8g2YsV_k9nRobA6ooYfaxtWE,2281
-pragma_cli/commands/dead_letter.py,sha256=8Mh_QVZiwkbOA1fYkw1O9BeHgPdqepis6tSJOAY3vhA,6754
-pragma_cli/commands/ops.py,sha256=ztx0Gx2L2mEqJQpbgDHgfOUZ4uaD132NxgKohaPOWv8,361
-pragma_cli/commands/providers.py,sha256=5OI1Rlgk4bN8OqMVhCVIQCOo3OqAZStDuV_4YXBgWeg,29168
-pragma_cli/commands/resources.py,sha256=_1Te1HqEayOEcpKIIJPI6ud_yk1F19Uaw-SRNQ8kCSs,7031
-pragma_cli/config.py,sha256=kcU4tJUV1DfnXC_ydQbgQoJzjdGB1s-6-7g4cwA1nZw,2340
-pragma_cli/helpers.py,sha256=dVxokT-sqF08oY0O35QZ64QyNC0PHZEBJYTvZ726UtI,650
-pragma_cli/main.py,sha256=DBclLuSeymcockptWgzX5I1euqrRrHgnrTgGAsF74Xc,1973
-pragma_cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pragmatiks_cli-0.8.1.dist-info/WHEEL,sha256=XV0cjMrO7zXhVAIyyc8aFf1VjZ33Fen4IiJk5zFlC3g,80
-pragmatiks_cli-0.8.1.dist-info/entry_points.txt,sha256=9xeQQlnHxq94dks6mlJ2I9LuMUKmqxuJzyKSZCb9iJM,48
-pragmatiks_cli-0.8.1.dist-info/METADATA,sha256=qQTi7V0AAFGf_EsVWV36cQgslubzeBa0O2mcZmsAyy0,4465
-pragmatiks_cli-0.8.1.dist-info/RECORD,,