boost-skill-cli 1.0.231__tar.gz → 1.0.232__tar.gz

{boost_skill_cli-1.0.231 → boost_skill_cli-1.0.232}/PKG-INFO

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

{boost_skill_cli-1.0.231 → boost_skill_cli-1.0.232}/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.231'
-__version_tuple__ = version_tuple = (1, 0, 231)
+__version__ = version = '1.0.232'
+__version_tuple__ = version_tuple = (1, 0, 232)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.231 → boost_skill_cli-1.0.232}/boost_cli/commands/configuration.py

@@ -26,6 +26,7 @@ from ..core import (
     policy,
     rag,
     registry,
+    selfupdate,
     serve,
     store,
     util,
@@ -1004,12 +1005,47 @@ def cmd_self_update(argv) -> int:
     p = cliparse.parser(
         prog="boost self-update",
         description="Update boost itself to the latest version")
-    p.parse_args(argv)
+    p.add_argument("--dry-run", action="store_true",
+                   help="show how boost would update itself, change nothing")
+    args = p.parse_args(argv)
+
+    method = selfupdate.detect()
+    if method != selfupdate.GIT:
+        return _self_update_package(method, dry_run=args.dry_run)
+    return _self_update_git(dry_run=args.dry_run)
+
+
+def _self_update_package(method: str, dry_run: bool) -> int:
+    """Upgrade a pip / pipx / uv-tool install by driving its own manager."""
+    old = __version__
+    cmd = selfupdate.upgrade_command(method)   # errors if the manager is gone
+    if dry_run:
+        out.info("installed with: %s" % method)
+        out.info("would run: %s" % " ".join(cmd))
+        return 0
+    out.info("updating via %s: %s" % (method, " ".join(cmd)))
+    selfupdate.run_upgrade(cmd)
+    # This process imported its version before the upgrade, so ask a fresh one.
+    new = selfupdate.observed_version()
+    journal.log("self-update", new or old, previous=old, method=method)
+    if new and new != old:
+        out.ok("boost v%s → v%s" % (old, new))
+    elif new:
+        out.ok("already up to date (v%s)" % new)
+    else:
+        # The upgrade succeeded but we never saw a version — say exactly that
+        # rather than claim one.
+        out.ok("upgraded via %s; run `boost --version` to confirm" % method)
+    return 0
+
 
+def _self_update_git(dry_run: bool) -> int:
+    """Fast-forward the source checkout boost is running from."""
     root = paths.repo_root()
-    if not gitutil.is_repo(root):
-        raise BoostError("boost is not running from a git checkout",
-                        hint="git clone the boost repo and symlink bin")
+    if dry_run:
+        out.info("installed with: git checkout (%s)" % _tilde(root))
+        out.info("would run: git -C %s pull --ff-only" % root)
+        return 0
     old = __version__
     before = gitutil.head_commit(root)
     gitutil.run(["-C", str(root), "pull", "--ff-only"], timeout=120)

boost_skill_cli-1.0.232/boost_cli/core/selfupdate.py

@@ -0,0 +1,138 @@
+"""How this boost was installed, and the command that upgrades it in place.
+
+`boost self-update` assumed a git checkout and told everyone else to abandon
+their install method — but the documented way in is `pipx install
+boost-skill-cli` or `pip install boost-skill-cli`, where the package lives in
+site-packages and there is nothing to `git pull`. This resolves the install
+method from evidence on disk and hands the command layer the exact argv that
+upgrades *this* copy.
+"""
+from __future__ import annotations
+
+import re
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+from ..errors import BoostError
+from . import gitutil, paths
+
+DIST = "boost-skill-cli"
+
+GIT = "git"
+PIPX = "pipx"
+UV_TOOL = "uv-tool"
+PIP = "pip"
+UNKNOWN = "unknown"
+
+# `boost --version` prints "boost <version>"; anything else means we did not
+# actually observe a version and must not report one.
+_VERSION_LINE = re.compile(r"^boost\s+(\S+)$", re.MULTILINE)
+
+
+def installed_version() -> Optional[str]:
+    """Version recorded in installed package metadata, or None.
+
+    None is the useful answer, not a failure: it means no Python package
+    manager has a record of this boost, so none of them can upgrade it.
+    """
+    try:
+        from importlib.metadata import version
+        return version(DIST)
+    except Exception:
+        return None
+
+
+def detect(root: Optional[Path] = None, prefix: Optional[Path] = None,
+           metadata_version=None) -> str:
+    """Resolve how this boost was installed.
+
+    Order matters. A source checkout wins first — that includes `pip install
+    -e .`, where the package metadata exists too but `git pull` is what the
+    user means. Then the two managers that own a private venv and leave a
+    receipt inside it. Then plain pip, but only if pip actually has a record
+    of the distribution: telling someone to `pip install --upgrade` a boost
+    that pip never installed sends them chasing a package that isn't there.
+    """
+    root = paths.repo_root() if root is None else Path(root)
+    if gitutil.is_repo(root):
+        return GIT
+    prefix = Path(sys.prefix) if prefix is None else Path(prefix)
+    if (prefix / "pipx_metadata.json").is_file():
+        return PIPX
+    if (prefix / "uv-receipt.toml").is_file():
+        return UV_TOOL
+    # Resolved here, not as a default argument: a default binds the function
+    # object once at import, which silently defeats every attempt to swap it —
+    # including a test's, which is how a test of the "nothing installed this"
+    # branch ended up running a real `pip install` against PyPI.
+    lookup = installed_version if metadata_version is None else metadata_version
+    return PIP if lookup() else UNKNOWN
+
+
+def _require(tool: str) -> str:
+    """Absolute path to `tool`, or a BoostError naming what is missing.
+
+    Falling back to another manager here would upgrade a different copy of
+    boost — or none at all — while reporting success.
+    """
+    found = shutil.which(tool)
+    if not found:
+        raise BoostError(
+            "boost was installed with %s, but %s is not on PATH" % (tool, tool),
+            hint="install %s, or upgrade manually with `%s upgrade %s`"
+                 % (tool, tool, DIST))
+    return found
+
+
+def upgrade_command(method: str) -> List[str]:
+    """The argv that upgrades boost for `method`."""
+    if method == PIPX:
+        return [_require("pipx"), "upgrade", DIST]
+    if method == UV_TOOL:
+        return [_require("uv"), "tool", "upgrade", DIST]
+    if method == PIP:
+        # sys.executable, never a bare `pip`: the pip first on PATH can belong
+        # to a different interpreter than the one running boost, and upgrading
+        # that one leaves this install exactly where it was while printing
+        # every sign of success.
+        return [sys.executable, "-m", "pip", "install", "--upgrade", DIST]
+    raise BoostError(
+        "cannot work out how boost was installed, so it cannot update itself",
+        hint="upgrade with your package manager, e.g. `pipx upgrade %s`" % DIST)
+
+
+def run_upgrade(cmd: List[str], timeout: float = 300.0):
+    """Run the upgrade, raising BoostError with the manager's own last words."""
+    try:
+        proc = subprocess.run(cmd, capture_output=True, text=True,
+                              timeout=timeout)
+    except (OSError, subprocess.SubprocessError) as err:
+        raise BoostError("could not run %s" % " ".join(cmd),
+                         hint=str(err)) from err
+    if proc.returncode != 0:
+        detail = ((proc.stderr or "") + (proc.stdout or "")).strip().splitlines()
+        raise BoostError(
+            "upgrade failed (%s exited %d)" % (Path(cmd[0]).name, proc.returncode),
+            hint=detail[-1] if detail else "re-run the command by hand to see why")
+    return proc
+
+
+def observed_version(timeout: float = 30.0) -> Optional[str]:
+    """Ask a freshly-spawned boost what version it is now, or None.
+
+    This process imported its own version before the upgrade ran, so it cannot
+    answer the question. None means "we did not see one" — better to say
+    nothing than to report a version we never observed.
+    """
+    try:
+        proc = subprocess.run([str(paths.launcher()), "--version"],
+                              capture_output=True, text=True, timeout=timeout)
+    except (OSError, subprocess.SubprocessError):
+        return None
+    if proc.returncode != 0:
+        return None
+    match = _VERSION_LINE.search(proc.stdout or "")
+    return match.group(1) if match else None

{boost_skill_cli-1.0.231 → boost_skill_cli-1.0.232}/boost_skill_cli.egg-info/PKG-INFO

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

{boost_skill_cli-1.0.231 → boost_skill_cli-1.0.232}/boost_skill_cli.egg-info/SOURCES.txt

@@ -81,6 +81,7 @@ boost_cli/core/resolve.py
 boost_cli/core/rules.py
 boost_cli/core/scopes.py
 boost_cli/core/secretscan.py
+boost_cli/core/selfupdate.py
 boost_cli/core/serve.py
 boost_cli/core/stackprobe.py
 boost_cli/core/staleness.py
@@ -460,6 +461,7 @@ tests/unit/test_roadmap_fresh.py
 tests/unit/test_rules.py
 tests/unit/test_scopes.py
 tests/unit/test_secretscan.py
+tests/unit/test_selfupdate.py
 tests/unit/test_serve.py
 tests/unit/test_spin.py
 tests/unit/test_stackprobe.py

{boost_skill_cli-1.0.231 → boost_skill_cli-1.0.232}/docs/commands.html

@@ -188,7 +188,7 @@
       <a class="cmd-link" href="#cmd-mcp" data-search="mcp register boost as an mcp server for claude code  --stdio {register,unregister}">mcp</a>
       <a class="cmd-link" href="#cmd-hooks" data-search="hooks manage claude code hooks (scope-aware) in settings.json  -c, --command command -n, --name name -s, --scope {global,project} -m, --matcher matcher --timeout timeout {add,remove,list} event">hooks</a>
       <a class="cmd-link" href="#cmd-bmad" data-search="bmad install &amp; manage the bmad method (scope-aware, toggleable)  -s, --scope {project,global} --modules modules -y, --yes --startup {install,init,startup,orient,uninstall,disable,enable,doctor,status} value">bmad</a>
-      <a class="cmd-link" href="#cmd-self-update" data-search="self-update update boost itself to the latest version ">self-update</a>
+      <a class="cmd-link" href="#cmd-self-update" data-search="self-update update boost itself to the latest version  --dry-run">self-update</a>
     </div>
     <div class="group" data-group="team">
       <div class="group-h">Team &amp; sharing</div>
@@ -1083,10 +1083,14 @@
           <div class="arg"><code>--startup</code><span>enable the startup toggle right after install</span></div>
         </div>
       </section>
-      <section class="cmd" id="cmd-self-update" data-search="self-update update boost itself to the latest version ">
+      <section class="cmd" id="cmd-self-update" data-search="self-update update boost itself to the latest version  --dry-run">
         <h3><span class="cname">self-update</span><span class="gtag">cfg</span></h3>
         <p class="summary">Update boost itself to the latest version</p>
-        <pre class="syn">boost self-update</pre>
+        <pre class="syn">boost self-update [--dry-run]</pre>
+        <div class="args-h">Options</div>
+        <div class="args">
+          <div class="arg"><code>--dry-run</code><span>show how boost would update itself, change nothing</span></div>
+        </div>
       </section>
       <h2 class="group-h" id="grp-team">Team &amp; sharing</h2>
       <section class="cmd" id="cmd-cohort" data-search="cohort controlled skill rollouts &amp; team a/b testing  --skills skills --percent percent --json {list,create,delete,status,apply} name">

boost_skill_cli-1.0.232/docs/roadmap/items/self-update-broken-for-pip-pipx-installs.md

@@ -0,0 +1,31 @@
+---
+id: self-update-broken-for-pip-pipx-installs
+board: code
+section: compat
+status: shipped
+category: Bug
+complexity: M
+impact: High
+wow: 3
+note:
+order: 10
+owner: loop/self-update
+pr: 272
+title: <code>self-update</code> is non-functional for pip/pipx installs
+---
+<code>boost self-update</code> only works when boost runs from a git checkout: <code>paths.repo_root()</code>
+resolves inside <code>site-packages</code> for a pip/pipx install, <code>gitutil.is_repo()</code> is
+False, and <code>cmd_self_update</code> raises "boost is not running from a git checkout" with a hint
+to clone the repo — telling a normal PyPI user to abandon their install method. Detect the install
+method and shell out to <code>pip install --upgrade boost-skill-cli</code> /
+<code>pipx upgrade boost-skill-cli</code>, falling back to the git-pull path only for source
+checkouts. Shipped as <code>core/selfupdate.py</code>: detection reads evidence on disk —
+<code>.git</code>, then <code>pipx_metadata.json</code> or <code>uv-receipt.toml</code> in
+<code>sys.prefix</code>, then installed package metadata — and a <code>--dry-run</code> flag
+prints the exact command without running it. Two details carry the weight: the pip branch
+invokes <code>sys.executable -m pip</code>, never a bare <code>pip</code>, because the pip
+first on PATH can belong to another interpreter and would upgrade a different copy while
+reporting success; and an install nothing has a record of reports that plainly instead of
+guessing pip. The new version is read from a freshly spawned <code>boost --version</code>,
+since the running process imported its own version before the upgrade — if that probe says
+nothing, neither does boost.

{boost_skill_cli-1.0.231 → boost_skill_cli-1.0.232}/docs/roadmap.html

@@ -2828,7 +2828,7 @@ same nav and footer as every other page.</p>
       </article>
 
       <article class="cap rcard" id="self-update-broken-for-pip-pipx-installs">
-        <div class="head"><span class="pill planned">Planned</span><span class="cat">Bug</span></div>
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Bug</span></div>
         <h3><code>self-update</code> is non-functional for pip/pipx installs</h3>
         <p><code>boost self-update</code> only works when boost runs from a git checkout: <code>paths.repo_root()</code>
 resolves inside <code>site-packages</code> for a pip/pipx install, <code>gitutil.is_repo()</code> is
@@ -2836,7 +2836,16 @@ False, and <code>cmd_self_update</code> raises "boost is not running from a git
 to clone the repo — telling a normal PyPI user to abandon their install method. Detect the install
 method and shell out to <code>pip install --upgrade boost-skill-cli</code> /
 <code>pipx upgrade boost-skill-cli</code>, falling back to the git-pull path only for source
-checkouts.</p>
+checkouts. Shipped as <code>core/selfupdate.py</code>: detection reads evidence on disk —
+<code>.git</code>, then <code>pipx_metadata.json</code> or <code>uv-receipt.toml</code> in
+<code>sys.prefix</code>, then installed package metadata — and a <code>--dry-run</code> flag
+prints the exact command without running it. Two details carry the weight: the pip branch
+invokes <code>sys.executable -m pip</code>, never a bare <code>pip</code>, because the pip
+first on PATH can belong to another interpreter and would upgrade a different copy while
+reporting success; and an install nothing has a record of reports that plainly instead of
+guessing pip. The new version is read from a freshly spawned <code>boost --version</code>,
+since the running process imported its own version before the upgrade — if that probe says
+nothing, neither does boost.</p>
         <div class="meta">
           <span class="m">Complexity <b>M</b></span>
           <span class="m hi">Impact <b>High</b></span>

{boost_skill_cli-1.0.231 → boost_skill_cli-1.0.232}/tests/functional/test_cli_configuration.py

@@ -20,6 +20,7 @@ import urllib.request
 import pytest
 
 from boost_cli.core import frontmatter, journal, paths, policy, util
+from boost_cli.errors import BoostError
 
 
 def _git(cwd, *args):
@@ -846,13 +847,108 @@ class TestMcp:
 # ---------------------------------------------------------------- self-update
 
 class TestSelfUpdate:
-    def test_non_git_checkout_fails_with_hint(self, boost, sandbox, monkeypatch):
-        # repo_root() normally resolves to the real boost checkout (a git
-        # repo, both locally and in CI); point it at the sandbox instead
+    def _not_a_checkout(self, monkeypatch, sandbox):
+        """repo_root() normally resolves to the real boost checkout (a git repo
+        both locally and in CI) — point it at the sandbox so the pip/pipx paths
+        are reachable, and make a real upgrade impossible.
+
+        The second half is not paranoia: while these tests were being written,
+        a detection bug sent one of them down the pip branch for real, and it
+        installed boost-skill-cli from PyPI over the editable checkout. A test
+        must not be one bad branch away from mutating the machine.
+        """
         monkeypatch.setattr("boost_cli.core.paths.repo_root", lambda: sandbox)
+
+        def never(cmd, **kw):
+            raise AssertionError("this test must not run an upgrade: %s" % cmd)
+        monkeypatch.setattr("boost_cli.core.selfupdate.run_upgrade", never)
+
+    def _pipx_install(self, monkeypatch, sandbox):
+        self._not_a_checkout(monkeypatch, sandbox)
+        prefix = sandbox / "pipx" / "venvs" / "boost-skill-cli"
+        prefix.mkdir(parents=True)
+        (prefix / "pipx_metadata.json").write_text("{}", encoding="utf-8")
+        monkeypatch.setattr("sys.prefix", str(prefix))
+        monkeypatch.setattr("boost_cli.core.selfupdate.shutil.which",
+                            lambda t: "/opt/bin/" + t)
+
+    def test_pipx_install_upgrades_with_pipx(self, boost, sandbox, monkeypatch):
+        # The old behaviour: rc=1, "boost is not running from a git checkout",
+        # and a hint telling a PyPI user to go clone the repo instead.
+        self._pipx_install(monkeypatch, sandbox)
+        r = boost("self-update", "--dry-run")
+        assert "installed with: pipx" in r.out
+        assert "would run: /opt/bin/pipx upgrade boost-skill-cli" in r.out
+
+    def test_plain_pip_install_upgrades_with_this_interpreter(
+            self, boost, sandbox, monkeypatch):
+        self._not_a_checkout(monkeypatch, sandbox)
+        monkeypatch.setattr("sys.prefix", str(sandbox))
+        monkeypatch.setattr("boost_cli.core.selfupdate.installed_version",
+                            lambda: "1.0.0")
+        r = boost("self-update", "--dry-run")
+        assert "installed with: pip" in r.out
+        assert ("would run: %s -m pip install --upgrade boost-skill-cli"
+                % sys.executable) in r.out
+
+    def test_pipx_upgrade_reports_the_new_version(self, boost, sandbox,
+                                                  monkeypatch):
+        self._pipx_install(monkeypatch, sandbox)
+        ran = []
+        monkeypatch.setattr("boost_cli.core.selfupdate.run_upgrade",
+                            lambda cmd, **kw: ran.append(cmd))
+        monkeypatch.setattr("boost_cli.core.selfupdate.observed_version",
+                            lambda: "9.9.9")
+        r = boost("self-update")
+        from boost_cli import __version__
+        assert ran == [["/opt/bin/pipx", "upgrade", "boost-skill-cli"]]
+        assert ("boost v%s → v9.9.9" % __version__) in r.out
+        ev = journal.events(action="self-update")[0]
+        assert ev["subject"] == "9.9.9" and ev["method"] == "pipx"
+
+    def test_upgrade_that_reveals_no_version_does_not_claim_one(
+            self, boost, sandbox, monkeypatch):
+        self._pipx_install(monkeypatch, sandbox)
+        monkeypatch.setattr("boost_cli.core.selfupdate.run_upgrade",
+                            lambda cmd, **kw: None)
+        monkeypatch.setattr("boost_cli.core.selfupdate.observed_version",
+                            lambda: None)
+        r = boost("self-update")
+        assert "upgraded via pipx; run `boost --version` to confirm" in r.out
+        assert "→" not in r.out
+
+    def test_failed_upgrade_surfaces_the_managers_message(
+            self, boost, sandbox, monkeypatch):
+        self._pipx_install(monkeypatch, sandbox)
+
+        def boom(cmd, **kw):
+            raise BoostError("upgrade failed (pipx exited 1)",
+                             hint="ERROR: No matching distribution")
+        monkeypatch.setattr("boost_cli.core.selfupdate.run_upgrade", boom)
+        r = boost("self-update", expect=1)
+        assert "upgrade failed (pipx exited 1)" in r.err
+        assert "No matching distribution" in r.err
+
+    def test_unknown_install_says_so_instead_of_guessing_pip(
+            self, boost, sandbox, monkeypatch):
+        self._not_a_checkout(monkeypatch, sandbox)
+        monkeypatch.setattr("sys.prefix", str(sandbox))
+        monkeypatch.setattr("boost_cli.core.selfupdate.installed_version",
+                            lambda: None)
         r = boost("self-update", expect=1)
-        assert "boost is not running from a git checkout" in r.err
-        assert "git clone the boost repo" in r.err
+        assert "cannot work out how boost was installed" in r.err
+        assert "pipx upgrade boost-skill-cli" in r.err
+
+    def test_git_checkout_dry_run_changes_nothing(self, boost, sandbox,
+                                                  monkeypatch):
+        monkeypatch.setattr("boost_cli.core.gitutil.is_repo", lambda p: True)
+
+        def no_git(*a, **kw):
+            raise AssertionError("--dry-run must not run git")
+        monkeypatch.setattr("boost_cli.core.gitutil.run", no_git)
+        r = boost("self-update", "--dry-run")
+        assert "installed with: git checkout" in r.out
+        assert "pull --ff-only" in r.out
 
     def _fake_git(self, monkeypatch, *, before, after, described):
         """Stub gitutil so self-update sees a controlled HEAD move + describe.