convexity-cli 0.4.0.dev146__tar.gz

convexity_cli-0.4.0.dev146/.gitignore

@@ -0,0 +1,46 @@
+# Monorepo specific ignores
+node_modules/
+.venv
+*.egg-info/
+back.egg-info/
+/Include
+/share
+/logs
+dist
+/out
+/.mypy_cache
+/.ruff_cache
+/.binaries
+.cache
+.cache_oai
+/uploaded_files
+/code
+db
+/output
+output/
+/coverage
+**/build/
+/.pnp
+.pnp.js
+.DS_Store
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.vercel
+*.css.d.ts
+.env*
+!.env.example
+.env.local
+__pycache__
+coverage.xml
+.coverage
+
+sales-analytics/
+# ducklake
+ducklake_catalog/
+ducklake_data/
+.playwright-mcp
+
+# Generated CLI API client (regenerated via `npm run generate:api`)
+packages/.generated/
+.wrangler

convexity_cli-0.4.0.dev146/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: convexity-cli
+Version: 0.4.0.dev146
+Summary: Convexity CLI - command-line interface for the Convexity platform
+Requires-Python: >=3.12
+Requires-Dist: convexity-api-client<0.5.0,>=0.4.0.dev0
+Requires-Dist: convexity-sdk<0.5.0,>=0.4.0.dev0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic-settings>=2.0.0
+Requires-Dist: pydantic>=2.10.0
+Requires-Dist: pyyaml>=6.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.12.0
+Description-Content-Type: text/markdown
+
+# Convexity CLI
+
+Command-line interface for the Convexity platform.
+
+## Installation
+
+```bash
+pip install convexity-cli
+```
+
+## Usage
+
+```bash
+convexity-cli --help
+```

convexity_cli-0.4.0.dev146/README.md

@@ -0,0 +1,15 @@
+# Convexity CLI
+
+Command-line interface for the Convexity platform.
+
+## Installation
+
+```bash
+pip install convexity-cli
+```
+
+## Usage
+
+```bash
+convexity-cli --help
+```

convexity_cli-0.4.0.dev146/convexity_cli/__init__.py

@@ -0,0 +1,5 @@
+"""Convexity CLI - Command-line interface for managing Convexity projects."""
+
+from importlib.metadata import version as _v
+
+__version__ = _v("convexity-cli")

convexity_cli-0.4.0.dev146/convexity_cli/client.py

@@ -0,0 +1,200 @@
+"""HTTP client for Convexity API.
+
+Provides a wrapper around httpx with API key authentication
+and CLI-specific error handling.
+"""
+
+from typing import Any
+
+import httpx
+
+from convexity_cli.config import get_config
+from convexity_cli.exceptions import (
+    APIError,
+    AuthenticationError,
+    ConflictError,
+    NetworkError,
+    NotFoundError,
+    PermissionError,
+    RateLimitError,
+    ServerError,
+    ValidationError,
+)
+
+
+class ConvexityClient:
+    """HTTP client for Convexity API with API key authentication."""
+
+    def __init__(
+        self,
+        base_url: str | None = None,
+        api_key: str | None = None,
+        timeout: float | None = None,
+    ):
+        """Initialize the client.
+
+        Args:
+            base_url: API base URL (defaults to config)
+            api_key: API key for authentication (defaults to config)
+            timeout: Request timeout in seconds (defaults to config)
+        """
+        config = get_config()
+
+        self.base_url = (base_url or config.get_base_url()).rstrip("/")
+        self.api_key = api_key or config.get_api_key()
+        self.timeout = timeout or config.get_timeout()
+        self._client: httpx.Client | None = None
+
+    @property
+    def client(self) -> httpx.Client:
+        """Lazy initialization of HTTP client."""
+        if self._client is None:
+            if not self.api_key:
+                raise AuthenticationError("No API key configured. Run 'convexity auth login' or set CONVEXITY_API_KEY.")
+
+            self._client = httpx.Client(
+                base_url=self.base_url,
+                timeout=self.timeout,
+                headers={
+                    "X-API-Key": self.api_key,
+                    "Content-Type": "application/json",
+                    "Accept": "application/json",
+                },
+            )
+        return self._client
+
+    def close(self) -> None:
+        """Close the HTTP client."""
+        if self._client is not None:
+            self._client.close()
+            self._client = None
+
+    def __enter__(self) -> "ConvexityClient":
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.close()
+
+    def _handle_response(self, response: httpx.Response) -> Any:
+        """Handle API response and raise appropriate exceptions.
+
+        Args:
+            response: HTTP response
+
+        Returns:
+            Parsed JSON response data
+
+        Raises:
+            Various CLI exceptions based on status code
+        """
+        if response.status_code >= 200 and response.status_code < 300:
+            if response.status_code == 204:
+                return None
+            try:
+                return response.json()
+            except Exception:
+                return response.text
+
+        # Parse error response
+        try:
+            error_data = response.json()
+            error_message = error_data.get("detail", str(error_data))
+        except Exception:
+            error_message = response.text or f"HTTP {response.status_code}"
+
+        # Map status codes to exceptions
+        status = response.status_code
+
+        if status == 401:
+            raise AuthenticationError(error_message)
+        elif status == 403:
+            raise PermissionError(error_message)
+        elif status == 404:
+            raise NotFoundError(message=error_message)
+        elif status == 409:
+            raise ConflictError(error_message)
+        elif status == 422:
+            errors = []
+            if isinstance(error_data, dict) and "detail" in error_data:
+                detail = error_data["detail"]
+                if isinstance(detail, list):
+                    errors = detail
+            raise ValidationError(error_message, errors=errors)
+        elif status == 429:
+            retry_after = response.headers.get("Retry-After")
+            raise RateLimitError(
+                error_message,
+                retry_after=int(retry_after) if retry_after else None,
+            )
+        elif status >= 500:
+            raise ServerError(error_message, status_code=status)
+        else:
+            raise APIError(error_message, status_code=status)
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        params: dict[str, Any] | None = None,
+        json_data: dict[str, Any] | None = None,
+    ) -> Any:
+        """Make an HTTP request.
+
+        Args:
+            method: HTTP method (GET, POST, PATCH, DELETE)
+            path: API path (will be appended to base_url)
+            params: Query parameters
+            json_data: JSON body data
+
+        Returns:
+            Parsed response data
+        """
+        try:
+            response = self.client.request(
+                method=method,
+                url=path,
+                params=params,
+                json=json_data,
+            )
+            return self._handle_response(response)
+        except httpx.ConnectError as e:
+            raise NetworkError(f"Failed to connect to {self.base_url}: {e}")
+        except httpx.TimeoutException as e:
+            raise NetworkError(f"Request timed out: {e}")
+        except httpx.RequestError as e:
+            raise NetworkError(f"Request failed: {e}")
+
+    def get(self, path: str, params: dict[str, Any] | None = None) -> Any:
+        """Make a GET request."""
+        return self._request("GET", path, params=params)
+
+    def post(
+        self,
+        path: str,
+        data: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+    ) -> Any:
+        """Make a POST request."""
+        return self._request("POST", path, params=params, json_data=data)
+
+    def patch(
+        self,
+        path: str,
+        data: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+    ) -> Any:
+        """Make a PATCH request."""
+        return self._request("PATCH", path, params=params, json_data=data)
+
+    def delete(self, path: str, params: dict[str, Any] | None = None) -> Any:
+        """Make a DELETE request."""
+        return self._request("DELETE", path, params=params)
+
+    # =========================================================================
+    # Organization methods
+    # =========================================================================
+
+    def list_organizations(self) -> list[dict[str, Any]]:
+        """List all organizations the user has access to."""
+        response = self.get("/v1/organizations")
+        return response.get("items", []) if isinstance(response, dict) else response

convexity_cli-0.4.0.dev146/convexity_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI commands for Convexity."""

convexity_cli-0.4.0.dev146/convexity_cli/commands/org.py

@@ -0,0 +1,117 @@
+"""Organization management commands for Convexity CLI.
+
+Commands:
+    list   - List all organizations the user has access to
+    create - Create a new organization
+    delete - Delete an organization
+    show   - Show details of an organization
+"""
+
+from typing import Annotated
+
+from convexity_api_client.api.v1 import (
+    create_organization_v1_organizations_post,
+    delete_organization_v1_organizations_organization_id_delete,
+    get_organization_v1_organizations_organization_id_get,
+    list_organizations_v1_organizations_get,
+)
+from convexity_api_client.models import CreateOrganizationRequest
+import typer
+
+from convexity_cli.commands.utils import get_authenticated_client
+from convexity_cli.exceptions import APIError
+from convexity_cli.output import output_json, output_list, output_success
+
+app = typer.Typer(
+    name="org",
+    help="Manage organizations.",
+    no_args_is_help=True,
+    rich_markup_mode=None,
+)
+
+
+@app.command("list")
+def list_organizations() -> None:
+    """List all organizations the user has access to."""
+    with get_authenticated_client() as client:
+        response = list_organizations_v1_organizations_get.sync_detailed(client=client)
+
+        if response.status_code == 200 and response.parsed:
+            orgs = [org.to_dict() for org in response.parsed.organizations]
+            output_list(orgs)
+        else:
+            raise APIError(f"Failed to list organizations: {response.status_code}")
+
+
+@app.command("create")
+def create_organization(
+    name: Annotated[str, typer.Argument(help="Organization name")],
+    slug: Annotated[
+        str,
+        typer.Option("--slug", "-s", help="Organization slug (URL-friendly identifier)"),
+    ],
+    description: Annotated[
+        str | None,
+        typer.Option("--description", "-d", help="Organization description"),
+    ] = None,
+) -> None:
+    """Create a new organization."""
+    with get_authenticated_client() as client:
+        request = CreateOrganizationRequest(
+            name=name,
+            slug=slug,
+            description=description,
+        )
+
+        response = create_organization_v1_organizations_post.sync_detailed(
+            client=client,
+            body=request,
+        )
+
+        if response.status_code == 201 and response.parsed:
+            output_json(response.parsed.to_dict())
+        else:
+            raise APIError(f"Failed to create organization: {response.status_code}")
+
+
+@app.command("delete")
+def delete_organization(
+    org_id: Annotated[str, typer.Argument(help="Organization ID to delete")],
+    force: Annotated[
+        bool,
+        typer.Option("--force", "-f", help="Skip confirmation prompt"),
+    ] = False,
+) -> None:
+    """Delete an organization."""
+    if not force:
+        confirm = typer.confirm(f"Are you sure you want to delete organization '{org_id}'? This cannot be undone.")
+        if not confirm:
+            raise typer.Abort()
+
+    with get_authenticated_client() as client:
+        response = delete_organization_v1_organizations_organization_id_delete.sync_detailed(
+            organization_id=org_id,
+            client=client,
+        )
+
+        if response.status_code in (200, 204):
+            output_success(f"Organization '{org_id}' deleted successfully")
+        else:
+            raise APIError(f"Failed to delete organization: {response.status_code}")
+
+
+@app.command("show")
+def show_organization(
+    org_id: Annotated[str, typer.Argument(help="Organization ID")],
+) -> None:
+    """Show details of an organization."""
+    with get_authenticated_client() as client:
+        response = get_organization_v1_organizations_organization_id_get.sync_detailed(
+            organization_id=org_id,
+            client=client,
+        )
+
+        if response.status_code == 200 and response.parsed:
+            output_json(response.parsed.to_dict())
+        else:
+            raise APIError(f"Failed to get organization: {response.status_code}")