boost-skill-cli 1.2.124__tar.gz → 1.2.125__tar.gz

{boost_skill_cli-1.2.124/boost_skill_cli.egg-info → boost_skill_cli-1.2.125}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.124
+Version: 1.2.125
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0

{boost_skill_cli-1.2.124 → boost_skill_cli-1.2.125}/boost_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.2.124'
-__version_tuple__ = version_tuple = (1, 2, 124)
+__version__ = version = '1.2.125'
+__version_tuple__ = version_tuple = (1, 2, 125)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.124 → boost_skill_cli-1.2.125}/boost_cli/commands/configuration.py

@@ -312,6 +312,11 @@ def _freight_bytes(tap_path: Path, keep_dirs: list[str]) -> int:
     return total
 
 
+# `boost doctor`'s wording for the same condition (quality.py), so the two
+# commands describe one missing clone in one sentence.
+_NOT_CLONED = "not cloned — run `boost update`"
+
+
 def cmd_compact(argv) -> int:
     """boost compact [--dry-run] [--reclone] [TAP ...]"""
     p = cliparse.parser(
@@ -329,12 +334,25 @@ def cmd_compact(argv) -> int:
     rows: list[dict] = []
 
     taps = [registry.get(n) for n in args.tap] if args.tap else registry.list_taps()
+    # A named tap is a request about that one tap (`registry.update`'s
+    # convention), so a missing clone is the answer to it. Filtering it out
+    # silently used to fall through to a green, global "no cloned taps to
+    # compact" that never named the tap — while `doctor` exited 1 on it.
+    if args.tap:
+        for tap in taps:
+            if not tap.is_cloned:
+                rows.append({"tap": tap.name, "error": _NOT_CLONED})
+                out.warn("tap %s %s" % (tap.name, _NOT_CLONED),
+                         stream=sys.stderr if args.json else None)
     taps = [t for t in taps if t.is_cloned]
     if not taps:
         if args.json:
-            print(json.dumps({"taps": [], "count": 0, "bytes": 0,
-                              "dry_run": args.dry_run, "ok": True}, indent=2))
-            return 0
+            print(json.dumps({"taps": rows, "count": 0, "bytes": 0,
+                              "dry_run": args.dry_run, "ok": not rows},
+                             indent=2))
+            return 1 if rows else 0
+        if rows:
+            return 1
         out.ok("no cloned taps to compact")
         return 0
 
@@ -348,6 +366,7 @@ def cmd_compact(argv) -> int:
 
     freed = 0
     changed = 0
+    broken = 0                  # cloned taps this run failed on
     for tap in taps:
         before = util.dir_size(tap.path)
         if args.dry_run:
@@ -399,6 +418,7 @@ def cmd_compact(argv) -> int:
             for rel in keep.get(tap.name, []):
                 gitutil.materialize(tap.path, rel)
         except BoostError as e:
+            broken += 1
             rows.append({"tap": tap.name, "error": str(e)})
             out.warn("could not compact %s: %s" % (tap.name, e),
                      stream=sys.stderr if args.json else None)
@@ -416,28 +436,37 @@ def cmd_compact(argv) -> int:
                 out.info("%s  %s → %s" % (tap.name, util.human_size(before),
                                           util.human_size(after)))
 
+    failed = any("error" in r for r in rows)
+    # Named: any failure is the answer (see above). Swept: fail only when no
+    # tap got through, as `boost update` does — a partial sweep did the job
+    # it could.
+    rc = 1 if failed and (args.tap or broken == len(taps)) else 0
     if args.dry_run:
         if args.json:
             print(json.dumps({"taps": rows, "count": changed, "bytes": freed,
-                              "dry_run": True, "ok": True}, indent=2))
-            return 0
+                              "dry_run": True, "ok": not failed}, indent=2))
+            return rc
         out.dim("  %d tap(s) · %s would be freed"
                 % (changed, util.human_size(freed)))
-        return 0
+        return rc
     journal.log("compact", "%d taps" % changed, freed=util.human_size(freed))
     if args.json:
         print(json.dumps({"taps": rows, "count": changed, "bytes": freed,
-                          "dry_run": False,
-                          "ok": not any("error" in r for r in rows)}, indent=2))
-        return 0
+                          "dry_run": False, "ok": not failed}, indent=2))
+        return rc
     if not changed:
-        out.ok("every tap is already compact")
-        return 0
+        # Not an all-clear over a tap that failed — the warning above it is
+        # the report for that one.
+        if not failed:
+            out.ok("every tap is already compact")
+        elif broken < len(taps):
+            out.ok("every other tap is already compact")
+        return rc
     out.ok("compacted %d tap(s) · %s freed" % (changed, util.human_size(freed)))
     if not args.reclone:
         out.dim("  `boost compact --reclone` also drops already-downloaded "
                 "git objects")
-    return 0
+    return rc
 
 
 # ---------------------------------------------------------------- create

{boost_skill_cli-1.2.124 → boost_skill_cli-1.2.125/boost_skill_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.124
+Version: 1.2.125
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0

{boost_skill_cli-1.2.124 → boost_skill_cli-1.2.125}/docs/roadmap/items/compact-answers-a-named-tap-with-a-global-all-clear.md

@@ -2,15 +2,15 @@
 id: compact-answers-a-named-tap-with-a-global-all-clear
 board: code
 section: internals
-status: planned
+status: shipped
 category: CLI · Bug
 complexity: S
 impact: Medium
 wow: 2
 note: boost compact <tap> on an uncloned tap prints a green "no cloned taps to compact" and exits 0
 order: 311
-owner:
-pr:
+owner: loop/compact-named-tap
+pr: 873
 title: "<code>compact &lt;tap&gt;</code> answers a question about one tap with a global all-clear"
 ---
 <code>cmd_compact</code> resolves its named taps and then filters

{boost_skill_cli-1.2.124 → boost_skill_cli-1.2.125}/docs/roadmap.html

@@ -4083,29 +4083,9 @@ Scope limits of my repro:
       </article>
 
       <article class="cap rcard" id="compact-answers-a-named-tap-with-a-global-all-clear">
-        <div class="head"><span class="pill planned">Planned</span><span class="cat">CLI · Bug</span></div>
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">CLI · Bug</span></div>
         <h3><code>compact &lt;tap&gt;</code> answers a question about one tap with a global all-clear</h3>
-        <p><code>cmd_compact</code> resolves its named taps and then filters
-(<code>taps = [t for t in taps if t.is_cloned]</code>). A tap that is configured but has
-no clone falls out of that list silently, so the empty-list branch fires and prints
-<em>&ldquo;&#10003; no cloned taps to compact&rdquo;</em> with exit 0 &mdash; a green,
-plural, global-sounding all-clear in answer to a question about one specific tap, which
-it never names.
-
-Reproduced on a scratch <code>BOOST_HOME</code>: tap a repo, delete its clone directory,
-then <code>boost compact &lt;that-tap&gt;</code> &rarr; <code>rc=0</code>,
-<em>&ldquo;&#10003; no cloned taps to compact&rdquo;</em>. Meanwhile
-<code>boost doctor</code> exits 1 on the same machine and says
-<em>&ldquo;! tap &lt;x&gt; not cloned &mdash; run <code>boost update</code>&rdquo;</em>,
-so the information exists and this command is the one that withholds it.
-
-This contradicts the convention <code>registry.update</code> states in its own docstring:
-<em>&ldquo;A named tap still raises. <code>boost update sometap</code> is a request about
-that one tap, so its failure is the answer to the question asked.&rdquo;</em> The sweep
-form is right to stay quiet; the named form is not. Fix: when <code>args.tap</code> named
-taps and the filter dropped some, say which and why, and point at
-<code>boost update</code> the way <code>doctor</code> does &mdash; and do not report
-success for a tap nothing was done to.</p>
+        <p class="cardbody"><a class="writeup" href="https://github.com/jonnyeclectic/boost/blob/main/docs/roadmap/items/compact-answers-a-named-tap-with-a-global-all-clear.md">Write-up &middot; compact-answers-a-named-tap-with-a-global-all-clear.md</a></p>
         <div class="meta">
           <span class="m">Complexity <b>S</b></span>
           <span class="m">Impact <b>Medium</b></span>

{boost_skill_cli-1.2.124 → boost_skill_cli-1.2.125}/tests/unit/test_compact.py

@@ -246,7 +246,8 @@ class TestRecloneHonoursThePin:
 
         monkeypatch.setattr(gitutil, "checkout_commit", unreachable)
 
-        res = boost("compact", "--reclone")
+        # The only tap failed, so the sweep failed — `boost update`'s rule.
+        res = boost("compact", "--reclone", expect=1)
 
         assert not clone.exists()
         # The re-raise is what makes the diagnostic name the *pin*. Without it
@@ -268,3 +269,109 @@ def os_utime(pth):
     import os
     st = pth.stat()
     os.utime(pth, (st.st_atime + 10_000, st.st_mtime + 10_000))
+
+
+class TestANamedTapIsAnsweredAboutThatTap:
+    """`boost compact <tap>` is a question about one tap, so a tap with no
+    clone is the answer — not something filtered away into a green, global
+    "no cloned taps to compact" that never names it. The sweep form stays
+    quiet, as `boost update` does for a sweep."""
+
+    @staticmethod
+    def _uncloned(boost, tmp_path, name="src"):
+        from boost_cli.core import util
+        src = _repo(tmp_path / name)
+        boost("tap", str(src))
+        tap = next(t for t in registry.list_taps() if t.name == name)
+        util.rmtree(tap.path)
+        return tap
+
+    def test_named_uncloned_tap_is_named_and_fails(self, boost, sandbox,
+                                                   tmp_path):
+        tap = self._uncloned(boost, tmp_path)
+        res = boost("compact", tap.name, expect=1)
+        assert "no cloned taps" not in res.out
+        # doctor's sentence for the same condition, naming this tap.
+        assert "tap src not cloned — run `boost update`" in res.out
+
+    def test_named_uncloned_tap_in_json_is_a_failed_row(self, boost, sandbox,
+                                                        tmp_path):
+        import json
+        tap = self._uncloned(boost, tmp_path)
+        res = boost("compact", tap.name, "--json", expect=1)
+        d = json.loads(res.out)                  # the warning went to stderr
+        assert d["ok"] is False and d["count"] == 0
+        assert d["taps"] == [{"tap": "src",
+                              "error": "not cloned — run `boost update`"}]
+        assert "src not cloned" in res.err
+
+    def test_dry_run_answers_the_same_way(self, boost, sandbox, tmp_path):
+        tap = self._uncloned(boost, tmp_path)
+        res = boost("compact", tap.name, "--dry-run", expect=1)
+        assert "src not cloned" in res.out
+        assert "no cloned taps" not in res.out
+
+    def test_the_cloned_half_of_a_named_pair_is_still_compacted(
+            self, boost, sandbox, tmp_path):
+        import json
+        gone = self._uncloned(boost, tmp_path, "gone")
+        src = _repo(tmp_path / "src")
+        boost("tap", str(src))
+        clone = next(t for t in registry.list_taps() if t.name == "src").path
+        gitutil.run(["-C", str(clone), "sparse-checkout", "disable"])
+
+        res = boost("compact", "src", gone.name, "--json", expect=1)
+
+        d = json.loads(res.out)
+        assert d["ok"] is False and d["count"] == 1
+        assert {r["tap"] for r in d["taps"]} == {"src", "gone"}
+        assert not (clone / "node_modules" / "pkg.js").exists()
+
+    def test_named_cloned_dry_run_passes(self, boost, sandbox, tmp_path):
+        import json
+        src = _repo(tmp_path / "src")
+        boost("tap", str(src))
+        d = json.loads(boost("compact", "src", "--dry-run", "--json").out)
+        assert d["ok"] is True
+
+    def test_the_sweep_stays_quiet_about_a_missing_clone(self, boost, sandbox,
+                                                         tmp_path):
+        self._uncloned(boost, tmp_path)
+        res = boost("compact")                   # rc 0: nothing was asked of it
+        assert "no cloned taps to compact" in res.out
+        assert "not cloned" not in res.out
+
+    def test_a_failed_named_tap_gets_no_all_clear(self, boost, sandbox,
+                                                  tmp_path, monkeypatch):
+        from boost_cli.errors import BoostError
+        src = _repo(tmp_path / "src")
+        boost("tap", str(src))
+
+        def refuse(path):
+            raise BoostError("sparse-checkout failed")
+
+        monkeypatch.setattr(gitutil, "narrow", refuse)
+        res = boost("compact", "src", expect=1)
+        assert "could not compact src" in res.out
+        assert "already compact" not in res.out
+        # A sweep whose every tap failed fails too, as `boost update` does.
+        res = boost("compact", expect=1)
+        assert "already compact" not in res.out
+
+    def test_a_partial_sweep_passes_but_certifies_only_the_rest(
+            self, boost, sandbox, tmp_path, monkeypatch):
+        from boost_cli.errors import BoostError
+        for name in ("good", "bad"):
+            boost("tap", str(_repo(tmp_path / name)))
+        real = gitutil.narrow
+
+        def refuse_bad(path):
+            if path.name == "bad":
+                raise BoostError("sparse-checkout failed")
+            return real(path)
+
+        monkeypatch.setattr(gitutil, "narrow", refuse_bad)
+        res = boost("compact")                   # one tap got through: rc 0
+        assert "could not compact bad" in res.out
+        assert "every other tap is already compact" in res.out
+        assert "every tap is already compact" not in res.out