kanon-cli 3.4.0__tar.gz → 3.4.1__tar.gz

{kanon_cli-3.4.0 → kanon_cli-3.4.1}/CHANGELOG.md

@@ -2,8 +2,56 @@
 
 
 
+## v3.4.1 (2026-08-21)
+
+### Fix
+
+* fix: kanon clean --purge-all no longer orphans the marketplace it registered (#120)
+
+Reported from a real machine, reproduced verbatim.
+
+`kanon clean --purge-all` removed the shared store without first unregistering
+what kanon had put into Claude. Claude was left holding a marketplace whose
+content no longer existed and reported it as `failed to load: cache-miss`.
+
+The state was unrecoverable through kanon. `kanon clean` locates the marketplace
+by enumerating the marketplace directory, which the teardown had already deleted,
+so a follow-up clean reports "Broken symlink detected and skipped" then "No
+marketplace entries found. Nothing to uninstall." and gives up. Fixing it meant
+`claude plugin uninstall` and `claude plugin marketplace remove` by hand.
+
+`.kanon.lock` survives a deleted `.kanon` and records `registered_marketplaces`
+per source. kanon always had the marketplace name, the directory, and the fact it
+had registered it; the teardown simply never read them.
+
+Both machine-wide paths now unregister from that ledger BEFORE removing anything.
+The no-project-found path discovers the lockfile by the same upward walk
+`find_kanonenv` uses; the sourceless-project path reads its sibling. Ordering is
+asserted by test, since unregistering after the delete is precisely what produced
+the orphan.
+
+One of the two paths was mine. `_purge_sourceless_project` shipped in 3.4.0 and
+delegated to the same incomplete teardown, so closing the "cannot purge" bug
+extended this defect to a new path rather than merely inheriting it. It also
+deleted `.kanon.lock`, destroying the only record of what to unregister.
+
+Candidates come only from the lockfile ledger, never from enumerating the
+directory, matching the safety invariant `_prune_orphaned_marketplaces` already
+documents: a marketplace kanon did not register was never written to a ledger and
+cannot be unregistered here. A missing lockfile or empty ledger is not an error
+and does not require claude on PATH.
+
+Verified end to end in a container against a 3.4.0 build: the reported sequence
+now leaves zero marketplaces, zero plugins and no stale lockfile. Guards proven
+falsifiable by reintroducing the defect in both paths. ([`6edc65a`](https://github.com/caylent-solutions/kanon/commit/6edc65a9c5cbe09fc057c370e867abaaf63136f7))
+
+
 ## v3.4.0 (2026-08-21)
 
+### Chore
+
+* chore(release): 3.4.0 ([`b361799`](https://github.com/caylent-solutions/kanon/commit/b36179978257a41a2a633de80393ac6a33735dd2))
+
 ### Feature
 
 * feat: multi project installs, safer file delivery, and faster validation (#117)
@@ -1241,6 +1289,12 @@ asserting what its name says. It now sets `purge_all = False` explicitly.
 
 Co-authored-by: Ryan Gross <ryan.gross@caylent.com> ([`f22fe03`](https://github.com/caylent-solutions/kanon/commit/f22fe03f77e3cabfe10822242ed689a8f11e7b73))
 
+### Unknown
+
+* Merge pull request #119 from caylent-solutions/release-3.4.0
+
+Release 3.4.0 ([`cc2e38d`](https://github.com/caylent-solutions/kanon/commit/cc2e38d528fd779ba770b451a8efc114c6c003ef))
+
 
 ## v3.3.3 (2026-08-06)
 

{kanon_cli-3.4.0 → kanon_cli-3.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: kanon-cli
-Version: 3.4.0
+Version: 3.4.1
 Summary: Kanon (Kanon Package Manager) CLI tool
 Project-URL: Homepage, https://github.com/caylent-solutions/kanon
 Project-URL: Issues, https://github.com/caylent-solutions/kanon/issues

{kanon_cli-3.4.0 → kanon_cli-3.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "kanon-cli"
-version = "3.4.0"
+version = "3.4.1"
 description = "Kanon (Kanon Package Manager) CLI tool"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.11"

{kanon_cli-3.4.0 → kanon_cli-3.4.1}/src/kanon_cli/__init__.py

@@ -1,3 +1,3 @@
 """Kanon CLI -- Kanon Package Manager."""
 
-__version__ = "3.4.0"
+__version__ = "3.4.1"

{kanon_cli-3.4.0 → kanon_cli-3.4.1}/src/kanon_cli/commands/clean.py

@@ -3,7 +3,14 @@
 import pathlib
 import sys
 
-from kanon_cli.core.clean import clean, remove_kanon_home_store, remove_project_config
+from kanon_cli.core.clean import (
+    clean,
+    find_lockfile,
+    remove_kanon_home_store,
+    remove_project_config,
+    unregister_marketplaces_from_lockfile,
+)
+from kanon_cli.constants import LOCKFILE_FILENAME
 from kanon_cli.core.discover import find_kanonenv
 from kanon_cli.core.kanonenv import NoSourcesError
 
@@ -95,7 +102,13 @@ def _purge_home_only() -> None:
     preserved exactly as in the in-``clean()`` path.
     """
     print("kanon clean --purge-all: no .kanon project found; removing only the shared kanon home store...")
+    lockfile_path = find_lockfile()
+    if lockfile_path is not None:
+        unregister_marketplaces_from_lockfile(lockfile_path)
     remove_kanon_home_store()
+    if lockfile_path is not None and lockfile_path.is_file():
+        print(f"kanon clean: removing {lockfile_path}...")
+        lockfile_path.unlink()
 
 
 def _purge_sourceless_project(kanonenv_path: pathlib.Path) -> None:
@@ -115,7 +128,9 @@ def _purge_sourceless_project(kanonenv_path: pathlib.Path) -> None:
         kanonenv_path: Path to the sourceless ``.kanon`` file.
     """
     print("kanon clean --purge-all: .kanon declares no sources; nothing to uninstall.")
-    remove_project_config(kanonenv_path, kanonenv_path.parent / ".kanon.lock")
+    lockfile_path = kanonenv_path.parent / LOCKFILE_FILENAME
+    unregister_marketplaces_from_lockfile(lockfile_path)
+    remove_project_config(kanonenv_path, lockfile_path)
     remove_kanon_home_store()
 
 

{kanon_cli-3.4.0 → kanon_cli-3.4.1}/src/kanon_cli/constants.py

@@ -471,6 +471,9 @@ KANON_ALLOW_INSECURE_REMOTES = "KANON_ALLOW_INSECURE_REMOTES"
 KANON_KANON_FILE_DEFAULT = "./.kanon"
 
 
+LOCKFILE_FILENAME = ".kanon.lock"
+
+
 KANON_HEADER_GITBASE = "GITBASE=<YOUR_GIT_ORG_BASE_URL>"
 KANON_HEADER_CLAUDE_MARKETPLACES_DIR = "CLAUDE_MARKETPLACES_DIR=${HOME}/.claude-marketplaces"
 

{kanon_cli-3.4.0 → kanon_cli-3.4.1}/src/kanon_cli/core/clean.py

@@ -24,6 +24,7 @@ import sys
 from kanon_cli.constants import (
     KANON_HOME_CACHE_SUBDIR,
     KANON_HOME_STORE_SUBDIR,
+    LOCKFILE_FILENAME,
     SOURCE_MARKETPLACE_KEY,
     resolve_kanon_home,
 )
@@ -321,6 +322,75 @@ def _prune_orphaned_marketplaces(lockfile: Lockfile | None, current_source_names
         remove_marketplace(claude_bin, name)
 
 
+def unregister_marketplaces_from_lockfile(lockfile_path: pathlib.Path) -> int:
+    """Unregister every marketplace a lockfile records kanon as having registered.
+
+    A teardown that deletes kanon's store without first unregistering what kanon
+    put into Claude leaves Claude holding a marketplace whose content no longer
+    exists. Claude reports that as ``failed to load: cache-miss``, and kanon can
+    no longer clean it up: the marketplace is normally located by enumerating the
+    marketplace directory, which the teardown has already removed.
+
+    The lockfile is the only record that survives the project's ``.kanon``, and it
+    carries what is needed: ``registered_marketplaces`` per source. This reads
+    that ledger and unregisters from it directly, so it works even when the
+    directory is gone or its symlinks are broken.
+
+    SAFETY INVARIANT, matching ``_prune_orphaned_marketplaces``: candidates come
+    ONLY from the per-source ``registered_marketplaces`` ledgers, never from
+    enumerating the directory. A marketplace kanon did not register was never
+    written to a ledger and so can never be unregistered here.
+
+    Args:
+        lockfile_path: Path to the ``.kanon.lock`` to read.
+
+    Returns:
+        The number of marketplaces unregistered.
+    """
+    lockfile = _read_lockfile_if_present(lockfile_path)
+    if lockfile is None:
+        return 0
+
+    registered: set[str] = set()
+    for source in lockfile.sources:
+        registered.update(source.registered_marketplaces)
+    names = sorted(registered)
+    if not names:
+        return 0
+
+    print(f"kanon clean: unregistering {len(names)} marketplace(s) recorded in {lockfile_path.name}...")
+    claude_bin = locate_claude_binary()
+    for name in names:
+        print(f"  - unregistering marketplace: {name}")
+        remove_marketplace(claude_bin, name)
+    return len(names)
+
+
+def find_lockfile(start_dir: pathlib.Path | None = None) -> pathlib.Path | None:
+    """Walk up from *start_dir* looking for a ``.kanon.lock``.
+
+    ``--purge-all`` runs in the situation where ``.kanon`` may already be gone,
+    which is exactly when the lockfile is the only surviving record of what kanon
+    registered. Discovery mirrors ``find_kanonenv``'s upward walk so the lock
+    found is the one belonging to the project the operator is standing in.
+
+    Args:
+        start_dir: Directory to start from. Defaults to the working directory.
+
+    Returns:
+        Path to the nearest ``.kanon.lock``, or None when there is none.
+    """
+    current = (start_dir or pathlib.Path.cwd()).resolve()
+    while True:
+        candidate = current / LOCKFILE_FILENAME
+        if candidate.is_file():
+            return candidate
+        parent = current.parent
+        if parent == current:
+            return None
+        current = parent
+
+
 def clean(
     kanonenv_path: pathlib.Path,
     orphans: bool = False,
@@ -381,7 +451,7 @@ def clean(
 
     marketplace_dir_str = globals_dict.get("CLAUDE_MARKETPLACES_DIR", "")
 
-    lockfile_path = kanonenv_path.parent / ".kanon.lock"
+    lockfile_path = kanonenv_path.parent / LOCKFILE_FILENAME
     lockfile = _read_lockfile_if_present(lockfile_path)
 
     if orphans:

{kanon_cli-3.4.0 → kanon_cli-3.4.1}/tests/unit/test_clean.py

@@ -2,6 +2,7 @@
 
 import datetime
 import pathlib
+import types
 from unittest.mock import patch
 
 import pytest
@@ -14,6 +15,8 @@ from kanon_cli.core.clean import (
     remove_kanon_home_store,
     remove_marketplace_dir,
     remove_project_config,
+    unregister_marketplaces_from_lockfile,
+    find_lockfile,
 )
 from kanon_cli.core.lockfile import (
     CURRENT_SCHEMA_VERSION,
@@ -742,3 +745,63 @@ class TestCleanIsProjectScoped:
             "the shared content-addressed store entry was pruned by a project-scoped clean, "
             "forcing every other project on the machine to re-fetch"
         )
+
+
+@pytest.mark.unit
+class TestUnregisterMarketplacesFromLockfile:
+    """The lock-driven unregister, which must work when the directory is already gone."""
+
+    def _lock(self, tmp_path, names):
+        lock = tmp_path / ".kanon.lock"
+        lock.write_text("")
+        source = types.SimpleNamespace(name="history", registered_marketplaces=names)
+        return lock, types.SimpleNamespace(sources=[source])
+
+    def test_unregisters_every_name_in_the_ledger(self, tmp_path: pathlib.Path) -> None:
+        """Each recorded marketplace is unregistered, by name, not by directory scan."""
+        lock, parsed = self._lock(tmp_path, ["claude-history", "other"])
+        with (
+            patch("kanon_cli.core.clean._read_lockfile_if_present", return_value=parsed),
+            patch("kanon_cli.core.clean.locate_claude_binary", return_value="claude"),
+            patch("kanon_cli.core.clean.remove_marketplace") as mock_remove,
+        ):
+            count = unregister_marketplaces_from_lockfile(lock)
+        assert count == 2
+        assert sorted(c.args[1] for c in mock_remove.call_args_list) == ["claude-history", "other"]
+
+    def test_absent_lockfile_is_not_an_error(self, tmp_path: pathlib.Path) -> None:
+        """No lockfile means nothing was recorded, so there is nothing to undo."""
+        with (
+            patch("kanon_cli.core.clean._read_lockfile_if_present", return_value=None),
+            patch("kanon_cli.core.clean.locate_claude_binary") as mock_locate,
+        ):
+            assert unregister_marketplaces_from_lockfile(tmp_path / ".kanon.lock") == 0
+        mock_locate.assert_not_called()
+
+    def test_empty_ledger_does_not_require_claude_on_path(self, tmp_path: pathlib.Path) -> None:
+        """A lockfile that registered nothing must not demand the claude binary."""
+        lock, parsed = self._lock(tmp_path, [])
+        with (
+            patch("kanon_cli.core.clean._read_lockfile_if_present", return_value=parsed),
+            patch("kanon_cli.core.clean.locate_claude_binary") as mock_locate,
+        ):
+            assert unregister_marketplaces_from_lockfile(lock) == 0
+        mock_locate.assert_not_called()
+
+
+@pytest.mark.unit
+class TestFindLockfile:
+    """Lockfile discovery, which must mirror find_kanonenv's upward walk."""
+
+    def test_finds_a_lockfile_in_a_parent_directory(self, tmp_path: pathlib.Path) -> None:
+        """The lock belonging to the project the operator stands in is the one found."""
+        (tmp_path / ".kanon.lock").write_text("")
+        nested = tmp_path / "a" / "b"
+        nested.mkdir(parents=True)
+        assert find_lockfile(nested) == tmp_path / ".kanon.lock"
+
+    def test_returns_none_when_there_is_no_lockfile(self, tmp_path: pathlib.Path) -> None:
+        """Absence is a normal outcome, not an error."""
+        nested = tmp_path / "a"
+        nested.mkdir()
+        assert find_lockfile(nested) is None

{kanon_cli-3.4.0 → kanon_cli-3.4.1}/tests/unit/test_clean_command.py

@@ -90,6 +90,77 @@ class TestPurgeAllWithASourcelessKanon:
         assert excinfo.value.code == 1
 
 
+@pytest.mark.unit
+class TestPurgeAllUnregistersBeforeDeleting:
+    """A teardown that deletes kanon's store must first undo what kanon put in Claude.
+
+    Removing the store without unregistering leaves Claude holding a marketplace
+    whose content is gone, which it reports as ``failed to load: cache-miss``. It
+    is unrecoverable through kanon, because the marketplace is normally found by
+    enumerating the marketplace directory the teardown already deleted.
+
+    ``.kanon.lock`` survives ``rm .kanon`` and records ``registered_marketplaces``,
+    so kanon always had what it needed. These assert it is used, and used *before*
+    anything is removed.
+    """
+
+    def test_no_project_path_unregisters_from_the_discovered_lockfile(self, tmp_path: pathlib.Path) -> None:
+        """With no .kanon, --purge-all still unregisters via the lockfile it finds."""
+        lock = tmp_path / ".kanon.lock"
+        lock.write_text("")
+        args = types.SimpleNamespace(kanonenv_path=None, orphans=False, purge=False, purge_all=True)
+        order: list[str] = []
+        with (
+            patch("kanon_cli.commands.clean.find_kanonenv", side_effect=FileNotFoundError("none")),
+            patch("kanon_cli.commands.clean.find_lockfile", return_value=lock),
+            patch(
+                "kanon_cli.commands.clean.unregister_marketplaces_from_lockfile",
+                side_effect=lambda p: order.append("unregister"),
+            ) as mock_unreg,
+            patch(
+                "kanon_cli.commands.clean.remove_kanon_home_store", side_effect=lambda: order.append("remove_store")
+            ) as mock_store,
+        ):
+            _run(args)
+        mock_unreg.assert_called_once_with(lock)
+        mock_store.assert_called_once_with()
+        assert order == ["unregister", "remove_store"], f"unregister must precede removal, got {order}"
+
+    def test_sourceless_project_unregisters_before_removing(self, tmp_path: pathlib.Path) -> None:
+        """A sourceless .kanon under --purge-all unregisters before deleting anything."""
+        kanonenv = tmp_path / ".kanon"
+        kanonenv.write_text("")
+        lock = tmp_path / ".kanon.lock"
+        args = types.SimpleNamespace(kanonenv_path=kanonenv, orphans=False, purge=False, purge_all=True)
+        order: list[str] = []
+        with (
+            patch(
+                "kanon_cli.commands.clean.unregister_marketplaces_from_lockfile",
+                side_effect=lambda p: order.append("unregister"),
+            ) as mock_unreg,
+            patch(
+                "kanon_cli.commands.clean.remove_project_config", side_effect=lambda a, b: order.append("remove_config")
+            ),
+            patch("kanon_cli.commands.clean.remove_kanon_home_store", side_effect=lambda: order.append("remove_store")),
+        ):
+            _run(args)
+        mock_unreg.assert_called_once_with(lock)
+        assert order == ["unregister", "remove_config", "remove_store"], f"unregister must come first, got {order}"
+
+    def test_no_lockfile_found_still_removes_the_store(self, tmp_path: pathlib.Path) -> None:
+        """A missing lockfile must not stop the teardown; there is simply nothing to undo."""
+        args = types.SimpleNamespace(kanonenv_path=None, orphans=False, purge=False, purge_all=True)
+        with (
+            patch("kanon_cli.commands.clean.find_kanonenv", side_effect=FileNotFoundError("none")),
+            patch("kanon_cli.commands.clean.find_lockfile", return_value=None),
+            patch("kanon_cli.commands.clean.unregister_marketplaces_from_lockfile") as mock_unreg,
+            patch("kanon_cli.commands.clean.remove_kanon_home_store") as mock_store,
+        ):
+            _run(args)
+        mock_unreg.assert_not_called()
+        mock_store.assert_called_once_with()
+
+
 @pytest.mark.unit
 class TestCleanRegister:
     def test_kanonenv_path_is_optional(self) -> None:

{kanon_cli-3.4.0 → kanon_cli-3.4.1}/uv.lock

@@ -643,7 +643,7 @@ wheels = [
 
 [[package]]
 name = "kanon-cli"
-version = "3.4.0"
+version = "3.4.1"
 source = { editable = "." }
 dependencies = [
     { name = "defusedxml" },