cassis-cli 2.4.0__tar.gz → 3.0.0__tar.gz

{cassis_cli-2.4.0 → cassis_cli-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cassis-cli
-Version: 2.4.0
+Version: 3.0.0
 Summary: Validate, test and evaluate your Cassis ontology from your terminal, then publish it
 License: Apache-2.0
 License-File: LICENSE
@@ -27,7 +27,7 @@ Validate, test and evaluate your ontology from your terminal, then publish it. T
 - `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. It then prints advisory **ontology quality warnings** for a tree that parsed — tables not assigned to any domain, joins/metrics pointing at unknown tables or columns, missing table/column descriptions (the same findings `ontology test` reports, without the agent run). In a checkout bound to a project (`project.yml`, `--project`, or `CASSIS_PROJECT_ID`), it also cross-checks the tree against the project's source schema: references to tables or columns the warehouse doesn't have print as **warnings** too — advisory only (the object may simply not be built or synced yet). Warnings never fail the check.
 - `cassis schema pull` downloads the data source's full source schema (as Cassis last introspected it) into `<base-path>/.schema.json` — a **gitignored** local snapshot (the command maintains the ignore entry) with a `pulled_at` stamp. The warehouse stays authoritative; the snapshot is a cache for offline/bulk work — e.g. a coding agent grepping table and column names during a modeling pass instead of paging through the MCP `get_source_schema` tool. Re-run to refresh.
 - `cassis ontology fmt` rewrites the ontology files in canonical form (think `black`/`gofmt` for the ontology), so hand or agent edits pass the round-trip check.
-- `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.
+- `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. It runs from a git checkout whose ontology files are committed, and the published version records that commit, so `cassis status` can tell whether a checkout matches what is live.
 - `cassis ontology pull` downloads the project's unpublished ontology into your repository checkout (full sync — stale local ontology files are pruned), so you can start editing from the current state, or bootstrap a repo that isn't git-synced (e.g. Bitbucket). Pruning only deletes files that are tracked and unmodified in git (i.e. restorable with `git checkout`); untracked or locally modified files are kept and listed, and every deleted path is printed.
 - `cassis ontology pull` and `cassis ontology fmt` also write `<base-path>/AGENTS.md`, the Cassis ontology modeling guide, into the checkout (default `cassis/AGENTS.md`) — a managed file (generated banner; the CLI overwrites local edits) so a repo-aware coding agent loads current Cassis modeling doctrine by convention. It sits inside the ontology directory but is not part of the ontology tree (which is the YAML files plus the domain Markdown files `domains/**/README.md`), so it is never uploaded, validated, or pruned. Commit it alongside your ontology changes. The guide text ships inside the CLI package, so its version tracks the **installed cassis-cli version** — upgrade the CLI (`pip install -U cassis-cli`) and re-run `fmt` to pick up doctrine updates; an unpinned `pip install cassis-cli` in CI gets them automatically. The banner stamps a doctrine version, and the CLI never *downgrades* the file: if the checkout's `AGENTS.md` was written by a newer doctrine (a newer CLI, or Cassis itself on a publish), `fmt`/`pull` leave it in place, print an upgrade notice, and `fmt --check` still passes.
 - The CLI identifies itself to the API (`User-Agent: cassis-cli/<version>`), and successful API responses advertise the newest published version — when you are behind, commands print a one-line upgrade notice on stderr (purely informational; output and exit codes are unchanged).
@@ -79,7 +79,8 @@ cassis ontology check /path/to/checkout
 # --no-prune keeps even the tracked stale files it would otherwise delete):
 cassis ontology pull --project 019f0000-0000-7000-8000-000000000000
 
-# Upload the ontology to a project and publish it immediately:
+# Upload the ontology to a project and publish it immediately (commit the
+# changes under cassis/ first: uploads refuse uncommitted ontology files):
 cassis ontology upload --project 019f0000-0000-7000-8000-000000000000
 
 # Upload without publishing (the tree becomes the project's unpublished ontology, to review in Cassis):
@@ -140,6 +141,7 @@ cassis schema pull
 # Preview, apply locally and push a schema update from a DDL file (DDL-only projects):
 cassis schema plan schema.sql --complete
 cassis schema apply schema.sql --complete      # writes cassis/ locally
+git add cassis && git commit -m "Apply schema update"  # push needs the tree committed
 cassis schema push schema.sql --complete --yes  # schema + ontology to the app
 cassis schema plan --warehouse                   # warehouse-connected projects: introspect instead
 cassis schema plan future.sql --dry-run --write-checkout  # plan a not-yet-deployed DDL, keep nothing server-side
@@ -216,7 +218,7 @@ cassis ontology fmt --check
 | ---- | ------------------------------------------------------------------------------ |
 | 0    | Ontology is valid (check) / pulled (pull) / uploaded (upload) / eval run completed all-passed (eval run) / every probe completed (test — whatever its outcome; probes are informational, don't gate CI on them) |
 | 1    | Validation failed (check: findings printed; upload: nothing imported; eval run: invalid tree, failed cases, or failed/cancelled run; test: invalid tree or a probe failed; add-case: duplicate question or gold SQL that does not run; delete-case: no such case in the project; issues: no such issue or occurrence in the project; issues analyze: failed or cancelled analysis run; schema plan/apply: extraction is incomplete, the plan failed (unparseable or truncated DDL), is stale or expired, the apply failed, or the project won't accept it (a plan is being applied, a DDL was given for a warehouse-connected project, or --warehouse for a DDL-only one)) |
-| 2    | Usage error (missing API key or project, no ontology directory, unreadable file, tree over the size limits, `eval run --branch` naming an ontology branch the project does not have) |
+| 2    | Usage error (missing API key or project, no ontology directory, unreadable file, tree over the size limits, `eval run --branch` naming an ontology branch the project does not have, `upload` or `schema push` outside a git checkout or with uncommitted ontology files) |
 | 3    | Transport/API error (unreachable API, invalid key, inaccessible project, unexpected response), another eval run or issue analysis already active, out of credits, or `--timeout` reached |
 
 Commands that send the local tree (`check`, `fmt`, `upload`, `eval run`, `test`) accept up to
@@ -299,7 +301,7 @@ ontology-eval:
     CASSIS_PROJECT_ID: $CASSIS_PROJECT_ID
 
 ontology-publish:
-  image: python:3.12-slim
+  image: python:3.12  # not -slim: the upload needs git to record the commit
   rules:
     - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
   script:

{cassis_cli-2.4.0 → cassis_cli-3.0.0}/README.md

@@ -5,7 +5,7 @@ Validate, test and evaluate your ontology from your terminal, then publish it. T
 - `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. It then prints advisory **ontology quality warnings** for a tree that parsed — tables not assigned to any domain, joins/metrics pointing at unknown tables or columns, missing table/column descriptions (the same findings `ontology test` reports, without the agent run). In a checkout bound to a project (`project.yml`, `--project`, or `CASSIS_PROJECT_ID`), it also cross-checks the tree against the project's source schema: references to tables or columns the warehouse doesn't have print as **warnings** too — advisory only (the object may simply not be built or synced yet). Warnings never fail the check.
 - `cassis schema pull` downloads the data source's full source schema (as Cassis last introspected it) into `<base-path>/.schema.json` — a **gitignored** local snapshot (the command maintains the ignore entry) with a `pulled_at` stamp. The warehouse stays authoritative; the snapshot is a cache for offline/bulk work — e.g. a coding agent grepping table and column names during a modeling pass instead of paging through the MCP `get_source_schema` tool. Re-run to refresh.
 - `cassis ontology fmt` rewrites the ontology files in canonical form (think `black`/`gofmt` for the ontology), so hand or agent edits pass the round-trip check.
-- `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.
+- `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. It runs from a git checkout whose ontology files are committed, and the published version records that commit, so `cassis status` can tell whether a checkout matches what is live.
 - `cassis ontology pull` downloads the project's unpublished ontology into your repository checkout (full sync — stale local ontology files are pruned), so you can start editing from the current state, or bootstrap a repo that isn't git-synced (e.g. Bitbucket). Pruning only deletes files that are tracked and unmodified in git (i.e. restorable with `git checkout`); untracked or locally modified files are kept and listed, and every deleted path is printed.
 - `cassis ontology pull` and `cassis ontology fmt` also write `<base-path>/AGENTS.md`, the Cassis ontology modeling guide, into the checkout (default `cassis/AGENTS.md`) — a managed file (generated banner; the CLI overwrites local edits) so a repo-aware coding agent loads current Cassis modeling doctrine by convention. It sits inside the ontology directory but is not part of the ontology tree (which is the YAML files plus the domain Markdown files `domains/**/README.md`), so it is never uploaded, validated, or pruned. Commit it alongside your ontology changes. The guide text ships inside the CLI package, so its version tracks the **installed cassis-cli version** — upgrade the CLI (`pip install -U cassis-cli`) and re-run `fmt` to pick up doctrine updates; an unpinned `pip install cassis-cli` in CI gets them automatically. The banner stamps a doctrine version, and the CLI never *downgrades* the file: if the checkout's `AGENTS.md` was written by a newer doctrine (a newer CLI, or Cassis itself on a publish), `fmt`/`pull` leave it in place, print an upgrade notice, and `fmt --check` still passes.
 - The CLI identifies itself to the API (`User-Agent: cassis-cli/<version>`), and successful API responses advertise the newest published version — when you are behind, commands print a one-line upgrade notice on stderr (purely informational; output and exit codes are unchanged).
@@ -57,7 +57,8 @@ cassis ontology check /path/to/checkout
 # --no-prune keeps even the tracked stale files it would otherwise delete):
 cassis ontology pull --project 019f0000-0000-7000-8000-000000000000
 
-# Upload the ontology to a project and publish it immediately:
+# Upload the ontology to a project and publish it immediately (commit the
+# changes under cassis/ first: uploads refuse uncommitted ontology files):
 cassis ontology upload --project 019f0000-0000-7000-8000-000000000000
 
 # Upload without publishing (the tree becomes the project's unpublished ontology, to review in Cassis):
@@ -118,6 +119,7 @@ cassis schema pull
 # Preview, apply locally and push a schema update from a DDL file (DDL-only projects):
 cassis schema plan schema.sql --complete
 cassis schema apply schema.sql --complete      # writes cassis/ locally
+git add cassis && git commit -m "Apply schema update"  # push needs the tree committed
 cassis schema push schema.sql --complete --yes  # schema + ontology to the app
 cassis schema plan --warehouse                   # warehouse-connected projects: introspect instead
 cassis schema plan future.sql --dry-run --write-checkout  # plan a not-yet-deployed DDL, keep nothing server-side
@@ -194,7 +196,7 @@ cassis ontology fmt --check
 | ---- | ------------------------------------------------------------------------------ |
 | 0    | Ontology is valid (check) / pulled (pull) / uploaded (upload) / eval run completed all-passed (eval run) / every probe completed (test — whatever its outcome; probes are informational, don't gate CI on them) |
 | 1    | Validation failed (check: findings printed; upload: nothing imported; eval run: invalid tree, failed cases, or failed/cancelled run; test: invalid tree or a probe failed; add-case: duplicate question or gold SQL that does not run; delete-case: no such case in the project; issues: no such issue or occurrence in the project; issues analyze: failed or cancelled analysis run; schema plan/apply: extraction is incomplete, the plan failed (unparseable or truncated DDL), is stale or expired, the apply failed, or the project won't accept it (a plan is being applied, a DDL was given for a warehouse-connected project, or --warehouse for a DDL-only one)) |
-| 2    | Usage error (missing API key or project, no ontology directory, unreadable file, tree over the size limits, `eval run --branch` naming an ontology branch the project does not have) |
+| 2    | Usage error (missing API key or project, no ontology directory, unreadable file, tree over the size limits, `eval run --branch` naming an ontology branch the project does not have, `upload` or `schema push` outside a git checkout or with uncommitted ontology files) |
 | 3    | Transport/API error (unreachable API, invalid key, inaccessible project, unexpected response), another eval run or issue analysis already active, out of credits, or `--timeout` reached |
 
 Commands that send the local tree (`check`, `fmt`, `upload`, `eval run`, `test`) accept up to
@@ -277,7 +279,7 @@ ontology-eval:
     CASSIS_PROJECT_ID: $CASSIS_PROJECT_ID
 
 ontology-publish:
-  image: python:3.12-slim
+  image: python:3.12  # not -slim: the upload needs git to record the commit
   rules:
     - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
   script:

{cassis_cli-2.4.0 → cassis_cli-3.0.0}/cassis_cli/api.py

@@ -204,12 +204,17 @@ def post_ontology_import(
     project_id: str,
     files: dict[str, str],
     publish: bool,
+    git_commit_sha: str,
     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."""
+    """POST the ontology tree to /api/ci/projects/{project_id}/ontology/import and return the response body.
+
+    ``git_commit_sha`` is the commit the files were read from, recorded on the
+    version the import publishes.
+    """
     url = api_url.rstrip("/") + f"/api/ci/projects/{project_id}/ontology/import"
-    body: dict[str, Any] = {"files": files, "publish": publish}
+    body: dict[str, Any] = {"files": files, "publish": publish, "git_commit_sha": git_commit_sha}
     if label is not None:
         body["label"] = label
     try:
@@ -1028,7 +1033,7 @@ def post_ontology_test(
     if response.status_code == 400:
         raise OntologyTestValidationError(_detail_or_text(response))
     if response.status_code == 402:
-        raise ApiError("Your organization has run out of credits. Contact your administrator to top up.")
+        raise ApiError("Your organization has run out of credits. Contact your Cassis administrator to top up.")
     if response.status_code in (403, 404):
         raise _project_scope_error(response)
     if response.status_code >= 400:

{cassis_cli-2.4.0 → cassis_cli-3.0.0}/cassis_cli/common.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import hashlib
 import os
 import re
 import subprocess
@@ -106,6 +107,133 @@ def git_file_states(directory: Path) -> Optional[tuple[set[str], set[str]]]:
     return tracked, dirty
 
 
+def require_committed_tree(path: Path, base_path: str, files: "dict[str, str]") -> str:
+    """Return the ``HEAD`` commit that holds exactly the ontology ``files`` about to be uploaded.
+
+    An upload records this commit on the version it publishes, so the uploaded
+    files must be the ontology files of ``base_path`` at ``HEAD``: the same paths
+    with the same text, up to line endings (``collect_files`` reads CRLF as LF,
+    and line endings carry no ontology meaning). ``files`` is what ``collect_tree`` read, keyed by path
+    relative to the base path. Exits 2 (usage) when ``path`` is not a git checkout
+    with a commit, or when the two differ: a file modified, staged, renamed,
+    deleted, untracked, gitignored, missing from a sparse checkout or inside a
+    submodule. Files the upload does not send never block.
+    """
+    ontology_dir = path / Path(base_path)
+    env = {**os.environ, "GIT_OPTIONAL_LOCKS": "0"}
+
+    def fail(reason: str) -> "typer.Exit":
+        typer.secho(
+            f"{reason} Upload the ontology from a git checkout of the repository that holds it: "
+            "Cassis records the commit each published version comes from.",
+            fg=typer.colors.RED,
+            err=True,
+        )
+        return typer.Exit(EXIT_USAGE)
+
+    def git(*args: str) -> str:
+        try:
+            proc = subprocess.run(
+                ["git", *args],
+                cwd=ontology_dir,
+                env=env,
+                capture_output=True,
+                text=True,
+                errors="replace",
+            )
+        except OSError as exc:
+            raise fail(f"Could not run git ({exc}).") from exc
+        if proc.returncode != 0:
+            detail = proc.stderr.strip().splitlines()
+            raise fail(f"{path} is not a git checkout with a commit" + (f" (git: {detail[0]})." if detail else "."))
+        return proc.stdout
+
+    head = git("rev-parse", "--verify", "HEAD").strip()
+    # Run from ontology_dir, ls-tree lists paths relative to it. A submodule is a
+    # "commit" entry, so the files inside it count as not committed.
+    committed: "dict[str, str]" = {}
+    for entry in git("ls-tree", "-r", "-z", "HEAD", ".").split("\0"):
+        if not entry:
+            continue
+        meta, rel = entry.split("\t", 1)
+        _mode, kind, blob = meta.split()
+        if kind == "blob" and is_ontology_file(rel):
+            committed[rel] = blob
+    # Compare the content about to be uploaded, not the files on disk: a clean
+    # filter can make a working-tree file hash to its committed blob while the
+    # text read from it differs. Its blob id is computed here; a blob that does
+    # not match is accepted when it holds the same text up to line endings,
+    # which `collect_files` already reads as LF (a CRLF commit uploads as LF).
+    differing_blobs = {
+        p: committed[p] for p in files if p in committed and _blob_id(files[p], committed[p]) != committed[p]
+    }
+    committed_text = _read_blobs(ontology_dir, env, set(differing_blobs.values()), fail)
+    differing = sorted(
+        {p for p in files if p not in committed}
+        | {p for p, blob in differing_blobs.items() if _lf(committed_text.get(blob)) != _lf(files[p])}
+        | (committed.keys() - files.keys())
+    )
+    if differing:
+        shown = "\n".join(f"  {base_path}/{p}" for p in differing[:20])
+        more = f"\n  … and {len(differing) - 20} more" if len(differing) > 20 else ""
+        typer.secho(
+            f"Uncommitted changes under {base_path}/ (these files differ from HEAD):\n{shown}{more}\n"
+            f"Commit the changes under {base_path}/, then upload again.",
+            fg=typer.colors.RED,
+            err=True,
+        )
+        raise typer.Exit(EXIT_USAGE)
+    return head
+
+
+def _blob_id(content: str, like: str) -> str:
+    """The git blob id of ``content``, in the hash ``like`` (a blob id of the repository) uses."""
+    data = content.encode("utf-8")
+    digest = hashlib.sha256() if len(like) == 64 else hashlib.sha1()
+    digest.update(b"blob %d\0" % len(data) + data)
+    return digest.hexdigest()
+
+
+def _read_blobs(
+    cwd: Path, env: "dict[str, str]", blobs: "set[str]", fail: "Callable[[str], typer.Exit]"
+) -> "dict[str, str]":
+    """Read committed blobs in one ``git cat-file --batch``, keyed by blob id; non-UTF-8 blobs are left out."""
+    if not blobs:
+        return {}
+    try:
+        proc = subprocess.run(
+            ["git", "cat-file", "--batch"],
+            cwd=cwd,
+            env=env,
+            input="".join(f"{blob}\n" for blob in sorted(blobs)).encode(),
+            capture_output=True,
+        )
+    except OSError as exc:
+        raise fail(f"Could not run git ({exc}).") from exc
+    if proc.returncode != 0:
+        raise fail(f"Could not read committed files (git: {proc.stderr.decode(errors='replace').strip()}).")
+    texts: "dict[str, str]" = {}
+    out, pos = proc.stdout, 0
+    while pos < len(out):
+        header_end = out.index(b"\n", pos)
+        fields = out[pos:header_end].split()
+        pos = header_end + 1
+        if len(fields) != 3:  # "<id> missing"
+            continue
+        size = int(fields[2])
+        try:
+            texts[fields[0].decode()] = out[pos : pos + size].decode("utf-8")
+        except UnicodeDecodeError:
+            pass
+        pos += size + 1  # the content is followed by a newline
+    return texts
+
+
+def _lf(text: Optional[str]) -> Optional[str]:
+    """``text`` with CRLF and CR line endings read as LF, as ``Path.read_text`` reads them."""
+    return None if text is None else text.replace("\r\n", "\n").replace("\r", "\n")
+
+
 def sync_ontology_tree(
     ontology_dir: Path,
     files: "dict[str, str]",

{cassis_cli-2.4.0 → cassis_cli-3.0.0}/cassis_cli/ontology.py

@@ -29,6 +29,7 @@ from cassis_cli.common import (
 from cassis_cli.common import collect_tree as _collect_tree
 from cassis_cli.common import is_legacy_domain_file as _is_legacy_domain_file
 from cassis_cli.common import require_api_key as _require_api_key
+from cassis_cli.common import require_committed_tree as _require_committed_tree
 from cassis_cli.common import resolve_project_id as _resolve_project_id
 from cassis_cli.common import sync_ontology_tree as _sync_ontology_tree
 from cassis_cli.guide import DOCTRINE_VERSION, GUIDE_FILENAME, guide_status, refresh_guide
@@ -332,11 +333,14 @@ def upload(
 
     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.
+    new version. The checkout must be a git repository whose ontology files
+    match HEAD: the published version records that commit. Exits 0 on success,
+    1 when the tree fails validation, 2 on usage errors (including uncommitted
+    changes under the base path), 3 on transport/API errors.
     """
     api_key = _require_api_key(api_key)
     files, base_path = _collect_tree(path, base_path)
+    head = _require_committed_tree(path, base_path, files)
     project_id = _resolve_project_id(project_id, path / Path(base_path))
 
     try:
@@ -346,6 +350,7 @@ def upload(
             project_id=project_id,
             files=files,
             publish=publish,
+            git_commit_sha=head,
             label=label,
         )
     except AuthError as exc:

{cassis_cli-2.4.0 → cassis_cli-3.0.0}/cassis_cli/schema.py

@@ -46,6 +46,7 @@ from cassis_cli.common import (
     collect_tree,
     poll_until,
     require_api_key,
+    require_committed_tree,
     resolve_project_id,
     sync_ontology_tree,
 )
@@ -434,15 +435,17 @@ def push(
     Two steps, in order: the new schema (a DDL file, or the connected
     warehouse with --warehouse) is planned and applied server-side (new
     schema version, tracked schema updated, ontology edits the plan lists),
-    then the local ontology tree replaces the project's unpublished ontology
-    (so hand edits made after `cassis schema apply` land too). Pass --publish
-    to publish it as a new version. Exits 0 when pushed, 1 when the plan
-    failed / is stale or the upload was rejected, 2 on usage errors, 3 on
-    transport errors.
+    then the local ontology tree replaces the project's unpublished ontology.
+    Commit the tree `cassis schema apply` wrote, and any hand edits, before
+    pushing: the push refuses uncommitted changes under the base path, and a
+    published version records the commit. Pass --publish to publish it as a
+    new version. Exits 0 when pushed, 1 when the plan failed / is stale or the
+    upload was rejected, 2 on usage errors, 3 on transport errors.
     """
     api_key = require_api_key(api_key)
     _require_one_source(ddl_file, warehouse)
     files, base_path = collect_tree(path, base_path)
+    head = require_committed_tree(path, base_path, files)
     resolved_project = resolve_project_id(project_id, path / Path(base_path), quiet=json_output)
     assert resolved_project is not None
 
@@ -506,7 +509,13 @@ def push(
     typer.echo(f"Uploading {len(files)} ontology file(s)…", err=True)
     try:
         upload = post_ontology_import(
-            api_url=api_url, api_key=api_key, project_id=resolved_project, files=files, publish=publish, label=label
+            api_url=api_url,
+            api_key=api_key,
+            project_id=resolved_project,
+            files=files,
+            publish=publish,
+            git_commit_sha=head,
+            label=label,
         )
     except UploadValidationError as exc:
         typer.secho("Ontology upload rejected:", fg=typer.colors.RED, bold=True, err=True)
@@ -572,8 +581,8 @@ def _require_checkout_in_sync(
     if len(differing) > 10:
         typer.secho(f"  … {len(differing) - 10} more", fg=typer.colors.RED, err=True)
     typer.secho(
-        "Bring the checkout up to date first (`cassis ontology pull`), or push your local edits "
-        "(`cassis ontology upload --no-publish`), then apply again. `--force` overwrites the local files.",
+        "Bring the checkout up to date first (`cassis ontology pull`), or commit your local edits and push "
+        "them (`cassis ontology upload --no-publish`), then apply again. `--force` overwrites the local files.",
         fg=typer.colors.RED,
         err=True,
     )

{cassis_cli-2.4.0 → cassis_cli-3.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cassis-cli"
-version = "2.4.0"
+version = "3.0.0"
 description = "Validate, test and evaluate your Cassis ontology from your terminal, then publish it"
 readme = "README.md"
 license = { text = "Apache-2.0" }