boost-skill-cli 1.0.52__tar.gz → 1.0.53__tar.gz

{boost_skill_cli-1.0.52 → boost_skill_cli-1.0.53}/PKG-INFO

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

{boost_skill_cli-1.0.52 → boost_skill_cli-1.0.53}/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.52'
-__version_tuple__ = version_tuple = (1, 0, 52)
+__version__ = version = '1.0.53'
+__version_tuple__ = version_tuple = (1, 0, 53)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.52 → boost_skill_cli-1.0.53}/boost_cli/core/config.py

@@ -5,7 +5,7 @@ import json
 from copy import deepcopy
 from typing import Any
 
-from . import paths
+from . import paths, util
 
 DEFAULTS = {
     "agents": {
@@ -90,7 +90,8 @@ def load() -> dict:
 
 def save(cfg: dict) -> None:
     paths.ensure_dirs()
-    paths.config_path().write_text(json.dumps(cfg, indent=2, sort_keys=False) + "\n")
+    util.atomic_write_text(
+        paths.config_path(), json.dumps(cfg, indent=2, sort_keys=False) + "\n")
 
 
 def get(dotted: str, default=None):

{boost_skill_cli-1.0.52 → boost_skill_cli-1.0.53}/boost_cli/core/journal.py

@@ -67,4 +67,6 @@ def _maybe_rotate() -> None:
     except OSError:
         return
     if len(lines) > ROTATE_AT:
-        p.write_text("\n".join(lines[-ROTATE_KEEP:]) + "\n")
+        # Atomic swap: a bare write_text here races concurrent log() appends and
+        # can truncate the feed mid-line if interrupted.
+        util.atomic_write_text(p, "\n".join(lines[-ROTATE_KEEP:]) + "\n")

{boost_skill_cli-1.0.52 → boost_skill_cli-1.0.53}/boost_cli/core/lockfile.py

@@ -26,16 +26,41 @@ def _skeleton() -> dict:
 def read() -> dict:
     p = paths.lockfile_path()
     if not p.exists():
-        return _skeleton()
+        return _skeleton()          # empty: never installed anything yet
     try:
         lock = json.loads(p.read_text())
     except (json.JSONDecodeError, OSError):
+        # Corrupt (present but unparseable) is NOT the same as empty: returning
+        # a bare skeleton here would let the next write() overwrite the only
+        # record of every prior install. Preserve the bytes for recovery and
+        # surface it loudly before falling back to the skeleton.
+        _preserve_corrupt(p)
         return _skeleton()
     lock.setdefault("version", SCHEMA_VERSION)
     lock.setdefault("skills", {})
     return lock
 
 
+def _preserve_corrupt(p) -> None:
+    """Copy an unparseable lock file aside as ``<lock>.corrupt`` and warn.
+
+    Best effort: a read must still succeed (returning the skeleton) even if the
+    sidecar cannot be written, so failures here are swallowed after logging.
+    """
+    try:
+        backup = p.with_name(p.name + ".corrupt")
+        shutil.copy(p, backup)
+    except OSError:
+        backup = None
+    try:
+        from . import logs
+        logs.get_logger().warning(
+            "lock file %s is corrupt; preserved %s and continuing with an "
+            "empty lock", p, backup or "(backup failed)")
+    except Exception:
+        pass
+
+
 def write(lock: dict) -> None:
     paths.ensure_dirs()
     p = paths.lockfile_path()
@@ -52,7 +77,7 @@ def write(lock: dict) -> None:
         _prune_history()
     lock["version"] = SCHEMA_VERSION
     lock["updated"] = util.now_iso()
-    p.write_text(json.dumps(lock, indent=2, sort_keys=True) + "\n")
+    util.atomic_write_text(p, json.dumps(lock, indent=2, sort_keys=True) + "\n")
 
 
 def _history_files() -> List:

{boost_skill_cli-1.0.52 → boost_skill_cli-1.0.53}/boost_cli/core/util.py

@@ -2,7 +2,9 @@
 from __future__ import annotations
 
 import hashlib
+import os
 import re
+import tempfile
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import List, Tuple
@@ -10,6 +12,36 @@ from typing import List, Tuple
 IGNORED = {".git", "__pycache__", ".DS_Store"}
 
 
+def atomic_write_text(path: Path, text: str, encoding: str = "utf-8") -> None:
+    """Write ``text`` to ``path`` so a reader never sees a partial file.
+
+    The bytes go to a temp file in the *same* directory (so the rename stays on
+    one filesystem and is atomic), get flushed and fsynced to disk, then swap
+    into place with ``os.replace``. An interrupted or concurrent write can no
+    longer truncate the target: the previous file survives intact until the
+    complete new one atomically replaces it. This is the corruption-safe
+    substitute for a bare ``Path.write_text`` on any file boost must not lose —
+    the lock file, the config, the pulse journal.
+    """
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd, tmp = tempfile.mkstemp(dir=str(path.parent),
+                               prefix="." + path.name + ".", suffix=".tmp")
+    try:
+        with os.fdopen(fd, "w", encoding=encoding) as f:
+            f.write(text)
+            f.flush()
+            os.fsync(f.fileno())
+        os.replace(tmp, str(path))
+    except BaseException:
+        # Never leave a temp turd behind, and never mask the original error.
+        try:
+            os.unlink(tmp)
+        except OSError:
+            pass
+        raise
+
+
 def now_iso() -> str:
     return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
 

{boost_skill_cli-1.0.52 → boost_skill_cli-1.0.53}/boost_skill_cli.egg-info/PKG-INFO

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

{boost_skill_cli-1.0.52 → boost_skill_cli-1.0.53}/tests/unit/test_lockfile.py

@@ -35,6 +35,31 @@ class TestRead:
         assert lock["version"] == 3
         assert lock["skills"] == {}
 
+    def test_corrupt_file_preserved_as_sidecar(self, sandbox):
+        paths.ensure_dirs()
+        p = paths.lockfile_path()
+        p.write_text("{definitely not json")
+        lockfile.read()
+        backup = p.with_name(p.name + ".corrupt")
+        assert backup.exists()
+        assert backup.read_text() == "{definitely not json"
+
+    def test_missing_file_leaves_no_sidecar(self, sandbox):
+        lockfile.read()
+        p = paths.lockfile_path()
+        assert not p.with_name(p.name + ".corrupt").exists()
+
+    def test_corrupt_read_does_not_lose_prior_records(self, sandbox):
+        # A corrupt lock followed by a new install must not silently erase the
+        # only surviving copy of the earlier records — they live on in .corrupt.
+        paths.ensure_dirs()
+        p = paths.lockfile_path()
+        p.write_text('{"skills": {"old": {"version": "1.0"}}, TRAILING GARBAGE')
+        lockfile.set_skill("new", {"version": "2.0"})
+        assert set(lockfile.installed()) == {"new"}      # skeleton took over
+        backup = p.with_name(p.name + ".corrupt")
+        assert '"old"' in backup.read_text()             # but old bytes survive
+
     def test_missing_keys_defaulted(self, sandbox):
         paths.ensure_dirs()
         paths.lockfile_path().write_text('{"skills": {"a": {}}}')

{boost_skill_cli-1.0.52 → boost_skill_cli-1.0.53}/tests/unit/test_util.py

@@ -364,3 +364,47 @@ class TestScoreSkill:
         assert len(text) == 48_000
         d = make_skill(tmp_path, text)
         assert util.score_skill(d) == (95, [])
+
+
+class TestAtomicWriteText:
+    def test_writes_content(self, tmp_path):
+        p = tmp_path / "f.txt"
+        util.atomic_write_text(p, "hello")
+        assert p.read_text() == "hello"
+
+    def test_overwrites_existing(self, tmp_path):
+        p = tmp_path / "f.txt"
+        p.write_text("old")
+        util.atomic_write_text(p, "new")
+        assert p.read_text() == "new"
+
+    def test_creates_missing_parents(self, tmp_path):
+        p = tmp_path / "a" / "b" / "f.txt"
+        util.atomic_write_text(p, "deep")
+        assert p.read_text() == "deep"
+
+    def test_leaves_no_temp_files(self, tmp_path):
+        util.atomic_write_text(tmp_path / "f.txt", "x")
+        leftovers = [q.name for q in tmp_path.iterdir() if q.name != "f.txt"]
+        assert leftovers == []
+
+    def test_honours_encoding(self, tmp_path):
+        p = tmp_path / "f.txt"
+        util.atomic_write_text(p, "café", encoding="utf-8")
+        assert p.read_bytes() == "café".encode("utf-8")
+
+    def test_replace_failure_cleans_temp_and_raises(self, tmp_path, monkeypatch):
+        import os as _os
+        p = tmp_path / "f.txt"
+        p.write_text("original")
+
+        def boom(_src, _dst):
+            raise OSError("replace failed")
+
+        monkeypatch.setattr(_os, "replace", boom)
+        with pytest.raises(OSError, match="replace failed"):
+            util.atomic_write_text(p, "new")
+        # original untouched, and no temp turd left behind
+        assert p.read_text() == "original"
+        leftovers = [q.name for q in tmp_path.iterdir() if q.name != "f.txt"]
+        assert leftovers == []