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

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,32 +144,288 @@ 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()
-    for res in client.list_resources(provider=provider, resource=resource, tags=tags):
-        print(f"{res['provider']}/{res['resource']}/{res['name']} {format_state(res['lifecycle_state'])}")
+    resources = list(client.list_resources(provider=provider, resource=resource, tags=tags))
+
+    if not 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:
+        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()
@@ -128,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:
@@ -138,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()
@@ -148,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.
+    """Delete a resource.
 
-    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.
-
-    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,21 +1,47 @@
 """CLI entry point with Typer application setup and command routing."""
 
+from importlib.metadata import version as get_version
 from typing import Annotated
 
 import typer
 from pragma_sdk import PragmaClient
 
 from pragma_cli import set_client
-from pragma_cli.commands import auth, config, ops, provider, resources
+from pragma_cli.commands import auth, config, ops, providers, resources
 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)
@@ -61,7 +87,7 @@ app.add_typer(resources.app, name="resources")
 app.add_typer(auth.app, name="auth")
 app.add_typer(config.app, name="config")
 app.add_typer(ops.app, name="ops")
-app.add_typer(provider.app, name="provider")
+app.add_typer(providers.app, name="providers")
 
 if __name__ == "__main__":  # pragma: no cover
     app()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pragmatiks-cli
-Version: 0.5.1
+Version: 0.12.5
 Summary: Command-line interface for Pragmatiks
 Requires-Dist: typer>=0.15.3
 Requires-Dist: pragmatiks-sdk>=0.6.0
@@ -10,19 +10,21 @@ Requires-Dist: rich>=13.9.0
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 
-# Pragmatiks CLI
+<p align="center">
+  <img src="assets/wordmark.png" alt="Pragma-OS" width="800">
+</p>
 
-[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/pragmatiks/cli)
+# Pragma CLI
+
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/pragmatiks/pragma-cli)
 [![PyPI version](https://img.shields.io/pypi/v/pragmatiks-cli.svg)](https://pypi.org/project/pragmatiks-cli/)
 [![Python 3.13+](https://img.shields.io/badge/python-3.13+-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Code style: ruff](https://img.shields.io/badge/code%20style-ruff-000000.svg)](https://github.com/astral-sh/ruff)
 
-**[Documentation](https://docs.pragmatiks.io/cli/overview)** | **[SDK](https://github.com/pragmatiks/sdk)** | **[Providers](https://github.com/pragmatiks/providers)**
-
-Command-line interface for managing Pragmatiks resources.
+**[Documentation](https://docs.pragmatiks.io/cli/overview)** | **[SDK](https://github.com/pragmatiks/pragma-sdk)** | **[Providers](https://github.com/pragmatiks/pragma-providers)**
 
-<!-- TODO: Add logo and demo GIF -->
+Command-line interface for managing pragma-os resources.
 
 ## Quick Start
 

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,,