cassis-cli 0.1.0__tar.gz → 0.2.0__tar.gz

cassis_cli-0.2.0/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: cassis-cli
+Version: 0.2.0
+Summary: Cassis CLI — run Cassis actions (ontology validation, upload and publish) from your CI pipelines
+License: Proprietary
+Keywords: cassis,ontology,ci,text-to-sql
+Author: Cassis
+Author-email: tech.admin@getcassis.com
+Requires-Python: >=3.10,<4.0
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: httpx (>=0.24,<1.0)
+Requires-Dist: typer (>=0.12,<1.0)
+Description-Content-Type: text/markdown
+
+# Cassis CLI
+
+Run Cassis actions from your CI pipelines:
+
+- `cassis ontology check` validates the ontology files in your repository with the exact same checks as the Cassis GitHub PR check (YAML parsing, round-trip, import validation) — so you can gate merges in any CI system, not just GitHub.
+- `cassis ontology upload` uploads the ontology files to a Cassis project (full replace) and, by default, publishes them immediately as a new version — so a merge to your main branch can go live in one CI step.
+
+## Install
+
+```bash
+pip install cassis-cli
+```
+
+## Setup
+
+1. Create an API key in Cassis under **Organization settings → API keys** (keys start with `sk-k6-`).
+2. Store it as a CI secret and expose it as `CASSIS_API_KEY`.
+3. For `upload`: find the project ID (UUID) in the project's URL and expose it as `CASSIS_PROJECT_ID` (or pass `--project`).
+
+## Usage
+
+```bash
+# From the root of a repository synced with Cassis (contains the ontology export directory, cassis/ by default):
+cassis ontology check
+
+# Or point at the checkout explicitly:
+cassis ontology check /path/to/checkout
+
+# Upload the ontology to a project and publish it immediately:
+cassis ontology upload --project 019f0000-0000-7000-8000-000000000000
+
+# Upload without publishing (the tree becomes the project's unpublished ontology, to review in Cassis):
+cassis ontology upload --project ... --no-publish
+
+# Label the published version:
+cassis ontology upload --project ... --label "release 1.2"
+
+# Machine-readable output:
+cassis ontology check --json
+cassis ontology upload --project ... --json
+```
+
+Configuration (flags take precedence over env vars):
+
+| Flag        | Env var          | Default                     |
+| ----------- | ---------------- | --------------------------- |
+| `--api-key` | `CASSIS_API_KEY` | — (required)                |
+| `--api-url` | `CASSIS_API_URL` | `https://app.getcassis.com` |
+| `--base-path` | `CASSIS_BASE_PATH` | `cassis` — must match the project's git-sync "Path" setting |
+| `--project` (upload only) | `CASSIS_PROJECT_ID` | — (required)      |
+
+### Exit codes
+
+| Code | Meaning                                                                        |
+| ---- | ------------------------------------------------------------------------------ |
+| 0    | Ontology is valid (check) / uploaded (upload)                                  |
+| 1    | Validation failed (check: findings printed; upload: nothing imported)          |
+| 2    | Usage error (missing API key or project, no ontology directory, unreadable file, tree over the size limits) |
+| 3    | Transport/API error (unreachable API, invalid key, inaccessible project, unexpected response) |
+
+Both commands accept up to 2000 YAML files / 5 MB total — far above real
+ontologies (a few hundred small files). Beyond that the CLI fails fast with
+exit 2 before uploading anything; double-check `--base-path` if you hit it.
+
+`upload` replaces the project's entire ontology with the uploaded tree. A
+never-published project always goes live immediately on first upload (even
+with `--no-publish`), matching imports from the Cassis app. Publishing is
+idempotent: re-uploading content identical to the published version reports
+that version instead of creating a new one, so re-running the CI job on
+unchanged files is a no-op.
+
+### GitHub Actions example
+
+```yaml
+jobs:
+  ontology-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install cassis-cli
+      - run: cassis ontology check
+        env:
+          CASSIS_API_KEY: ${{ secrets.CASSIS_API_KEY }}
+
+  ontology-publish:
+    runs-on: ubuntu-latest
+    if: github.ref == 'refs/heads/main'
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install cassis-cli
+      - run: cassis ontology upload
+        env:
+          CASSIS_API_KEY: ${{ secrets.CASSIS_API_KEY }}
+          CASSIS_PROJECT_ID: ${{ vars.CASSIS_PROJECT_ID }}
+```
+
+### GitLab CI example
+
+```yaml
+ontology-check:
+  image: python:3.12-slim
+  script:
+    - pip install cassis-cli
+    - cassis ontology check
+  variables:
+    CASSIS_API_KEY: $CASSIS_API_KEY
+
+ontology-publish:
+  image: python:3.12-slim
+  rules:
+    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+  script:
+    - pip install cassis-cli
+    - cassis ontology upload
+  variables:
+    CASSIS_API_KEY: $CASSIS_API_KEY
+    CASSIS_PROJECT_ID: $CASSIS_PROJECT_ID
+```
+

cassis_cli-0.2.0/README.md

@@ -0,0 +1,124 @@
+# Cassis CLI
+
+Run Cassis actions from your CI pipelines:
+
+- `cassis ontology check` validates the ontology files in your repository with the exact same checks as the Cassis GitHub PR check (YAML parsing, round-trip, import validation) — so you can gate merges in any CI system, not just GitHub.
+- `cassis ontology upload` uploads the ontology files to a Cassis project (full replace) and, by default, publishes them immediately as a new version — so a merge to your main branch can go live in one CI step.
+
+## Install
+
+```bash
+pip install cassis-cli
+```
+
+## Setup
+
+1. Create an API key in Cassis under **Organization settings → API keys** (keys start with `sk-k6-`).
+2. Store it as a CI secret and expose it as `CASSIS_API_KEY`.
+3. For `upload`: find the project ID (UUID) in the project's URL and expose it as `CASSIS_PROJECT_ID` (or pass `--project`).
+
+## Usage
+
+```bash
+# From the root of a repository synced with Cassis (contains the ontology export directory, cassis/ by default):
+cassis ontology check
+
+# Or point at the checkout explicitly:
+cassis ontology check /path/to/checkout
+
+# Upload the ontology to a project and publish it immediately:
+cassis ontology upload --project 019f0000-0000-7000-8000-000000000000
+
+# Upload without publishing (the tree becomes the project's unpublished ontology, to review in Cassis):
+cassis ontology upload --project ... --no-publish
+
+# Label the published version:
+cassis ontology upload --project ... --label "release 1.2"
+
+# Machine-readable output:
+cassis ontology check --json
+cassis ontology upload --project ... --json
+```
+
+Configuration (flags take precedence over env vars):
+
+| Flag        | Env var          | Default                     |
+| ----------- | ---------------- | --------------------------- |
+| `--api-key` | `CASSIS_API_KEY` | — (required)                |
+| `--api-url` | `CASSIS_API_URL` | `https://app.getcassis.com` |
+| `--base-path` | `CASSIS_BASE_PATH` | `cassis` — must match the project's git-sync "Path" setting |
+| `--project` (upload only) | `CASSIS_PROJECT_ID` | — (required)      |
+
+### Exit codes
+
+| Code | Meaning                                                                        |
+| ---- | ------------------------------------------------------------------------------ |
+| 0    | Ontology is valid (check) / uploaded (upload)                                  |
+| 1    | Validation failed (check: findings printed; upload: nothing imported)          |
+| 2    | Usage error (missing API key or project, no ontology directory, unreadable file, tree over the size limits) |
+| 3    | Transport/API error (unreachable API, invalid key, inaccessible project, unexpected response) |
+
+Both commands accept up to 2000 YAML files / 5 MB total — far above real
+ontologies (a few hundred small files). Beyond that the CLI fails fast with
+exit 2 before uploading anything; double-check `--base-path` if you hit it.
+
+`upload` replaces the project's entire ontology with the uploaded tree. A
+never-published project always goes live immediately on first upload (even
+with `--no-publish`), matching imports from the Cassis app. Publishing is
+idempotent: re-uploading content identical to the published version reports
+that version instead of creating a new one, so re-running the CI job on
+unchanged files is a no-op.
+
+### GitHub Actions example
+
+```yaml
+jobs:
+  ontology-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install cassis-cli
+      - run: cassis ontology check
+        env:
+          CASSIS_API_KEY: ${{ secrets.CASSIS_API_KEY }}
+
+  ontology-publish:
+    runs-on: ubuntu-latest
+    if: github.ref == 'refs/heads/main'
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install cassis-cli
+      - run: cassis ontology upload
+        env:
+          CASSIS_API_KEY: ${{ secrets.CASSIS_API_KEY }}
+          CASSIS_PROJECT_ID: ${{ vars.CASSIS_PROJECT_ID }}
+```
+
+### GitLab CI example
+
+```yaml
+ontology-check:
+  image: python:3.12-slim
+  script:
+    - pip install cassis-cli
+    - cassis ontology check
+  variables:
+    CASSIS_API_KEY: $CASSIS_API_KEY
+
+ontology-publish:
+  image: python:3.12-slim
+  rules:
+    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+  script:
+    - pip install cassis-cli
+    - cassis ontology upload
+  variables:
+    CASSIS_API_KEY: $CASSIS_API_KEY
+    CASSIS_PROJECT_ID: $CASSIS_PROJECT_ID
+```

{cassis_cli-0.1.0 → cassis_cli-0.2.0}/cassis_cli/__init__.py

@@ -1,3 +1,3 @@
 """Cassis CLI — run Cassis actions from your CI pipelines."""
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"

cassis_cli-0.2.0/cassis_cli/api.py

@@ -0,0 +1,113 @@
+"""Thin HTTP client for the Cassis API."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+import httpx
+
+DEFAULT_API_URL = "https://app.getcassis.com"
+TIMEOUT_SECONDS = 60.0
+
+
+class ApiError(Exception):
+    """Transport or HTTP-level failure talking to the Cassis API."""
+
+
+class AuthError(ApiError):
+    """The API rejected the API key (401)."""
+
+
+class UploadValidationError(ApiError):
+    """The API rejected the uploaded ontology tree as invalid (400)."""
+
+
+def post_ontology_check(
+    *,
+    api_url: str,
+    api_key: str,
+    files: dict[str, str],
+    transport: Optional[httpx.BaseTransport] = None,
+) -> dict[str, Any]:
+    """POST the ontology tree to /api/ci/ontology-check and return the response body."""
+    url = api_url.rstrip("/") + "/api/ci/ontology-check"
+    try:
+        with httpx.Client(timeout=TIMEOUT_SECONDS, transport=transport) as client:
+            response = client.post(
+                url,
+                json={"files": files},
+                headers={"Authorization": f"Bearer {api_key}"},
+            )
+    except httpx.HTTPError as exc:
+        raise ApiError(f"Could not reach the Cassis API at {url}: {exc}") from exc
+
+    if response.status_code == 401:
+        raise AuthError("The Cassis API rejected the API key (invalid or expired).")
+    if response.status_code >= 400:
+        raise ApiError(f"Cassis API returned HTTP {response.status_code}: {response.text[:500]}")
+    try:
+        result = response.json()
+    except ValueError as exc:  # json.JSONDecodeError — e.g. a proxy or portal answering HTML with a 200
+        raise ApiError(
+            f"The Cassis API at {url} returned a non-JSON response — check the API URL and any proxy in between."
+        ) from exc
+    if (
+        not isinstance(result, dict)
+        or not all(key in result for key in ("passed", "title", "summary"))
+        or not isinstance(result.get("findings"), list)
+    ):
+        raise ApiError(f"Unexpected response shape from the Cassis API at {url}.")
+    return result
+
+
+def post_ontology_import(
+    *,
+    api_url: str,
+    api_key: str,
+    project_id: str,
+    files: dict[str, str],
+    publish: bool,
+    label: Optional[str] = None,
+    transport: Optional[httpx.BaseTransport] = None,
+) -> dict[str, Any]:
+    """POST the ontology tree to /api/ci/projects/{project_id}/ontology/import and return the response body."""
+    url = api_url.rstrip("/") + f"/api/ci/projects/{project_id}/ontology/import"
+    body: dict[str, Any] = {"files": files, "publish": publish}
+    if label is not None:
+        body["label"] = label
+    try:
+        with httpx.Client(timeout=TIMEOUT_SECONDS, transport=transport) as client:
+            response = client.post(
+                url,
+                json=body,
+                headers={"Authorization": f"Bearer {api_key}"},
+            )
+    except httpx.HTTPError as exc:
+        raise ApiError(f"Could not reach the Cassis API at {url}: {exc}") from exc
+
+    if response.status_code == 401:
+        raise AuthError("The Cassis API rejected the API key (invalid or expired).")
+    if response.status_code == 400:
+        try:
+            detail = response.json().get("detail") or response.text[:500]
+        except ValueError:
+            detail = response.text[:500]
+        raise UploadValidationError(str(detail))
+    if response.status_code in (403, 404):
+        raise ApiError(
+            f"Project not found or not accessible (HTTP {response.status_code}). Check --project and that "
+            "the API key belongs to the project's organization and can edit it."
+        )
+    if response.status_code >= 400:
+        raise ApiError(f"Cassis API returned HTTP {response.status_code}: {response.text[:500]}")
+    try:
+        result = response.json()
+    except ValueError as exc:  # json.JSONDecodeError — e.g. a proxy or portal answering HTML with a 200
+        raise ApiError(
+            f"The Cassis API at {url} returned a non-JSON response — check the API URL and any proxy in between."
+        ) from exc
+    if not isinstance(result, dict) or not all(
+        key in result for key in ("domain_count", "table_count", "join_count", "metric_count", "published_version")
+    ):
+        raise ApiError(f"Unexpected response shape from the Cassis API at {url}.")
+    return result

{cassis_cli-0.1.0 → cassis_cli-0.2.0}/cassis_cli/ontology.py

@@ -5,9 +5,17 @@ from __future__ import annotations
 import json
 from pathlib import Path
 from typing import Optional
+from uuid import UUID
 
 import typer
-from cassis_cli.api import DEFAULT_API_URL, ApiError, AuthError, post_ontology_check
+from cassis_cli.api import (
+    DEFAULT_API_URL,
+    ApiError,
+    AuthError,
+    UploadValidationError,
+    post_ontology_check,
+    post_ontology_import,
+)
 
 app = typer.Typer(no_args_is_help=True, help="Ontology commands.")
 
@@ -46,38 +54,8 @@ def _collect_files(ontology_dir: Path) -> dict[str, str]:
     return files
 
 
-@app.command()
-def check(
-    path: Path = typer.Argument(
-        Path("."),
-        help="Repository checkout root (the directory containing the ontology export path).",
-    ),
-    api_key: Optional[str] = typer.Option(
-        None,
-        "--api-key",
-        envvar="CASSIS_API_KEY",
-        help="Cassis API key (sk-k6-...). Create one in Organization settings -> API keys.",
-    ),
-    api_url: str = typer.Option(
-        DEFAULT_API_URL,
-        "--api-url",
-        envvar="CASSIS_API_URL",
-        help="Cassis API base URL.",
-    ),
-    base_path: str = typer.Option(
-        DEFAULT_BASE_PATH,
-        "--base-path",
-        envvar="CASSIS_BASE_PATH",
-        help="Repository directory the ontology is exported under (the project's git-sync Path setting).",
-    ),
-    json_output: bool = typer.Option(False, "--json", help="Print the raw JSON response."),
-) -> None:
-    """Validate the ontology files in a repository checkout.
-
-    Runs the same checks as the Cassis GitHub PR check (YAML parsing,
-    round-trip, import validation). Exits 0 when valid, 1 when validation
-    fails, 2 on usage errors, 3 on transport/API errors.
-    """
+def _require_api_key(api_key: Optional[str]) -> str:
+    """Exit 2 (usage) when no API key was provided."""
     if not api_key:
         typer.secho(
             "No API key. Set CASSIS_API_KEY or pass --api-key "
@@ -86,7 +64,16 @@ def check(
             err=True,
         )
         raise typer.Exit(EXIT_USAGE)
+    return api_key
+
+
+def _collect_tree(path: Path, base_path: str) -> "tuple[dict[str, str], str]":
+    """Resolve the ontology dir under the checkout and read its YAML tree.
 
+    Returns ``(files, normalized_base_path)``. Exits 2 (usage) on an empty or
+    missing dir, or a tree beyond the API request ceilings — all local checkout
+    problems, reported before anything is sent to the API.
+    """
     base_path = base_path.strip().strip("/")
     if not base_path:
         typer.secho("--base-path must not be empty.", fg=typer.colors.RED, err=True)
@@ -110,13 +97,50 @@ def check(
     total_bytes = sum(len(content.encode()) for content in files.values())
     if len(files) > MAX_FILES or total_bytes > MAX_TOTAL_BYTES:
         typer.secho(
-            f"Ontology tree too large for the CI check: {len(files)} files / {total_bytes / (1024 * 1024):.1f} MB "
+            f"Ontology tree too large: {len(files)} files / {total_bytes / (1024 * 1024):.1f} MB "
             f"(limits: {MAX_FILES} files / {MAX_TOTAL_BYTES // (1024 * 1024)} MB). "
             "Check that --base-path points at the ontology directory, not a larger tree.",
             fg=typer.colors.RED,
             err=True,
         )
         raise typer.Exit(EXIT_USAGE)
+    return files, base_path
+
+
+@app.command()
+def check(
+    path: Path = typer.Argument(
+        Path("."),
+        help="Repository checkout root (the directory containing the ontology export path).",
+    ),
+    api_key: Optional[str] = typer.Option(
+        None,
+        "--api-key",
+        envvar="CASSIS_API_KEY",
+        help="Cassis API key (sk-k6-...). Create one in Organization settings -> API keys.",
+    ),
+    api_url: str = typer.Option(
+        DEFAULT_API_URL,
+        "--api-url",
+        envvar="CASSIS_API_URL",
+        help="Cassis API base URL.",
+    ),
+    base_path: str = typer.Option(
+        DEFAULT_BASE_PATH,
+        "--base-path",
+        envvar="CASSIS_BASE_PATH",
+        help="Repository directory the ontology is exported under (the project's git-sync Path setting).",
+    ),
+    json_output: bool = typer.Option(False, "--json", help="Print the raw JSON response."),
+) -> None:
+    """Validate the ontology files in a repository checkout.
+
+    Runs the same checks as the Cassis GitHub PR check (YAML parsing,
+    round-trip, import validation). Exits 0 when valid, 1 when validation
+    fails, 2 on usage errors, 3 on transport/API errors.
+    """
+    api_key = _require_api_key(api_key)
+    files, base_path = _collect_tree(path, base_path)
 
     try:
         result = post_ontology_check(api_url=api_url, api_key=api_key, files=files)
@@ -139,3 +163,94 @@ def check(
             typer.echo(f"  {location}{finding.get('message', '')} ({finding.get('stage', '?')})")
 
     raise typer.Exit(EXIT_OK if result["passed"] else EXIT_VALIDATION_FAILED)
+
+
+@app.command()
+def upload(
+    path: Path = typer.Argument(
+        Path("."),
+        help="Repository checkout root (the directory containing the ontology export path).",
+    ),
+    project_id: str = typer.Option(
+        ...,
+        "--project",
+        envvar="CASSIS_PROJECT_ID",
+        help="Target Cassis project ID (UUID, shown in the project's URL).",
+    ),
+    api_key: Optional[str] = typer.Option(
+        None,
+        "--api-key",
+        envvar="CASSIS_API_KEY",
+        help="Cassis API key (sk-k6-...). Create one in Organization settings -> API keys.",
+    ),
+    api_url: str = typer.Option(
+        DEFAULT_API_URL,
+        "--api-url",
+        envvar="CASSIS_API_URL",
+        help="Cassis API base URL.",
+    ),
+    base_path: str = typer.Option(
+        DEFAULT_BASE_PATH,
+        "--base-path",
+        envvar="CASSIS_BASE_PATH",
+        help="Repository directory the ontology is exported under (the project's git-sync Path setting).",
+    ),
+    publish: bool = typer.Option(
+        True,
+        "--publish/--no-publish",
+        help="Publish the uploaded ontology immediately as a new version (default: publish).",
+    ),
+    label: Optional[str] = typer.Option(None, "--label", help="Label for the published version."),
+    json_output: bool = typer.Option(False, "--json", help="Print the raw JSON response."),
+) -> None:
+    """Upload the ontology files in a repository checkout to a Cassis project.
+
+    Replaces the project's unpublished ontology with the local tree (full
+    replace) and, unless --no-publish is passed, publishes it immediately as a
+    new version. Exits 0 on success, 1 when the tree fails validation, 2 on
+    usage errors, 3 on transport/API errors.
+    """
+    api_key = _require_api_key(api_key)
+    try:
+        UUID(project_id)
+    except ValueError:
+        typer.secho(f"--project must be a project ID (UUID), got {project_id!r}.", fg=typer.colors.RED, err=True)
+        raise typer.Exit(EXIT_USAGE)
+    files, base_path = _collect_tree(path, base_path)
+
+    try:
+        result = post_ontology_import(
+            api_url=api_url,
+            api_key=api_key,
+            project_id=project_id,
+            files=files,
+            publish=publish,
+            label=label,
+        )
+    except AuthError as exc:
+        typer.secho(str(exc), fg=typer.colors.RED, err=True)
+        raise typer.Exit(EXIT_TRANSPORT) from exc
+    except UploadValidationError as exc:
+        typer.secho("Ontology upload rejected:", fg=typer.colors.RED, bold=True, err=True)
+        typer.secho(str(exc), fg=typer.colors.RED, err=True)
+        raise typer.Exit(EXIT_VALIDATION_FAILED) from exc
+    except ApiError as exc:
+        typer.secho(str(exc), fg=typer.colors.RED, err=True)
+        raise typer.Exit(EXIT_TRANSPORT) from exc
+
+    if json_output:
+        typer.echo(json.dumps(result, indent=2))
+    else:
+        counts = (
+            f"{result['table_count']} tables, {result['domain_count']} domains, "
+            f"{result['join_count']} joins, {result['metric_count']} metrics"
+        )
+        version = result.get("published_version")
+        if version is not None:
+            typer.secho(f"✓ Ontology uploaded and published as v{version} ({counts}).", fg=typer.colors.GREEN)
+        else:
+            typer.secho(
+                f"✓ Ontology uploaded ({counts}). Not published — it is now the project's unpublished ontology.",
+                fg=typer.colors.GREEN,
+            )
+    raise typer.Exit(EXIT_OK)

{cassis_cli-0.1.0 → cassis_cli-0.2.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "cassis-cli"
-version = "0.1.0"
-description = "Cassis CLI — run Cassis actions (ontology validation) from your CI pipelines"
+version = "0.2.0"
+description = "Cassis CLI — run Cassis actions (ontology validation, upload and publish) from your CI pipelines"
 readme = "README.md"
 license = { text = "Proprietary" }
 authors = [{ name = "Cassis", email = "tech.admin@getcassis.com" }]

cassis_cli-0.1.0/PKG-INFO

@@ -1,98 +0,0 @@
-Metadata-Version: 2.4
-Name: cassis-cli
-Version: 0.1.0
-Summary: Cassis CLI — run Cassis actions (ontology validation) from your CI pipelines
-License: Proprietary
-Keywords: cassis,ontology,ci,text-to-sql
-Author: Cassis
-Author-email: tech.admin@getcassis.com
-Requires-Python: >=3.10,<4.0
-Classifier: License :: Other/Proprietary License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Requires-Dist: httpx (>=0.24,<1.0)
-Requires-Dist: typer (>=0.12,<1.0)
-Description-Content-Type: text/markdown
-
-# Cassis CLI
-
-Run Cassis actions from your CI pipelines. The first command, `cassis ontology check`, validates the ontology files in your repository with the exact same checks as the Cassis GitHub PR check (YAML parsing, round-trip, import validation) — so you can gate merges in any CI system, not just GitHub.
-
-## Install
-
-```bash
-pip install cassis-cli
-```
-
-## Setup
-
-1. Create an API key in Cassis under **Organization settings → API keys** (keys start with `sk-k6-`).
-2. Store it as a CI secret and expose it as `CASSIS_API_KEY`.
-
-## Usage
-
-```bash
-# From the root of a repository synced with Cassis (contains the ontology export directory, cassis/ by default):
-cassis ontology check
-
-# Or point at the checkout explicitly:
-cassis ontology check /path/to/checkout
-
-# Machine-readable output:
-cassis ontology check --json
-```
-
-Configuration (flags take precedence over env vars):
-
-| Flag        | Env var          | Default                     |
-| ----------- | ---------------- | --------------------------- |
-| `--api-key` | `CASSIS_API_KEY` | — (required)                |
-| `--api-url` | `CASSIS_API_URL` | `https://app.getcassis.com` |
-| `--base-path` | `CASSIS_BASE_PATH` | `cassis` — must match the project's git-sync "Path" setting |
-
-### Exit codes
-
-| Code | Meaning                                                                        |
-| ---- | ------------------------------------------------------------------------------ |
-| 0    | Ontology is valid                                                              |
-| 1    | Validation failed (findings printed)                                           |
-| 2    | Usage error (missing API key, no ontology directory, unreadable file, tree over the size limits) |
-| 3    | Transport/API error (unreachable API, invalid key, unexpected response)        |
-
-The check accepts up to 2000 YAML files / 5 MB total — far above real
-ontologies (a few hundred small files). Beyond that the CLI fails fast with
-exit 2 before uploading anything; double-check `--base-path` if you hit it.
-
-### GitHub Actions example
-
-```yaml
-jobs:
-  ontology-check:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: "3.12"
-      - run: pip install cassis-cli
-      - run: cassis ontology check
-        env:
-          CASSIS_API_KEY: ${{ secrets.CASSIS_API_KEY }}
-```
-
-### GitLab CI example
-
-```yaml
-ontology-check:
-  image: python:3.12-slim
-  script:
-    - pip install cassis-cli
-    - cassis ontology check
-  variables:
-    CASSIS_API_KEY: $CASSIS_API_KEY
-```
-

cassis_cli-0.1.0/README.md

@@ -1,77 +0,0 @@
-# Cassis CLI
-
-Run Cassis actions from your CI pipelines. The first command, `cassis ontology check`, validates the ontology files in your repository with the exact same checks as the Cassis GitHub PR check (YAML parsing, round-trip, import validation) — so you can gate merges in any CI system, not just GitHub.
-
-## Install
-
-```bash
-pip install cassis-cli
-```
-
-## Setup
-
-1. Create an API key in Cassis under **Organization settings → API keys** (keys start with `sk-k6-`).
-2. Store it as a CI secret and expose it as `CASSIS_API_KEY`.
-
-## Usage
-
-```bash
-# From the root of a repository synced with Cassis (contains the ontology export directory, cassis/ by default):
-cassis ontology check
-
-# Or point at the checkout explicitly:
-cassis ontology check /path/to/checkout
-
-# Machine-readable output:
-cassis ontology check --json
-```
-
-Configuration (flags take precedence over env vars):
-
-| Flag        | Env var          | Default                     |
-| ----------- | ---------------- | --------------------------- |
-| `--api-key` | `CASSIS_API_KEY` | — (required)                |
-| `--api-url` | `CASSIS_API_URL` | `https://app.getcassis.com` |
-| `--base-path` | `CASSIS_BASE_PATH` | `cassis` — must match the project's git-sync "Path" setting |
-
-### Exit codes
-
-| Code | Meaning                                                                        |
-| ---- | ------------------------------------------------------------------------------ |
-| 0    | Ontology is valid                                                              |
-| 1    | Validation failed (findings printed)                                           |
-| 2    | Usage error (missing API key, no ontology directory, unreadable file, tree over the size limits) |
-| 3    | Transport/API error (unreachable API, invalid key, unexpected response)        |
-
-The check accepts up to 2000 YAML files / 5 MB total — far above real
-ontologies (a few hundred small files). Beyond that the CLI fails fast with
-exit 2 before uploading anything; double-check `--base-path` if you hit it.
-
-### GitHub Actions example
-
-```yaml
-jobs:
-  ontology-check:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: "3.12"
-      - run: pip install cassis-cli
-      - run: cassis ontology check
-        env:
-          CASSIS_API_KEY: ${{ secrets.CASSIS_API_KEY }}
-```
-
-### GitLab CI example
-
-```yaml
-ontology-check:
-  image: python:3.12-slim
-  script:
-    - pip install cassis-cli
-    - cassis ontology check
-  variables:
-    CASSIS_API_KEY: $CASSIS_API_KEY
-```

cassis_cli-0.1.0/cassis_cli/api.py

@@ -1,56 +0,0 @@
-"""Thin HTTP client for the Cassis API."""
-
-from __future__ import annotations
-
-from typing import Any, Optional
-
-import httpx
-
-DEFAULT_API_URL = "https://app.getcassis.com"
-TIMEOUT_SECONDS = 60.0
-
-
-class ApiError(Exception):
-    """Transport or HTTP-level failure talking to the Cassis API."""
-
-
-class AuthError(ApiError):
-    """The API rejected the API key (401)."""
-
-
-def post_ontology_check(
-    *,
-    api_url: str,
-    api_key: str,
-    files: dict[str, str],
-    transport: Optional[httpx.BaseTransport] = None,
-) -> dict[str, Any]:
-    """POST the ontology tree to /api/ci/ontology-check and return the response body."""
-    url = api_url.rstrip("/") + "/api/ci/ontology-check"
-    try:
-        with httpx.Client(timeout=TIMEOUT_SECONDS, transport=transport) as client:
-            response = client.post(
-                url,
-                json={"files": files},
-                headers={"Authorization": f"Bearer {api_key}"},
-            )
-    except httpx.HTTPError as exc:
-        raise ApiError(f"Could not reach the Cassis API at {url}: {exc}") from exc
-
-    if response.status_code == 401:
-        raise AuthError("The Cassis API rejected the API key (invalid or expired).")
-    if response.status_code >= 400:
-        raise ApiError(f"Cassis API returned HTTP {response.status_code}: {response.text[:500]}")
-    try:
-        result = response.json()
-    except ValueError as exc:  # json.JSONDecodeError — e.g. a proxy or portal answering HTML with a 200
-        raise ApiError(
-            f"The Cassis API at {url} returned a non-JSON response — check the API URL and any proxy in between."
-        ) from exc
-    if (
-        not isinstance(result, dict)
-        or not all(key in result for key in ("passed", "title", "summary"))
-        or not isinstance(result.get("findings"), list)
-    ):
-        raise ApiError(f"Unexpected response shape from the Cassis API at {url}.")
-    return result