calkit-python 0.45.1__tar.gz → 0.45.3__tar.gz

{calkit_python-0.45.1 → calkit_python-0.45.3}/.dockerignore

@@ -21,7 +21,7 @@ site
 docs
 examples
 test
-calk9
+ck9
 jupyterlab-ext
 vscode-ext
 hub/frontend

{calkit_python-0.45.1 → calkit_python-0.45.3}/.gitignore

@@ -17,7 +17,7 @@ node_modules
 calkit/labextension
 coverage
 junit.xml
-calk9
+ck9
 dist
 *.vsix
 vscode-ext/out

{calkit_python-0.45.1 → calkit_python-0.45.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: calkit-python
-Version: 0.45.1
+Version: 0.45.3
 Summary: Reproducibility simplified.
 Project-URL: Homepage, https://calkit.org
 Project-URL: Issues, https://github.com/calkit/calkit/issues
@@ -192,7 +192,7 @@ If you want to use Calkit without installing it,
 you can use uv's `uvx` command to run it directly:
 
 ```sh
-uvx calk9 --help
+uvx ck9 --help
 ```
 
 ### Nix

{calkit_python-0.45.1 → calkit_python-0.45.3}/README.md

@@ -133,7 +133,7 @@ If you want to use Calkit without installing it,
 you can use uv's `uvx` command to run it directly:
 
 ```sh
-uvx calk9 --help
+uvx ck9 --help
 ```
 
 ### Nix

{calkit_python-0.45.1 → calkit_python-0.45.3}/calkit/cli/main/core.py

@@ -286,9 +286,18 @@ def init(
         needs_own_repo = True
     if needs_own_repo:
         subprocess.run(["git", "init"])
-    result = calkit.dvc.init(force=force)
-    if result != 0:
-        raise_error("Failed to initialize DVC")
+    # A DVC repo can already exist here without a calkit.yaml, e.g., on
+    # platforms that set one up for us, so leave it alone rather than
+    # failing on DVC's refusal to initialize over an existing .dvc. The
+    # marker is .dvc/config, as elsewhere: a .dvc directory without one is
+    # an interrupted initialization, which has nothing worth keeping and
+    # which DVC will only initialize over with --force.
+    if os.path.isfile(os.path.join(".dvc", "config")) and not force:
+        typer.echo("DVC is already initialized")
+    else:
+        result = calkit.dvc.init(force=force or os.path.isdir(".dvc"))
+        if result != 0:
+            raise_error("Failed to initialize DVC")
     # Ensure autostage is enabled for DVC
     result = calkit.dvc.run_dvc_command(["config", "core.autostage", "true"])
     if result != 0:

{calkit_python-0.45.1 → calkit_python-0.45.3}/calkit/cli/new.py

@@ -3710,6 +3710,9 @@ def new_release(
             f"'{project_name}'."
         )
         record_id = None
+        # SPDX IDs are case-insensitive, but the InvenioRDM license vocabulary
+        # used by Zenodo and CaltechDATA only accepts them lowercased
+        license_ids = [lid.strip().lower() for lid in license_ids]
         # Detect project license IDs if necessary
         if not license_ids:
             license_file = calkit.licenses.find_license_file()
@@ -3756,7 +3759,7 @@ def new_release(
             publication_date=release_date,
             version=name,
             publisher=publisher_name,
-            rights=[{"id": lid for lid in license_ids}],
+            rights=[{"id": lid} for lid in license_ids],
         )
         # Add related identifiers
         github_url = calkit.detect_project_github_url()

{calkit_python-0.45.1 → calkit_python-0.45.3}/calkit/dvc/core.py

@@ -98,6 +98,60 @@ if sys.platform == "win32":
     _tolerate_lock_release_failures()
 
 
+def _hash_dirs_inside_nested_repos() -> None:
+    """Make DVC hash directories that live inside nested DVC repos.
+
+    DVC's ``DvcIgnoreFilter`` prunes nested DVC repos (e.g. isolated
+    subprojects) when walking, so the parent never indexes a subproject's
+    ``dvc.yaml`` and ``.dvc`` files as its own. The same walk hashes directory
+    deps and outs, though, and the subrepo check is order-dependent:
+    ``_get_trie_pattern`` hands the starting directory's ``dnames`` to every
+    ancestor it visits, so a walk that starts inside the nested repo never
+    registers it, while the root-level index walk does. Whichever touches the
+    ignore trie first wins for the rest of the process. In practice a parent
+    stage depending on a directory inside an isolated subproject hashes it as
+    *empty* on ``status`` but not always on ``repro``, so ``dvc.lock`` and
+    ``dvc status`` disagree and the stage is forever stale (or, worse, changes
+    in the subproject go unnoticed).
+
+    A walk that starts at or below a nested repo can only be a caller hashing
+    that path (the index walk always starts at the repo root), and the caller
+    named the path deliberately, so its contents must be hashed. Such walks
+    are routed through DVC's ``ignore_subrepos=False`` trie, which is built
+    separately, is deterministic, and still honors every ``.dvcignore`` on
+    the way down, including the nested repo's own.
+    """
+    from dvc.ignore import DvcIgnoreFilter
+    from dvc.repo import Repo
+
+    original_walk = DvcIgnoreFilter.walk
+
+    def in_nested_repo(dvcignore: Any, path: str) -> bool:
+        fs = dvcignore.fs
+        root_dir = dvcignore.root_dir
+        current = fs.abspath(path)
+        if not fs.isin(current, root_dir):
+            return False
+        while current != root_dir:
+            if fs.exists(fs.join(current, Repo.DVC_DIR)):
+                return True
+            parent = fs.parent(current)
+            if parent == current:
+                return False
+            current = parent
+        return False
+
+    def walk(self: Any, fs: Any, path: str, **kwargs: Any) -> Any:
+        if "ignore_subrepos" not in kwargs and in_nested_repo(self, path):
+            kwargs["ignore_subrepos"] = False
+        return original_walk(self, fs, path, **kwargs)
+
+    DvcIgnoreFilter.walk = walk
+
+
+_hash_dirs_inside_nested_repos()
+
+
 # Default seconds to wait for DVC's repo-level lock during a pipeline run.
 #
 # DVC's own default is only 3 seconds (``dvc.lock.DEFAULT_TIMEOUT``), after

{calkit_python-0.45.1 → calkit_python-0.45.3}/calkit/tests/cli/main/test_core.py

@@ -149,6 +149,25 @@ def test_init(tmp_dir):
     # --force allows re-initialization without clobbering calkit.yaml
     subprocess.check_call(["calkit", "init", "--force"], cwd="sub")
     assert calkit.load_calkit_info(wdir="sub") == ck_info
+    # An existing DVC repo with no calkit.yaml is left alone rather than
+    # failing on DVC's refusal to initialize over an existing .dvc (#1013)
+    os.remove(os.path.join("sub", "calkit.yaml"))
+    assert os.path.isdir(os.path.join("sub", ".dvc"))
+    result = subprocess.run(
+        ["calkit", "init"],
+        cwd="sub",
+        capture_output=True,
+        text=True,
+    )
+    assert result.returncode == 0
+    assert "already initialized" in result.stdout.lower()
+    assert os.path.isfile(os.path.join("sub", "calkit.yaml"))
+    assert calkit.load_calkit_info(wdir="sub") == {}
+    # A .dvc directory left behind by an interrupted init has no config in
+    # it, so it is re-initialized rather than taken for a working repo
+    os.remove(os.path.join("sub", ".dvc", "config"))
+    subprocess.check_call(["calkit", "init"], cwd="sub")
+    assert os.path.isfile(os.path.join("sub", ".dvc", "config"))
     # --no-commit stages the initial files without committing, so a
     # bootstrap (as run by xr) can be rolled back by restoring files
     os.makedirs("nocommit")

{calkit_python-0.45.1 → calkit_python-0.45.3}/calkit/tests/cli/main/test_subprojects.py

@@ -4,6 +4,7 @@ import os
 import subprocess
 
 import calkit
+import calkit.dvc
 import calkit.pipeline
 
 
@@ -375,6 +376,106 @@ def test_isolated_subproject_external_dep(tmp_dir):
     assert not status.is_stale
 
 
+def test_isolated_subproject_dir_dep(tmp_dir):
+    # A parent stage depending on a *directory* inside an isolated
+    # subproject: DVC prunes nested repos when walking, so without calkit's
+    # workaround the directory hashes as empty on status (but not always on
+    # repro), leaving the stage forever stale and blind to subproject changes.
+    def write_sub(b_content):
+        # Create the output directory here, since mkdir -p doesn't work in
+        # cmd.exe on Windows
+        os.makedirs("sub/figs", exist_ok=True)
+        write_ck_info(
+            "sub/calkit.yaml",
+            {
+                "pipeline": {
+                    "stages": {
+                        "make-figs": make_stage(
+                            "echo a > figs/a.txt && "
+                            f"echo {b_content} > figs/b.txt",
+                            outputs=[
+                                {"path": "figs/a.txt", "storage": "git"},
+                                {"path": "figs/b.txt", "storage": "git"},
+                            ],
+                        )
+                    }
+                }
+            },
+        )
+        calkit.pipeline.to_dvc(wdir="sub", write=True, manage_gitignore=False)
+
+    subprocess.check_call(["calkit", "init"])
+    init_isolated_subproject("sub", {})
+    write_sub("b")
+    write_ck_info(
+        "calkit.yaml",
+        {
+            "subprojects": [{"path": "sub"}],
+            "pipeline": {
+                "stages": {
+                    "consume": make_stage(
+                        "cat sub/figs/* > parent.txt",
+                        inputs=["sub/figs/"],
+                        outputs=[{"path": "parent.txt", "storage": "git"}],
+                    )
+                }
+            },
+        },
+    )
+    subprocess.check_call(["calkit", "run"])
+    # Windows' echo leaves trailing spaces, so compare tokens
+    with open("parent.txt") as f:
+        assert f.read().split() == ["a", "b"]
+    # The lock must record the directory's real contents, not an empty dir
+    with open("dvc.lock") as f:
+        lock = calkit.ryaml.load(f)
+    figs_dep = [
+        d
+        for d in lock["stages"]["consume"]["deps"]
+        if d["path"] == "sub/figs/"
+    ][0]
+    assert figs_dep["nfiles"] == 2
+    # And status must agree with the lock
+    status = calkit.pipeline.get_status(
+        check_environments=False, compile_to_dvc=False
+    )
+    assert not status.is_stale
+    # Hashing must not depend on whether the index walk (which registers the
+    # subrepo in DVC's ignore trie) ran first
+    repo = calkit.dvc.get_dvc_repo()
+    list(repo.index.stages)
+    found = sorted(
+        os.path.relpath(p)
+        for p in repo.dvcignore.find(repo.fs, os.path.abspath("sub/figs"))
+    )
+    assert found == [
+        os.path.join("sub", "figs", "a.txt"),
+        os.path.join("sub", "figs", "b.txt"),
+    ]
+    # The index walk still keeps the subproject's own pipeline out of the
+    # parent's index
+    assert {s.addressing for s in repo.index.stages} == {"sub", "consume"}
+    # A change inside the subproject propagates to the parent stage
+    write_sub("c")
+    subprocess.check_call(["calkit", "run"])
+    with open("parent.txt") as f:
+        assert f.read().split() == ["a", "c"]
+    status = calkit.pipeline.get_status(
+        check_environments=False, compile_to_dvc=False
+    )
+    assert not status.is_stale
+    # Editing a file in the directory makes the parent stage stale
+    with open("sub/figs/a.txt", "w") as f:
+        f.write("z\n")
+    status = calkit.pipeline.get_status(
+        check_environments=False, compile_to_dvc=False
+    )
+    assert status.is_stale
+    assert [
+        p.rstrip("/") for p in status.stale_stages["consume"].modified_inputs
+    ] == ["sub/figs"]
+
+
 def test_targeted_status_uses_full_subproject_status_for_stage_targets(
     tmp_dir, monkeypatch
 ):

{calkit_python-0.45.1 → calkit_python-0.45.3}/calkit/tests/cli/test_new.py

@@ -1100,6 +1100,10 @@ def test_new_nix_env_stages_flake(tmp_dir):
 def test_new_release(tmp_dir, monkeypatch, httpserver):
     # Set up a mock Zenodo API so the test doesn't depend on the real sandbox
     record_id = "test-record-abc123"
+    # A new version of a record gets its own ID, which the client must switch
+    # to; only the draft endpoints below are shared between the two
+    version_record_id = "test-record-def456"
+    any_record_id = f"(?:{record_id}|{version_record_id})"
     doi = "10.5072/zenodo.test123"
     # Point the Zenodo base URL at the local mock server and provide a dummy
     # token so no real credentials are needed.  Both env vars are inherited
@@ -1115,26 +1119,27 @@ def test_new_release(tmp_dir, monkeypatch, httpserver):
     ).respond_with_json({"id": record_id, "pids": {}})
     # POST /records/{id}/draft/files – initiate a file upload slot
     httpserver.expect_request(
-        re.compile(rf"^/records/{record_id}/draft/files$"), method="POST"
+        re.compile(rf"^/records/{any_record_id}/draft/files$"), method="POST"
     ).respond_with_json({"entries": []})
     # PUT /records/{id}/draft/files/{filename}/content – stream file bytes
     httpserver.expect_request(
-        re.compile(rf"^/records/{record_id}/draft/files/.+/content$"),
+        re.compile(rf"^/records/{any_record_id}/draft/files/.+/content$"),
         method="PUT",
     ).respond_with_data("", status=200)
     # POST /records/{id}/draft/files/{filename}/commit – finalise upload
     httpserver.expect_request(
-        re.compile(rf"^/records/{record_id}/draft/files/.+/commit$"),
+        re.compile(rf"^/records/{any_record_id}/draft/files/.+/commit$"),
         method="POST",
     ).respond_with_json({"key": "file", "status": "completed"})
     # POST /records/{id}/draft/pids/doi – reserve a DOI for a draft
     httpserver.expect_request(
-        re.compile(rf"^/records/{record_id}/draft/pids/doi$"), method="POST"
+        re.compile(rf"^/records/{any_record_id}/draft/pids/doi$"),
+        method="POST",
     ).respond_with_json({"pids": {"doi": {"identifier": doi}}})
     # GET /records/{id}/draft/files – list files already in the draft
     # (used by --reupload to decide which files to delete first)
     httpserver.expect_request(
-        re.compile(rf"^/records/{record_id}/draft/files$"), method="GET"
+        re.compile(rf"^/records/{any_record_id}/draft/files$"), method="GET"
     ).respond_with_json({"entries": []})
     # POST /records/{id}/draft/actions/publish – publish the draft
     httpserver.expect_request(
@@ -1143,6 +1148,16 @@ def test_new_release(tmp_dir, monkeypatch, httpserver):
     ).respond_with_json(
         {"id": record_id, "pids": {"doi": {"identifier": doi}}}
     )
+    # POST /records/{id}/versions – create a new version of a record, and
+    # PUT /records/{new_id}/draft – set that new version's metadata; the draft
+    # is only mocked under the new ID, so a client that failed to switch to it
+    # would get no response here
+    httpserver.expect_request(
+        re.compile(rf"^/records/{record_id}/versions$"), method="POST"
+    ).respond_with_json({"id": version_record_id, "pids": {}})
+    httpserver.expect_request(
+        re.compile(rf"^/records/{version_record_id}/draft$"), method="PUT"
+    ).respond_with_json({"id": version_record_id, "pids": {}})
     # GET /records/{id} – fetch the published record for post-test assertions
     httpserver.expect_request(
         re.compile(rf"^/records/{record_id}$"), method="GET"
@@ -1267,7 +1282,6 @@ def test_new_release(tmp_dir, monkeypatch, httpserver):
     git_tags = git.Repo().tags
     assert "v0.1.0" in [tag.name for tag in git_tags]
     # Check the license is correct
-    # TODO: It seems like we can't use multiple license IDs with the API
     record_id = release["record_id"]
     record = calkit.invenio.get(f"/records/{record_id}")
     metadata = record["metadata"]
@@ -1275,6 +1289,36 @@ def test_new_release(tmp_dir, monkeypatch, httpserver):
     assert metadata["license"] == {"id": "cc-by-4.0"}
     related = metadata["related_identifiers"]
     assert related[0]["identifier"] == "https://github.com/calkit/test-project"
+    # Issue #1582: SPDX IDs are case-insensitive, but the InvenioRDM license
+    # vocabulary rejects anything but the lowercase form, so release again
+    # with the licenses spelled in uppercase to check they are normalized
+    subprocess.check_call(
+        [
+            "calkit",
+            "new",
+            "release",
+            "--name",
+            "v0.2.0",
+            "--license",
+            "MIT",
+            "--license",
+            "CC-BY-4.0",
+            "--draft",
+            "--no-github",
+        ]
+    )
+    # Every set of metadata sent to the service should have carried both
+    # licenses as separate lowercase rights entries, rather than collapsing
+    # them into one: the first release detected them from the LICENSE file,
+    # the second took them from the uppercase --license options
+    rights_sent = [
+        body["metadata"]["rights"]
+        for request, _ in httpserver.log
+        if (body := request.get_json(silent=True)) and "metadata" in body
+    ]
+    expected_rights = [{"id": "mit"}, {"id": "cc-by-4.0"}]
+    assert len(rights_sent) >= 2
+    assert rights_sent == [expected_rights] * len(rights_sent)
     # TODO: Test that we can delete the release
     # This will fail if it's not a draft
     # subprocess.check_call(

{calkit_python-0.45.1 → calkit_python-0.45.3}/docs/installation.md

@@ -48,7 +48,7 @@ If you want to use Calkit without installing it,
 you can use uv's `uvx` command to run it directly:
 
 ```sh
-uvx calk9 --help
+uvx ck9 --help
 ```
 
 ## Nix

{calkit_python-0.45.1 → calkit_python-0.45.3}/hub/frontend/src/components/Onboarding/AccountSetupCard.tsx

@@ -32,7 +32,7 @@ const CHROME_EXT_URL =
 const AccountSetupCard = ({ projectCount }: { projectCount: number }) => {
   const showToast = useCustomToast()
   const overleafModal = useDisclosure()
-  const { accountFlags, setFlag } = useOnboardingFlags()
+  const { accountFlags, setFlag, flagsLoading } = useOnboardingFlags()
   const connectedAccountsQuery = useQuery({
     queryKey: ["user", "connected-accounts"],
     queryFn: () =>
@@ -60,7 +60,10 @@ const AccountSetupCard = ({ projectCount }: { projectCount: number }) => {
     projectCount,
     flags: accountFlags,
   })
-  if (connectedAccountsQuery.isPending) {
+  // Nothing shows until both the connected accounts and the user's flags
+  // are in hand: a card rendered on either one alone flashes a full
+  // checklist at a user who finished or dismissed it long ago.
+  if (connectedAccountsQuery.isPending || flagsLoading) {
     return null
   }
   const actions: Record<string, React.ReactNode> = {

{calkit_python-0.45.1 → calkit_python-0.45.3}/hub/frontend/src/components/Onboarding/ProjectChecklist.tsx

@@ -41,7 +41,7 @@ const ProjectChecklist = ({
   projectName,
   projectId,
 }: ProjectChecklistProps) => {
-  const { projectFlags, setFlag } = useOnboardingFlags(projectId)
+  const { projectFlags, setFlag, flagsLoading } = useOnboardingFlags(projectId)
   const { questionsRequest } = useProjectQuestions(accountName, projectName)
   // Both of these read the project's repo, which the page has already had
   // cloned and cached for the README and showcase, so they're cheap here
@@ -86,7 +86,9 @@ const ProjectChecklist = ({
   // someone whose project is already in good shape, which is the worst
   // first impression this card can make. A read that failed outright says
   // nothing about the project either, so that's no reason to show one.
-  if (reproCheckQuery.isPending || reproCheckQuery.isError) {
+  // The flags say whether this list was dismissed, so they have to land
+  // before anything renders for the same reason.
+  if (reproCheckQuery.isPending || reproCheckQuery.isError || flagsLoading) {
     return null
   }
   const actions: Record<string, React.ReactNode> = {

{calkit_python-0.45.1 → calkit_python-0.45.3}/hub/frontend/src/hooks/useOnboarding.ts

@@ -72,6 +72,10 @@ const useOnboardingFlags = (projectId?: string | null) => {
     )
   return {
     flagsQuery,
+    // Whether the flags are still on their way. A checklist rendered before
+    // they land reads as undismissed and unchecked, which flashes a fresh
+    // user's checklist at someone who put it away months ago.
+    flagsLoading: flagsQuery.isLoading,
     accountFlags,
     projectFlags,
     setFlag,

{calkit_python-0.45.1 → calkit_python-0.45.3}/pyproject.toml

@@ -106,7 +106,7 @@ ck = "calkit.fs:CalkitFileSystem"
 
 [project.scripts]
 calkit = "calkit.cli:run"
-calk9 = "calkit.cli:run"
+ck9 = "calkit.cli:run"
 ck = "calkit.cli:run"
 
 [tool.hatch.build.targets.wheel]

calkit_python-0.45.3/scripts/install.ps1

@@ -0,0 +1,26 @@
+# Install Calkit with uv (installing the latter if it isn't yet)
+
+# Every statement below is kept on a single line so the script still does the
+# right thing when a shell feeds it to `iex` one line at a time, which is what
+# happens if the quoting around `irm ... | iex` is lost and the outer shell,
+# rather than the inner one, ends up handling the pipe (see issue #1569)
+
+# Check if uv is installed
+if (-not (Get-Command uv -ErrorAction SilentlyContinue)) { Write-Host "Installing uv"; powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex" } else { Write-Host "uv is already installed" }
+
+# uv and the tools it installs go in ~\.local\bin, which this process won't
+# have on its PATH, since it started before uv put it there
+$env:Path = "$env:USERPROFILE\.local\bin;$env:Path"
+
+if (-not (Get-Command uv -ErrorAction SilentlyContinue)) { throw "Failed to install uv; please install it manually from https://docs.astral.sh/uv/getting-started/installation/" }
+
+# Install Calkit using uv
+Write-Host "Installing Calkit"
+uv tool install --upgrade calkit-python --python=3.14
+if ($LASTEXITCODE -ne 0) { throw "Failed to install Calkit; please check your uv installation" }
+
+# Install shell completion, per command name, so the `ck` alias gets it too
+Write-Host "Installing shell completion"
+foreach ($cmd in @("calkit", "ck")) { & $cmd --install-completion; if ($LASTEXITCODE -ne 0) { Write-Warning "Failed to install shell completion for '$cmd'; run '$cmd --install-completion' manually" } }
+
+Write-Host "Success! Restart your shell to pick up Calkit on your PATH."

{calkit_python-0.45.1 → calkit_python-0.45.3}/scripts/install.sh

@@ -22,11 +22,14 @@ if ! uv tool install --upgrade calkit-python --python=3.14; then
     exit 1
 fi
 
+# Completion is installed per command name, so the `ck` alias gets it too
 echo "Installing shell completion"
-if ! calkit --install-completion; then
-    echo "⚠️ Failed to install shell completion; run 'calkit --install-completion' manually"
-else
-    echo "✅ Shell completion installed"
-fi
+for cmd in calkit ck; do
+    if ! $cmd --install-completion; then
+        echo "⚠️ Failed to install shell completion for '$cmd'; run '$cmd --install-completion' manually"
+    else
+        echo "✅ Shell completion installed for '$cmd'"
+    fi
+done
 
 echo "✅ Success! 🚀"

calkit_python-0.45.1/scripts/make-calk9.sh → calkit_python-0.45.3/scripts/make-ck9.sh

@@ -4,18 +4,18 @@ set -e
 # Get version from VCS via hatch
 VERSION="$(uvx --with 'virtualenv<20.29.0' hatch version)"
 
-# Create calk9 directory structure
-rm -rf calk9
-mkdir -p calk9
+# Create ck9 directory structure
+rm -rf ck9
+mkdir -p ck9
 
 # Create pyproject.toml
-cat > calk9/pyproject.toml <<EOF
+cat > ck9/pyproject.toml <<EOF
 [build-system]
 requires = ["setuptools>=69"]
 build-backend = "setuptools.build_meta"
 
 [project]
-name = "calk9"
+name = "ck9"
 version = "$VERSION"
 description = "Reproducibility simplified."
 readme = "README.md"
@@ -29,30 +29,30 @@ Homepage = "https://calkit.org"
 Repository = "https://github.com/calkit/calkit"
 
 [project.scripts]
-calk9 = "calkit.cli:run"
+ck9 = "calkit.cli:run"
 EOF
 
 # Create README.md
-cat > calk9/README.md <<EOF
-# calk9
+cat > ck9/README.md <<EOF
+# ck9
 
 Alias package for [calkit-python](https://pypi.org/project/calkit-python/).
 
-This package provides the \`calk9\` command as a shorter alternative to \`calkit\`.
+This package provides the \`ck9\` command as a shorter alternative to \`calkit\`.
 
 ## Installation
 
 \`\`\`sh
-pip install calk9
+pip install ck9
 \`\`\`
 
 Or use with uvx without installation:
 
 \`\`\`sh
-uvx calk9 --help
+uvx ck9 --help
 \`\`\`
 
 See the [Calkit documentation](https://docs.calkit.org) for more information.
 EOF
 
-echo "Created calk9/ package with version $VERSION"
+echo "Created ck9/ package with version $VERSION"