deepctl-cmd-plugin 0.1.13__tar.gz → 0.1.14__tar.gz

{deepctl_cmd_plugin-0.1.13 → deepctl_cmd_plugin-0.1.14}/.gitignore

@@ -139,6 +139,9 @@ dmypy.json
 *.swo
 *~
 
+# Claude Code local state (worktrees, session files)
+.claude/
+
 # OS
 .DS_Store
 .DS_Store?

{deepctl_cmd_plugin-0.1.13 → deepctl_cmd_plugin-0.1.14}/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.1.14](https://github.com/deepgram/cli/compare/deepctl-cmd-plugin-v0.1.13...deepctl-cmd-plugin-v0.1.14) (2026-10-09)
+
+
+### Features
+
+* **skills:** prove and remove deepctl 0.3.x skill files after the new folders land ([f65e0e2](https://github.com/deepgram/cli/commit/f65e0e22868b3d8f7ac4e81d9163045aca3383ec))
+* **skills:** remove the deepctl 0.3.x skill files deepctl can prove it wrote ([#130](https://github.com/deepgram/cli/issues/130)) ([8be5172](https://github.com/deepgram/cli/commit/8be5172fc8d101dbcb60f5b1fb7b36e5f4cfbcff))
+
+
+### Bug Fixes
+
+* **skills:** install skills from login and plugin through the shared installer ([1d34a22](https://github.com/deepgram/cli/commit/1d34a22c6b6c6ee2d87b3ee83657e7c28998a8fd))
+* **skills:** keep a newer skills ref and a removed tool when a refresh overlaps ([#126](https://github.com/deepgram/cli/issues/126)) ([3c9d1cf](https://github.com/deepgram/cli/commit/3c9d1cf3121a649a67b74ca9992cafdb0f2159ac))
+* **skills:** login and plugin install skills through the shared installer ([#125](https://github.com/deepgram/cli/issues/125)) ([3675f7a](https://github.com/deepgram/cli/commit/3675f7a21a34f59a6d1ab5c1c463149fec66d0e3))
+* **skills:** re-check records in dg skills update and the plugin refresh ([b0b1595](https://github.com/deepgram/cli/commit/b0b15959214085e818a551f1c37cfb1645001c6a))
+
 ## [0.1.13](https://github.com/deepgram/cli/compare/deepctl-cmd-plugin-v0.1.12...deepctl-cmd-plugin-v0.1.13) (2026-09-23)
 
 

{deepctl_cmd_plugin-0.1.13 → deepctl_cmd_plugin-0.1.14}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.5
 Name: deepctl-cmd-plugin
-Version: 0.1.13
+Version: 0.1.14
 Summary: Plugin management command for deepctl
 Author-email: Deepgram DevRel <devrel@deepgram.com>
 Requires-Python: >=3.10
-Requires-Dist: deepctl-core>=0.1.10
+Requires-Dist: deepctl-core>=0.2.19
 Requires-Dist: packaging>=21.0
 Requires-Dist: toml>=0.10.2
 Description-Content-Type: text/markdown

{deepctl_cmd_plugin-0.1.13 → deepctl_cmd_plugin-0.1.14}/pyproject.toml

@@ -2,11 +2,11 @@
 name = "deepctl-cmd-plugin"
 description = "Plugin management command for deepctl"
 readme = "README.md"
-version = "0.1.13" # x-release-please-version
+version = "0.1.14" # x-release-please-version
 requires-python = ">=3.10"
 authors = [{ name = "Deepgram DevRel", email = "devrel@deepgram.com" }]
 dependencies = [
-    "deepctl-core>=0.1.10",
+    "deepctl-core>=0.2.19",
     "packaging>=21.0",
     "toml>=0.10.2",
 ]

{deepctl_cmd_plugin-0.1.13 → deepctl_cmd_plugin-0.1.14}/src/deepctl_cmd_plugin/command.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import importlib.metadata
 import json
 import subprocess
 import sys
@@ -29,6 +28,7 @@ from deepctl_core.plugin_env import (
     save_plugin_state,
 )
 from rich.console import Console
+from rich.markup import escape
 from rich.table import Table
 
 from .models import (
@@ -1171,37 +1171,31 @@ except:
         return "varies"
 
     def _maybe_update_skills(self) -> None:
-        """Regenerate AI CLI skills if installed (best-effort)."""
-        try:
-            from deepctl_core.skill_generator import (
-                _commands_hash,
-                collect_command_metadata,
-                get_all_generators,
-                get_skills_state,
-                save_skills_state,
-            )
+        """Refresh the recorded skills the way 'dg skills update' does (B3).
 
-            state = get_skills_state()
-            if not state.get("installed_skills") or not state.get("auto_update", True):
-                return
-
-            commands = collect_command_metadata()
-            version = importlib.metadata.version("deepctl")
-            generators = {g.cli_name: g for g in get_all_generators()}
-
-            for cli_name, info in state["installed_skills"].items():
-                gen = generators.get(cli_name)
-                if gen:
-                    paths = gen.install(commands, version)
-                    info.update(
-                        {
-                            "paths": [str(p) for p in paths],
-                            "version": version,
-                            "commands_hash": _commands_hash(commands),
-                        }
-                    )
+        Never changes the plugin command's exit code; a failure prints a
+        warning on stderr.
+        """
+        from deepctl_core import skill_generator as sg
 
-            save_skills_state(state)
-            console.print("[dim]AI assistant skills updated[/dim]")
-        except Exception:
-            pass  # Non-fatal
+        try:
+            state = sg.get_skills_state()
+            names = {*state.get("skill_folders", {}), *state["installed_skills"]}
+            if not state.get("auto_update", True):
+                return
+            plan = [
+                (g, sg._ref_for(g.cli_name, state))
+                for g in sg.get_all_generators()
+                if g.cli_name in names and g.skills_root() is not None
+            ]
+            if not plan:  # None recorded, or hint-only only: records untouched.
+                return
+            for _gen, _paths, leftover in sg.install_for(plan, since=state):
+                if leftover:
+                    print_warning(escape(sg._msg("E12", staging=leftover)), stderr=True)
+        except Exception as exc:  # Non-fatal: the plugin operation succeeded.
+            sg.warn_install_failure(
+                "AI assistant skills were not updated",
+                exc,
+                "run 'dg skills update' to try again",
+            )

{deepctl_cmd_plugin-0.1.13 → deepctl_cmd_plugin-0.1.14}/tests/unit/test_plugin_command.py

@@ -1,21 +1,185 @@
 """Unit tests for plugin command."""
 
+import ast
+import hashlib
+import inspect
 import json
+import os
+import shutil
 from pathlib import Path
 from unittest.mock import MagicMock, patch
 
 import click
 import pytest
 from click.testing import CliRunner
+from deepctl_cmd_plugin import command as plugin_module
 from deepctl_cmd_plugin.command import PluginCommand
 from deepctl_cmd_plugin.models import (
     PluginInstallOptions,
     PluginOperationResult,
 )
 from deepctl_cmd_update.installation import InstallMethod
+from deepctl_core import output, skill_bundle
+from deepctl_core import skill_generator as sg
 from deepctl_core.auth import AuthManager
 from deepctl_core.client import DeepgramClient
 from deepctl_core.config import Config
+from deepctl_core.skill_bundle import RepoSkill, SkillFetchError
+
+REF = skill_bundle.DEFAULT_SKILLS_COMMIT
+RETRY = "run 'dg skills update' to try again"
+AGAIN = ", then run the command again."
+
+
+def retried(msg):
+    """The refresh's warning for ``msg``: it names the retry, not a plugin rerun."""
+    if AGAIN in msg:
+        return msg.replace(AGAIN, f", then {RETRY}.")
+    assert msg.endswith(".")
+    return msg[:-1] + f"; {RETRY}."
+
+
+def invoke_install(cmd=None):
+    """Run ``dg plugin install p`` through click with the pip step stubbed out."""
+    cmd = cmd or PluginCommand()
+    ok = PluginOperationResult(
+        success=True, action="install", package="p", message="Installed p"
+    )
+    group = click.Group("plugin", commands=cmd.setup_commands())
+    obj = {"config": MagicMock(), "auth_manager": MagicMock(), "client": MagicMock()}
+    with patch.object(cmd, "install_plugin", return_value=ok):
+        return CliRunner().invoke(group, ["install", "p"], obj=obj)
+
+
+@pytest.fixture(autouse=True)
+def _no_real_skills_state(tmp_path, monkeypatch):
+    """No test here reads or writes the developer's real skills.json (T19).
+
+    Handler tests that succeed run the real skills refresh; with no records
+    under this throwaway path it returns before any fetch.
+    """
+    skills_dir = tmp_path / "deepctl-skills"
+    monkeypatch.setattr(sg, "_SKILLS_DIR", skills_dir)
+    monkeypatch.setattr(sg, "_STATE_FILE", skills_dir / "skills.json")
+
+
+def use_home(monkeypatch, home):
+    """Point every home lookup the skills refresh makes at ``home``."""
+    home.mkdir(parents=True, exist_ok=True)
+    monkeypatch.setattr(Path, "home", staticmethod(lambda: home))
+    monkeypatch.setenv("HOME", str(home))
+    monkeypatch.setenv("USERPROFILE", str(home))
+    monkeypatch.setattr(sg, "_SKILLS_DIR", home / ".deepctl" / "skills")
+    monkeypatch.setattr(sg, "_STATE_FILE", home / ".deepctl" / "skills" / "skills.json")
+    return home
+
+
+@pytest.fixture
+def home(tmp_path, monkeypatch):
+    """A throwaway HOME with the output mode pinned (S4) and no PATH detection."""
+    monkeypatch.setattr(shutil, "which", lambda name: None)
+    monkeypatch.delenv(skill_bundle.REF_ENV_VAR, raising=False)
+    for con in (output.console, output.stderr_console, plugin_module.console):
+        monkeypatch.setattr(con, "_width", 400)
+    saved = dict(output._output_config)
+    output._output_config.update(agentic=True, format="default", quiet=False)
+    yield use_home(monkeypatch, tmp_path / "home")
+    output._output_config.clear()
+    output._output_config.update(saved)
+
+
+@pytest.fixture
+def bundle(tmp_path, monkeypatch):
+    """Patch the one fetch point; return the list of refs fetched."""
+    fetched = []
+
+    def fetch(ref=None):
+        fetched.append(ref)
+        skills = []
+        for name in ("api", "docs"):
+            folder = tmp_path / "bundle" / "skills" / name
+            folder.mkdir(parents=True, exist_ok=True)
+            (folder / "SKILL.md").write_bytes(f"---\nname: {name}\n---\n{ref}\n".encode())
+            skills.append(RepoSkill(name, folder))
+        return skills
+
+    monkeypatch.setattr(skill_bundle, "fetch_skill_bundle", fetch)
+    return fetched
+
+
+def gen(cli):
+    return next(g for g in sg.get_all_generators() if g.cli_name == cli)
+
+
+def write_state(state):
+    sg._STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
+    sg._STATE_FILE.write_text(json.dumps(state), encoding="utf-8")
+
+
+def state_bytes():
+    try:
+        return sg._STATE_FILE.read_bytes()
+    except FileNotFoundError:
+        return None
+
+
+def normalized(home):
+    """skills.json with paths rebased on ``home`` and timestamps dropped."""
+    text = sg._STATE_FILE.read_text(encoding="utf-8")
+    state = json.loads(text.replace(json.dumps(str(home))[1:-1], "~"))
+    for section in ("skill_folders", "installed_skills"):
+        for tool in state.get(section, {}).values():
+            tool.pop("installed_at", None)
+    return state
+
+
+def sha_tree(path):
+    path = Path(path)
+    if path.is_symlink():
+        return {"": "link:" + os.readlink(path)}
+    return {
+        str(p.relative_to(path)): hashlib.sha256(p.read_bytes()).hexdigest()
+        for p in sorted(path.rglob("*"))
+        if p.is_file()
+    }
+
+
+def staging_dirs(where):
+    if not where.is_dir():
+        return []
+    return [n for n in os.listdir(where) if n.startswith(sg._STAGING_PREFIX)]
+
+
+def bundle_for(where, ref):
+    """A separate bundle whose SKILL.md files name ``ref``."""
+    skills = []
+    for name in ("api", "docs"):
+        folder = where.parent / f"bundle-{ref}" / "skills" / name
+        folder.mkdir(parents=True, exist_ok=True)
+        (folder / "SKILL.md").write_bytes(f"---\nname: {name}\n---\n{ref}\n".encode())
+        skills.append(RepoSkill(name, folder))
+    return skills
+
+
+def fail_for(monkeypatch, cli, exc):
+    real = sg.install_tool
+
+    def install_tool(g, *a, **k):
+        if g.cli_name == cli:
+            raise exc
+        return real(g, *a, **k)
+
+    monkeypatch.setattr(sg, "install_tool", install_tool)
+
+
+def refresh(capsys):
+    capsys.readouterr()
+    PluginCommand()._maybe_update_skills()
+    return capsys.readouterr()
+
+
+def warnings(err):
+    return [line for line in err.splitlines() if line.startswith(("WARN:", "⚠"))]
 
 
 class TestPluginCommand:
@@ -607,3 +771,381 @@ class TestPluginCommand:
         assert self.command._needs_isolated_venv(InstallMethod.PIP) is False
         assert self.command._needs_isolated_venv(InstallMethod.PIPX) is False
         assert self.command._needs_isolated_venv(InstallMethod.UV) is False
+
+
+class TestSkillsRefresh:
+    """B3: the plugin refresh installs through the path 'dg skills update' uses."""
+
+    def test_refresh_writes_the_records_dg_skills_update_would(
+        self, home, bundle, monkeypatch, capsys, tmp_path
+    ):
+        from deepctl_cmd_skills.command import SkillsCommand
+
+        homes = [home, use_home(monkeypatch, tmp_path / "other")]
+        for h in homes:
+            use_home(monkeypatch, h)
+            for cli in ("claude", "cursor"):
+                h.joinpath(*gen(cli).homes[0]).mkdir(parents=True)
+            SkillsCommand()._handle_install(install_all=True)
+        use_home(monkeypatch, homes[0])
+        out, err = refresh(capsys)
+        assert (out, err) == ("", "")
+        use_home(monkeypatch, homes[1])
+        SkillsCommand()._handle_update()
+        after_update = normalized(homes[1])
+        use_home(monkeypatch, homes[0])
+        assert normalized(homes[0]) == after_update
+        assert set(after_update["skill_folders"]) == {"claude", "cursor"}
+
+    @pytest.mark.parametrize("quiet", [False, True])
+    def test_successful_refresh_keeps_skills_off_stdout_and_quiet_silent(
+        self, home, bundle, quiet
+    ):
+        output._output_config.update(agentic=False, quiet=quiet)
+        write_state({"installed_skills": {"claude": {"paths": []}}})
+        result = invoke_install()
+        assert result.exit_code == 0, result.output
+        assert bundle == [REF]
+        assert "skills" not in result.stdout.lower()
+        assert "skills" not in result.stderr.lower()
+        if quiet:
+            assert (result.stdout, result.stderr) == ("", "")
+
+    @pytest.mark.parametrize("agentic", [False, True])
+    def test_refresh_second_tool_failure_keeps_first_recorded_warns_once_exit_zero(
+        self, home, bundle, monkeypatch, agentic
+    ):
+        output._output_config["agentic"] = agentic
+        write_state(
+            {"installed_skills": {"claude": {"paths": []}, "cursor": {"paths": []}}}
+        )
+        exc = sg._err("E5", gen("cursor"), reason="No space left on device")
+        fail_for(monkeypatch, "cursor", exc)
+        result = invoke_install()
+        assert result.exit_code == 0, result.output
+        assert "not updated" not in result.stdout
+        assert len(warnings(result.stderr)) == 1
+        assert warnings(result.stderr)[0].endswith(
+            "AI assistant skills were not updated: " + retried(str(exc))
+        )
+        claude = sg.get_skills_state()["skill_folders"]["claude"]["folders"]
+        assert {n: r["state"] for n, r in claude.items()} == {
+            "api": "installed",
+            "docs": "installed",
+        }
+        assert "cursor" not in sg.get_skills_state()["skill_folders"]
+
+    def test_refresh_keeps_03x_and_hint_only_records_byte_identical(
+        self, home, bundle, capsys
+    ):
+        old = Path.home() / ".claude" / "commands" / "deepgram" / "setup-mcp.md"
+        old.parent.mkdir(parents=True)
+        old.write_bytes(b"mine")  # A folder for setup-mcp never lands: kept.
+        rule = Path.home() / ".amazonq" / "rules" / "deepctl.md"
+        conf = Path.home() / ".aider.conf.yml"
+        legacy = {
+            "claude": {"paths": [str(old)], "version": "0.3.0", "commands_hash": "h"},
+            "amazonq": {"paths": [str(rule)], "version": "0.3.0"},
+            "aider": {"paths": [str(conf)], "commands_hash": "h"},
+        }
+        write_state({"installed_skills": legacy})
+        _, err = refresh(capsys)
+        state = sg.get_skills_state()
+        if os.name == "nt":
+            assert len(warnings(err)) == 1
+            assert "does not clean 0.3.x content on Windows" in warnings(err)[0]
+            assert str(old) not in state["installed_skills"]["claude"]["paths"]
+            assert "v03" not in state["skill_folders"]["claude"]
+        else:
+            assert warnings(err) == []
+            assert state["installed_skills"] == legacy
+        assert set(state["skill_folders"]) == {"claude"}
+        assert (state["skill_folders"]["claude"].get("v03") is True) != (
+            os.name == "nt"
+        )
+        assert (gen("claude").skills_root() / "api" / "SKILL.md").is_file()
+        assert bundle == [REF]
+
+    def _install_then_overlap(self, monkeypatch, action):
+        list(sg.install_for([(gen("claude"), REF), (gen("cursor"), REF)]))
+        real, pending = skill_bundle.fetch_skill_bundle, [action]
+
+        def fetch(ref=None):
+            if pending:
+                pending.pop()()
+            return real(ref)
+
+        monkeypatch.setattr(skill_bundle, "fetch_skill_bundle", fetch)
+
+    def test_refresh_skips_a_tool_removed_during_its_download(
+        self, home, bundle, monkeypatch, capsys
+    ):
+        self._install_then_overlap(monkeypatch, lambda: sg.remove_tool(gen("claude")))
+        out, err = refresh(capsys)
+        assert out == ""
+        assert warnings(err) == ["WARN: " + sg._msg("E31", gen("claude"))]
+        state = sg.get_skills_state()
+        assert "claude" not in state["skill_folders"]
+        assert "claude" not in state["installed_skills"]
+        assert not (gen("claude").skills_root() / "api").exists()
+        assert set(state["skill_folders"]["cursor"]["folders"]) == {"api", "docs"}
+
+    def test_refresh_keeps_an_explicit_ref_set_during_its_download(
+        self, home, bundle, monkeypatch
+    ):
+        skills = bundle_for(home, "newer")
+        self._install_then_overlap(
+            monkeypatch,
+            lambda: sg.install_tool(gen("claude"), skills, ref="newer", version="9"),
+        )
+        result = invoke_install()
+        assert result.exit_code == 0, result.output
+        assert warnings(result.stderr) == ["WARN: " + sg._msg("E30", gen("claude"))]
+        assert sg.get_skills_state()["skill_folders"]["claude"]["skills_ref"] == "newer"
+        assert sg.get_skills_state()["skill_folders"]["cursor"]["skills_ref"] == REF
+
+    def test_refresh_keeps_a_newer_copy_of_the_same_moving_ref(
+        self, home, bundle, monkeypatch, capsys
+    ):
+        """B1 (review): REF moved; the newer download landed first and stays."""
+        newer = bundle_for(home, "newer")
+        self._install_then_overlap(
+            monkeypatch,
+            lambda: sg.install_tool(gen("claude"), newer, ref=REF, version="9"),
+        )
+        out, err = refresh(capsys)
+        assert out == ""
+        assert warnings(err) == ["WARN: " + sg._msg("E32", gen("claude"))]
+        api = gen("claude").skills_root() / "api" / "SKILL.md"
+        assert api.read_bytes() == (newer[0].path / "SKILL.md").read_bytes()
+        state = sg.get_skills_state()["skill_folders"]
+        assert (state["claude"]["skills_ref"], state["claude"]["version"]) == (REF, "9")
+        assert state["cursor"]["version"] != "9"
+
+    @pytest.mark.parametrize(
+        "state",
+        [
+            None,
+            {"installed_skills": {}},
+            {"installed_skills": {"claude": {"paths": []}}, "auto_update": False},
+            {"installed_skills": {"amazonq": {"paths": []}, "aider": {"paths": []}}},
+        ],
+        ids=["no-file", "empty", "auto-update-off", "hint-only"],
+    )
+    def test_refresh_noops_without_fetch(self, home, bundle, capsys, state):
+        if state is not None:
+            write_state(state)
+        saved = state_bytes()
+        out, err = refresh(capsys)
+        assert bundle == []
+        assert state_bytes() == saved
+        assert (out, err) == ("", "")
+        assert not gen("claude").skills_root().exists()
+
+    @pytest.mark.parametrize("agentic", [False, True])
+    def test_refresh_fetch_failure_warns_once_exit_zero_keeps_records(
+        self, home, monkeypatch, agentic
+    ):
+        output._output_config["agentic"] = agentic
+        write_state({"installed_skills": {"claude": {"paths": []}}})
+        saved = state_bytes()
+
+        def fetch(ref=None):
+            raise SkillFetchError("Could not download the skills.")
+
+        monkeypatch.setattr(skill_bundle, "fetch_skill_bundle", fetch)
+        result = invoke_install()
+        assert result.exit_code == 0, result.output
+        assert "not updated" not in result.stdout
+        assert "skills updated" not in result.stdout
+        assert warnings(result.stderr) == [
+            ("WARN: " if agentic else "⚠ ")
+            + "AI assistant skills were not updated: Could not download the skills; "
+            "run 'dg skills update' to try again."
+        ]
+        assert state_bytes() == saved
+        assert not gen("claude").skills_root().exists()
+
+    def test_refresh_invalid_recorded_ref_warns_once_exit_zero_keeps_records(
+        self, home, bundle
+    ):
+        list(sg.install_for([(gen("claude"), REF)]))
+        state = json.loads(state_bytes())
+        state["skill_folders"]["claude"]["skills_ref"] = "../evil"
+        write_state(state)
+        saved, tree = state_bytes(), sha_tree(gen("claude").skills_root())
+        result = invoke_install()
+        assert result.exit_code == 0, result.output
+        assert "updated" not in result.stdout
+        [line] = warnings(result.stderr)
+        assert line.startswith("WARN: AI assistant skills were not updated: ")
+        assert "'../evil'" in line
+        assert line.endswith(f"; {RETRY}.")
+        assert bundle == [REF]
+        assert state_bytes() == saved
+        assert sha_tree(gen("claude").skills_root()) == tree
+
+    def test_refresh_follows_recorded_ref_and_env_wins(
+        self, home, bundle, capsys, monkeypatch
+    ):
+        list(sg.install_for([(gen("claude"), "my-branch")]))
+        refresh(capsys)
+        assert bundle == ["my-branch", "my-branch"]
+        assert sg.get_skills_state()["skill_folders"]["claude"]["skills_ref"] == (
+            "my-branch"
+        )
+        monkeypatch.setenv(skill_bundle.REF_ENV_VAR, "env-ref")
+        refresh(capsys)
+        monkeypatch.delenv(skill_bundle.REF_ENV_VAR)
+        assert bundle[-1] == "env-ref"
+        write_state({"installed_skills": {"cursor": {"paths": []}}})
+        refresh(capsys)
+        assert bundle[-1] == REF
+
+    @pytest.mark.parametrize("kind", ["dir", "symlink", "dangling-symlink"])
+    def test_refresh_conflict_refuses_every_tool(
+        self, home, bundle, capsys, tmp_path, kind
+    ):
+        list(sg.install_for([(gen("claude"), REF)]))
+        write_state(
+            {**json.loads(state_bytes()), "installed_skills": {"cursor": {"paths": []}}}
+        )
+        saved, claude = state_bytes(), sha_tree(gen("claude").skills_root())
+        dest = gen("cursor").skills_root() / "api"
+        dest.parent.mkdir(parents=True)
+        mine = tmp_path / "mine"
+        mine.mkdir()
+        (mine / "notes.md").write_bytes(b"mine")
+        if kind == "dir":
+            shutil.copytree(mine, dest)
+        else:
+            target = mine if kind == "symlink" else tmp_path / "gone"
+            try:
+                dest.symlink_to(target, target_is_directory=True)
+            except (OSError, NotImplementedError) as exc:
+                pytest.skip(f"cannot create a symlink here: {exc}")
+        before = sha_tree(dest)
+        out, err = refresh(capsys)
+        e1 = sg._msg("E1", paths=str(dest))
+        assert warnings(err) == [
+            f"WARN: AI assistant skills were not updated: {e1.removesuffix(AGAIN)}, "
+            "then run 'dg skills update' to try again."
+        ]
+        assert "updated" not in out
+        assert sha_tree(dest) == before
+        assert sha_tree(mine) == {"notes.md": hashlib.sha256(b"mine").hexdigest()}
+        assert state_bytes() == saved
+        assert sha_tree(gen("claude").skills_root()) == claude
+        assert bundle == [REF, REF]
+
+    def test_refresh_edited_folder_warns_e22_and_leaves_it(self, home, bundle, capsys):
+        list(sg.install_for([(gen("claude"), REF)]))
+        api = gen("claude").skills_root() / "api"
+        with open(api / "SKILL.md", "ab") as f:
+            f.write(b"mine\n")
+        before, saved = sha_tree(api), state_bytes()
+        _, err = refresh(capsys)
+        e22 = sg._msg("E22", dest=api)
+        assert warnings(err) == [
+            f"WARN: AI assistant skills were not updated: {retried(e22)}"
+        ]
+        assert sha_tree(api) == before
+        assert state_bytes() == saved
+
+    def test_refresh_multi_problem_warning_names_the_retry_in_every_sentence(
+        self, home, bundle, monkeypatch, capsys
+    ):
+        monkeypatch.setattr(output.stderr_console, "_width", 2000)
+        write_state({"installed_skills": {"claude": {"paths": []}}})
+        p1, p2, p3 = (home / n for n in ("a", "b", "c"))
+        fail_for(monkeypatch, "claude", sg.SkillOwnershipError([p1], [p2, p3]))
+        _, err = refresh(capsys)
+        [line] = warnings(err)
+        assert "run the command again" not in line
+        assert line.count(f", then {RETRY}.") == 3
+        assert line.endswith(f", then {RETRY}.")
+
+    def test_refresh_corrupt_skills_json_warns_and_keeps_bytes(
+        self, home, bundle, capsys
+    ):
+        sg._STATE_FILE.parent.mkdir(parents=True)
+        sg._STATE_FILE.write_bytes(b'{"installed_skills": []}')
+        out, err = refresh(capsys)
+        e7 = sg._msg("E7")
+        assert warnings(err) == [
+            f"WARN: AI assistant skills were not updated: {retried(e7)}"
+        ]
+        assert out == ""
+        assert state_bytes() == b'{"installed_skills": []}'
+        assert bundle == []
+
+    @pytest.mark.parametrize("handler", ["install", "update", "remove"])
+    @pytest.mark.parametrize("success", [True, False])
+    def test_refresh_runs_after_install_update_remove_only_on_success(
+        self, handler, success
+    ):
+        cmd = PluginCommand()
+        result = PluginOperationResult(
+            success=success, action=handler, package="p", message="m"
+        )
+        method = "remove_plugin" if handler == "remove" else "install_plugin"
+        with (
+            patch.object(cmd, method, return_value=result),
+            patch.object(cmd, "_maybe_update_skills") as refresh_mock,
+        ):
+            call = getattr(cmd, f"_handle_{handler}")
+            args = (MagicMock(), MagicMock(), MagicMock())
+            if success:
+                call(*args, package="p", yes=True)
+            else:
+                with pytest.raises(click.ClickException):
+                    call(*args, package="p", yes=True)
+        assert refresh_mock.call_count == (1 if success else 0)
+
+    def test_only_install_update_remove_refresh(self):
+        tree = ast.parse(inspect.getsource(PluginCommand).lstrip())
+        callers = {
+            fn.name
+            for fn in ast.walk(tree)
+            if isinstance(fn, ast.FunctionDef)
+            for node in ast.walk(fn)
+            if isinstance(node, ast.Attribute) and node.attr == "_maybe_update_skills"
+        }
+        assert callers == {"_handle_install", "_handle_update", "_handle_remove"}
+
+    def test_refresh_ctrl_c_in_second_tool_keeps_first_and_no_staging(
+        self, home, bundle, monkeypatch
+    ):
+        write_state(
+            {"installed_skills": {"claude": {"paths": []}, "cursor": {"paths": []}}}
+        )
+        real = sg._swap
+
+        def swap(g, *a, **k):
+            if g.cli_name == "cursor":
+                raise KeyboardInterrupt
+            return real(g, *a, **k)
+
+        monkeypatch.setattr(sg, "_swap", swap)
+        with pytest.raises(KeyboardInterrupt):
+            PluginCommand()._maybe_update_skills()
+        state = sg.get_skills_state()
+        claude = state["skill_folders"]["claude"]["folders"]
+        assert {r["state"] for r in claude.values()} == {"installed"}
+        assert "cursor" not in state.get("skill_folders", {})
+        for cli in ("claude", "cursor"):
+            assert staging_dirs(gen(cli).skills_root()) == []
+
+    def test_refresh_leftover_staging_warns_on_stderr(
+        self, home, bundle, monkeypatch, capsys
+    ):
+        output._output_config["agentic"] = False
+        write_state({"installed_skills": {"claude": {"paths": []}}})
+        staging = gen("claude").skills_root() / ".deepctl-staging-x"
+        real = sg.install_tool
+        monkeypatch.setattr(
+            sg, "install_tool", lambda *a, **k: (real(*a, **k)[0], staging)
+        )
+        out, err = refresh(capsys)
+        assert err.splitlines() == ["⚠ " + sg._msg("E12", staging=staging)]
+        assert out == ""

deepctl_cmd_plugin-0.1.14/tests/unit/test_plugin_legacy_v03.py

@@ -0,0 +1,94 @@
+"""dg plugin's skills refresh runs the deepctl 0.3.x cleanup on stderr only."""
+
+import json
+import os
+import shutil
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import click
+import pytest
+from click.testing import CliRunner
+from deepctl_cmd_plugin import command as plugin_module
+from deepctl_cmd_plugin.command import PluginCommand
+from deepctl_cmd_plugin.models import PluginOperationResult
+from deepctl_core import output, skill_bundle
+from deepctl_core import skill_generator as sg
+from deepctl_core.skill_bundle import RepoSkill
+
+FIX = Path(__file__).parents[3] / "deepctl-core" / "tests" / "unit" / "fixtures"
+FIX = FIX / "legacy_v03"
+NAMES = ("api", "docs", "setup-mcp", "starters")
+pytestmark = pytest.mark.skipif(
+    os.name == "nt", reason="legacy cleanup is intentionally disabled on Windows"
+)
+
+
+@pytest.fixture(autouse=True)
+def home(tmp_path, monkeypatch):
+    home = tmp_path / "home"
+    home.mkdir()
+    monkeypatch.setattr(Path, "home", staticmethod(lambda: home))
+    monkeypatch.setenv("HOME", str(home))
+    monkeypatch.setenv("USERPROFILE", str(home))
+    monkeypatch.setattr(sg, "_SKILLS_DIR", home / ".deepctl" / "skills")
+    monkeypatch.setattr(sg, "_STATE_FILE", home / ".deepctl" / "skills" / "skills.json")
+    for con in (output.console, output.stderr_console, plugin_module.console):
+        monkeypatch.setattr(con, "_width", 400)
+    monkeypatch.delenv(skill_bundle.REF_ENV_VAR, raising=False)
+    monkeypatch.setattr(shutil, "which", lambda name: None)
+
+    def fetch(ref=None):
+        skills = []
+        for name in NAMES:
+            folder = tmp_path / "bundle" / "skills" / name
+            folder.mkdir(parents=True, exist_ok=True)
+            (folder / "SKILL.md").write_bytes(f"---\nname: {name}\n---\n".encode())
+            skills.append(RepoSkill(name, folder))
+        return skills
+
+    monkeypatch.setattr(skill_bundle, "fetch_skill_bundle", fetch)
+    saved = dict(output._output_config)
+    yield home
+    output._output_config.clear()
+    output._output_config.update(saved)
+
+
+def seed():
+    paths = []
+    for n in NAMES:
+        path = Path.home() / ".claude" / "commands" / "deepgram" / f"{n}.md"
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_bytes((FIX / f"{n}.md").read_bytes())
+        paths.append(str(path))
+    edited = Path.home() / ".cursor" / "rules" / "deepctl.mdc"
+    edited.parent.mkdir(parents=True)
+    edited.write_bytes((FIX / "deepctl.mdc").read_bytes() + b"mine\n")
+    legacy = {"claude": {"paths": paths}, "cursor": {"paths": [str(edited)]}}
+    sg._STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
+    sg._STATE_FILE.write_text(json.dumps({"installed_skills": legacy}), "utf-8")
+    return [Path(p) for p in paths], edited
+
+
+@pytest.mark.parametrize("agentic", [False, True])
+def test_plugin_remove_json_keeps_cleanup_off_stdout(agentic):
+    output._output_config.update(agentic=agentic, format="json", quiet=False)
+    files, edited = seed()
+    cmd = PluginCommand()
+    ok = PluginOperationResult(
+        success=True, action="remove", package="foo", message="Removed foo"
+    )
+    group = click.Group("plugin", commands=cmd.setup_commands())
+    obj = {"config": MagicMock(), "auth_manager": MagicMock(), "client": MagicMock()}
+    with patch.object(cmd, "remove_plugin", return_value=ok):
+        result = CliRunner().invoke(group, ["remove", "foo", "--yes"], obj=obj)
+    assert result.exit_code == 0, result.output
+    assert not any(p.exists() for p in files)
+    assert edited.exists()
+    assert "0.3.x" not in result.stdout
+    assert "deepctl can't prove it wrote" not in result.stdout
+    err = " ".join(result.stderr.split())
+    assert "Removed deepctl 0.3.x files for Claude Code" in err
+    assert "deepctl can't prove it wrote" in err
+    if agentic:
+        assert result.stdout == ""