boost-skill-cli 1.0.56__tar.gz → 1.0.58__tar.gz

{boost_skill_cli-1.0.56 → boost_skill_cli-1.0.58}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.56
+Version: 1.0.58
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE

{boost_skill_cli-1.0.56 → boost_skill_cli-1.0.58}/boost_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.56'
-__version_tuple__ = version_tuple = (1, 0, 56)
+__version__ = version = '1.0.58'
+__version_tuple__ = version_tuple = (1, 0, 58)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.56 → boost_skill_cli-1.0.58}/boost_cli/core/store.py

@@ -5,8 +5,10 @@ install():  copy skill dir from a tap clone -> store, symlink into every
 """
 from __future__ import annotations
 
+import os
 import re
 import shutil
+import tempfile
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Dict, List, Optional
@@ -76,10 +78,38 @@ def unlink_agents(name: str) -> List[str]:
 
 
 def _copy_skill(src: Path, dest: Path) -> None:
-    if dest.exists():
-        shutil.rmtree(dest)
-    shutil.copytree(src, dest,
-                    ignore=shutil.ignore_patterns(".git", "__pycache__", ".DS_Store"))
+    """Copy a skill tree into ``dest`` atomically.
+
+    The old rmtree-then-copytree left a window where a crash destroyed the
+    previous good copy before the new one finished — on a reinstall/upgrade the
+    skill would vanish while the lock file still referenced it, so store and
+    lock disagreed. Instead stage the full copy in a temp dir on the same
+    filesystem, then swap it in with directory renames: the existing copy stays
+    untouched until the new one is complete, the failure window shrinks to two
+    fast renames, and a failed swap rolls back to the original.
+    """
+    dest = Path(dest)
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    staged = Path(tempfile.mkdtemp(dir=str(dest.parent),
+                                   prefix="." + dest.name + ".tmp"))
+    backup = None
+    try:
+        shutil.copytree(
+            src, staged, dirs_exist_ok=True,
+            ignore=shutil.ignore_patterns(".git", "__pycache__", ".DS_Store"))
+        if dest.exists():
+            backup = staged.with_name(staged.name + ".old")
+            os.replace(dest, backup)      # move the old copy aside (atomic)
+        os.replace(staged, dest)          # swap the new copy in (atomic)
+    except BaseException:
+        if backup is not None and not dest.exists():
+            os.replace(backup, dest)      # swap-in failed: restore the original
+        shutil.rmtree(staged, ignore_errors=True)
+        if backup is not None and backup.exists():
+            shutil.rmtree(backup, ignore_errors=True)
+        raise
+    if backup is not None:
+        shutil.rmtree(backup, ignore_errors=True)
 
 
 def install(entry: dict, force: bool = False,

{boost_skill_cli-1.0.56 → boost_skill_cli-1.0.58}/boost_skill_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.56
+Version: 1.0.58
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE

{boost_skill_cli-1.0.56 → boost_skill_cli-1.0.58}/tests/unit/test_store.py

@@ -423,3 +423,69 @@ class TestSyncApply:
 
     def test_nothing_to_do_no_actions(self, brainstorming):
         assert store.sync_apply(store.sync_plan()) == []
+
+
+class TestCopySkillAtomic:
+    def _mkskill(self, root, name, body="v1"):
+        d = root / name
+        d.mkdir(parents=True)
+        (d / "SKILL.md").write_text(body)
+        return d
+
+    def _leftovers(self, parent, keep):
+        return sorted(p.name for p in parent.iterdir() if p.name != keep)
+
+    def test_fresh_copy(self, tmp_path):
+        src = self._mkskill(tmp_path / "src", "sk")
+        (src / ".git").mkdir()
+        (src / ".git" / "cfg").write_text("junk")
+        dest = tmp_path / "store" / "sk"
+        store._copy_skill(src, dest)
+        assert (dest / "SKILL.md").read_text() == "v1"
+        assert not (dest / ".git").exists()           # ignore patterns honoured
+        assert self._leftovers(dest.parent, "sk") == []   # no temp/backup dirs
+
+    def test_reinstall_replaces_and_cleans_up(self, tmp_path):
+        src1 = self._mkskill(tmp_path / "s1", "sk", body="old")
+        dest = tmp_path / "store" / "sk"
+        store._copy_skill(src1, dest)
+        src2 = self._mkskill(tmp_path / "s2", "sk", body="new")
+        store._copy_skill(src2, dest)
+        assert (dest / "SKILL.md").read_text() == "new"
+        assert self._leftovers(dest.parent, "sk") == []
+
+    def test_swap_in_failure_rolls_back_to_original(self, tmp_path, monkeypatch):
+        src1 = self._mkskill(tmp_path / "s1", "sk", body="original")
+        dest = tmp_path / "store" / "sk"
+        store._copy_skill(src1, dest)          # dest now holds the good copy
+        src2 = self._mkskill(tmp_path / "s2", "sk", body="broken")
+
+        real = store.os.replace
+        calls = {"n": 0}
+
+        def flaky(a, b):
+            calls["n"] += 1
+            if calls["n"] == 2:                # the swap-IN of the new copy
+                raise OSError("swap failed")
+            return real(a, b)
+
+        monkeypatch.setattr(store.os, "replace", flaky)
+        with pytest.raises(OSError, match="swap failed"):
+            store._copy_skill(src2, dest)
+        # original survives intact, nothing half-swapped, no debris
+        assert (dest / "SKILL.md").read_text() == "original"
+        assert self._leftovers(dest.parent, "sk") == []
+
+    def test_copytree_failure_preserves_existing(self, tmp_path, monkeypatch):
+        src1 = self._mkskill(tmp_path / "s1", "sk", body="original")
+        dest = tmp_path / "store" / "sk"
+        store._copy_skill(src1, dest)
+
+        def boom(*a, **k):
+            raise OSError("copy failed")
+
+        monkeypatch.setattr(store.shutil, "copytree", boom)
+        with pytest.raises(OSError, match="copy failed"):
+            store._copy_skill(tmp_path / "s1" / "sk", dest)
+        assert (dest / "SKILL.md").read_text() == "original"
+        assert self._leftovers(dest.parent, "sk") == []