beakr-cli 0.3.0__tar.gz → 0.3.2__tar.gz

{beakr_cli-0.3.0 → beakr_cli-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: beakr-cli
-Version: 0.3.0
+Version: 0.3.2
 Summary: CLI and MCP server for Beakr's knowledge base
 Project-URL: Homepage, https://thebeakr.com
 Project-URL: Repository, https://github.com/BeakrHub/beakr-cli

{beakr_cli-0.3.0 → beakr_cli-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "beakr-cli"
-version = "0.3.0"
+version = "0.3.2"
 description = "CLI and MCP server for Beakr's knowledge base"
 readme = "README.md"
 license = "MIT"

{beakr_cli-0.3.0 → beakr_cli-0.3.2}/src/beakr_cli/__init__.py

@@ -1,3 +1,3 @@
 """Beakr CLI -- command-line and MCP server for Beakr's knowledge base."""
 
-__version__ = "0.3.0"
+__version__ = "0.3.2"

{beakr_cli-0.3.0 → beakr_cli-0.3.2}/src/beakr_cli/main.py

@@ -62,7 +62,7 @@ def version(
         return
     status = get_update_status(max_age=timedelta(hours=1))
     if status.latest is None:
-        print("Latest release: unknown (could not reach PyPI)")
+        print("Latest release: unknown (PyPI could not be checked)")
     elif status.update_available:
         print(f"Update available: {status.latest}. {detect_install().instructions}")
     else:
@@ -114,7 +114,7 @@ def update(
         raise typer.Exit(1)
 
     console.print(f"[dim]$ {' '.join(info.upgrade_command)}[/dim]")
-    result = run_upgrade(info)
+    result = run_upgrade(info, expected_version=status.latest)
     if result.output:
         console.print(f"[dim]{result.output}[/dim]", highlight=False)
     if not result.ok:

{beakr_cli-0.3.0 → beakr_cli-0.3.2}/src/beakr_cli/mcp_server.py

@@ -831,7 +831,7 @@ async def beakr_version() -> str:
     info = detect_install()
     lines = [f"Installed: beakr-cli {status.current} ({info.method.value})"]
     if status.latest is None:
-        lines.append("Latest release: unknown (could not reach PyPI).")
+        lines.append("Latest release: unknown (PyPI could not be checked).")
     elif status.update_available:
         lines.append(f"Update available: {status.latest}.")
         if info.upgrade_command is not None:
@@ -865,7 +865,7 @@ async def update_beakr() -> str:
             f"No update needed: installed {status.current}, latest release {status.latest}."
         )
     info = detect_install()
-    result = await asyncio.to_thread(run_upgrade, info)
+    result = await asyncio.to_thread(run_upgrade, info, expected_version=status.latest)
     if not result.ok:
         tail = f"\n\n{result.output[-2000:]}" if result.output else ""
         return f"Update did not run: {result.message}{tail}"

{beakr_cli-0.3.0 → beakr_cli-0.3.2}/src/beakr_cli/updates.py

@@ -15,6 +15,7 @@ from __future__ import annotations
 
 import json
 import os
+import re
 import shutil
 import subprocess
 import sys
@@ -104,20 +105,35 @@ def get_update_status(
     allow_network: bool = True,
     timeout: float = 2.0,
 ) -> UpdateStatus:
-    """Current vs latest version, from cache when fresh enough, else from PyPI."""
+    """Current vs latest version, from cache when fresh enough, else from PyPI.
+
+    A "latest" older than the running version is never reported or cached. PyPI's
+    CDN serves the project JSON with ``max-age=900``, so for up to 15 minutes after
+    a release it can still list the previous one; caching that answer used to make
+    a freshly upgraded CLI report the version it had just replaced as the latest.
+    """
     cached_latest, checked_at = _read_cache()
+    if cached_latest is not None and _older_than_running(cached_latest):
+        cached_latest, checked_at = None, None
     now = datetime.now(timezone.utc)
     fresh = checked_at is not None and now - checked_at <= max_age
     if fresh or not allow_network or check_disabled():
         return UpdateStatus(__version__, cached_latest, checked_at)
     latest = fetch_latest_version(timeout)
-    if latest is None:
-        # Offline or PyPI unavailable: fall back to what we last knew.
+    if latest is None or _older_than_running(latest):
+        # Offline, PyPI unavailable, or a stale CDN listing: keep what we last knew.
         return UpdateStatus(__version__, cached_latest, checked_at)
     _write_cache(latest, now)
     return UpdateStatus(__version__, latest, now)
 
 
+def _older_than_running(version: str) -> bool:
+    try:
+        return Version(version) < Version(__version__)
+    except InvalidVersion:
+        return True
+
+
 # ---------------------------------------------------------------------------
 # Install method detection
 # ---------------------------------------------------------------------------
@@ -126,6 +142,7 @@ def get_update_status(
 class InstallMethod(str, Enum):
     uv_tool = "uv tool"
     uv_tool_source = "uv tool (local source)"
+    uv_tool_pinned = "uv tool (pinned version)"
     pipx = "pipx"
     uvx = "uvx"
     other = "other"
@@ -148,17 +165,40 @@ def _uv_tool_dir() -> Path:
     return base / "uv" / "tools"
 
 
-def _receipt_is_local_source(receipt: Path) -> bool:
-    """True when the uv tool was installed from a directory, path, or git checkout.
+#: The ``{ name = "beakr-cli", ... }`` inline table in a uv tool receipt's
+#: ``requirements``. Parsed from the requirement entry alone: the receipt also
+#: carries ``entrypoints`` with ``install-path = ...``, and matching keys against
+#: the whole file made every uv tool install look like a local checkout.
+_RECEIPT_REQUIREMENT = re.compile(r'\{\s*name\s*=\s*"' + re.escape(PACKAGE_NAME) + r'"([^}]*)\}')
+_SOURCE_KEYS = re.compile(r"(?<![\w-])(directory|path|git|url|editable)\s*=")
+_PINNED_SPECIFIER = re.compile(r'(?<![\w-])specifier\s*=\s*"\s*==')
+
+
+def _receipt_requirement(receipt: Path) -> str | None:
+    """The body of this package's requirement entry in a uv receipt, if readable."""
+    try:
+        match = _RECEIPT_REQUIREMENT.search(receipt.read_text())
+    except OSError:
+        return None
+    return match.group(1) if match else None
+
+
+def _receipt_is_local_source(requirement: str) -> bool:
+    """True when the uv tool was installed from a directory, path, URL, or git.
 
     Upgrading such an install from PyPI would silently swap a developer's local
     build for the release, so it is reported rather than done.
     """
-    try:
-        text = receipt.read_text()
-    except OSError:
-        return False
-    return any(marker in text for marker in ("directory =", "path =", "git ="))
+    return _SOURCE_KEYS.search(requirement) is not None
+
+
+def _receipt_pins_version(requirement: str) -> bool:
+    """True when the uv tool was installed as ``beakr-cli==X``.
+
+    ``uv tool upgrade`` honours the pin and does nothing, so offering it would
+    report an upgrade that never happens.
+    """
+    return _PINNED_SPECIFIER.search(requirement) is not None
 
 
 def detect_install(prefix: Path | None = None) -> InstallInfo:
@@ -171,8 +211,8 @@ def detect_install(prefix: Path | None = None) -> InstallInfo:
     except OSError:
         in_uv_tools = False
     if in_uv_tools or ("uv" in parts and "tools" in parts):
-        receipt = env / "uv-receipt.toml"
-        if _receipt_is_local_source(receipt):
+        requirement = _receipt_requirement(env / "uv-receipt.toml") or ""
+        if _receipt_is_local_source(requirement):
             return InstallInfo(
                 InstallMethod.uv_tool_source,
                 None,
@@ -180,16 +220,28 @@ def detect_install(prefix: Path | None = None) -> InstallInfo:
                 "`uv tool install --force <checkout>`, or switch to the published "
                 f"release with `uv tool install --force {PACKAGE_NAME}`.",
             )
+        if _receipt_pins_version(requirement):
+            return InstallInfo(
+                InstallMethod.uv_tool_pinned,
+                None,
+                "Installed with uv pinned to one version, which `uv tool upgrade` keeps. "
+                f"Unpin it with `uv tool install --force {PACKAGE_NAME}`.",
+            )
+        # --reinstall-package implies --refresh-package (which `uv tool upgrade` does not
+        # accept directly). uv caches the package index, and without a refresh an
+        # upgrade run shortly after a release resolves the old version and exits 0.
         return InstallInfo(
             InstallMethod.uv_tool,
-            ["uv", "tool", "upgrade", PACKAGE_NAME],
+            ["uv", "tool", "upgrade", "--reinstall-package", PACKAGE_NAME, PACKAGE_NAME],
             f"Run `beakr update` (or `uv tool upgrade {PACKAGE_NAME}`).",
         )
 
-    if "pipx" in parts and "venvs" in parts:
+    pipx_home = os.environ.get("PIPX_HOME")
+    in_custom_pipx = bool(pipx_home) and env.parent == (Path(pipx_home) / "venvs").resolve()
+    if in_custom_pipx or ("pipx" in parts and "venvs" in parts):
         return InstallInfo(
             InstallMethod.pipx,
-            ["pipx", "upgrade", PACKAGE_NAME],
+            ["pipx", "upgrade", "--pip-args=--no-cache-dir", PACKAGE_NAME],
             f"Run `beakr update` (or `pipx upgrade {PACKAGE_NAME}`).",
         )
 
@@ -227,11 +279,16 @@ def _beakr_executable() -> str | None:
     return shutil.which("beakr")
 
 
-def run_upgrade(info: InstallInfo, *, timeout: float = 300.0) -> UpgradeResult:
-    """Upgrade the package, then refresh the skills it installed.
+def run_upgrade(
+    info: InstallInfo, *, expected_version: str | None = None, timeout: float = 300.0
+) -> UpgradeResult:
+    """Upgrade the package, confirm it moved, then refresh the skills it installed.
 
     The skill refresh runs through the NEW binary on PATH, not this process: the
     running interpreter still has the old code and the old bundled assets loaded.
+    A package manager exiting 0 is not proof of an upgrade (a cached index or a
+    pin both "succeed" without changing anything), so the binary's own version is
+    checked against ``expected_version`` before anything is reported as upgraded.
     """
     if info.upgrade_command is None:
         return UpgradeResult(False, info.instructions, "")
@@ -255,6 +312,17 @@ def run_upgrade(info: InstallInfo, *, timeout: float = 300.0) -> UpgradeResult:
             False, f"`{' '.join(info.upgrade_command)}` failed (exit {upgrade.returncode}).", output
         )
 
+    if expected_version is not None:
+        now = installed_version_on_path()
+        if now is None or _version_lt(now, expected_version):
+            return UpgradeResult(
+                False,
+                f"The upgrade ran but `beakr` on PATH is still {now or 'unknown'}, not "
+                f"{expected_version}. A new release can take a few minutes to reach PyPI's "
+                "mirrors; try again shortly.",
+                output,
+            )
+
     beakr = _beakr_executable()
     if beakr is None:
         return UpgradeResult(
@@ -294,7 +362,11 @@ def installed_version_on_path() -> str | None:
         return None
     try:
         result = subprocess.run(
-            [beakr, "version"], capture_output=True, text=True, timeout=30, check=False
+            [beakr, "version", "--offline"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+            check=False,
         )
     except subprocess.TimeoutExpired:
         return None
@@ -303,3 +375,10 @@ def installed_version_on_path() -> str | None:
         return None
     # First line is "beakr-cli X.Y.Z"; later lines may describe update status.
     return text[0].removeprefix(f"{PACKAGE_NAME} ").strip() or None
+
+
+def _version_lt(left: str, right: str) -> bool:
+    try:
+        return Version(left) < Version(right)
+    except InvalidVersion:
+        return True

{beakr_cli-0.3.0 → beakr_cli-0.3.2}/tests/test_updates.py

@@ -102,6 +102,33 @@ def test_disabled_check_never_touches_network(monkeypatch) -> None:
     assert route.call_count == 0
 
 
+@respx.mock
+def test_cached_latest_older_than_running_version_is_refetched() -> None:
+    """Right after upgrading, a cache written by the old version must not be shown."""
+    route = respx.get(updates.PYPI_JSON_URL).mock(
+        return_value=httpx.Response(200, json=_pypi("0.2.1", "0.3.0"))
+    )
+    _write_cache("0.2.1", age=timedelta(minutes=5))
+    status = updates.get_update_status()
+    assert status.latest == "0.3.0"
+    assert route.call_count == 1
+
+
+@respx.mock
+def test_stale_cdn_listing_older_than_running_version_is_not_cached() -> None:
+    """PyPI's CDN can list the previous release for ~15 minutes after publishing.
+
+    That answer was cached for a day and shown as "latest release: 0.2.1" on 0.3.0.
+    """
+    respx.get(updates.PYPI_JSON_URL).mock(
+        return_value=httpx.Response(200, json=_pypi("0.2.0", "0.2.1"))
+    )
+    status = updates.get_update_status()
+    assert status.latest is None
+    assert not status.update_available
+    assert not (config.CONFIG_DIR / "update_check.json").exists()
+
+
 def test_running_ahead_of_pypi_is_not_an_update() -> None:
     assert not updates.UpdateStatus("0.3.0", "0.2.1", None).update_available
 
@@ -110,28 +137,58 @@ def test_running_ahead_of_pypi_is_not_an_update() -> None:
 # Install detection
 # ---------------------------------------------------------------------------
 
+#: Receipts exactly as uv 0.11 writes them. The entrypoints block matters: its
+#: ``install-path = ...`` made every PyPI install look like a local checkout when
+#: detection searched the whole file for ``path =``, so `beakr update` refused to
+#: upgrade any uv tool install in 0.3.0 and 0.3.1.
+_ENTRYPOINTS = """entrypoints = [
+    { name = "beakr", install-path = "/Users/u/.local/bin/beakr", from = "beakr-cli" },
+]
+"""
+PYPI_RECEIPT = '[tool]\nrequirements = [{ name = "beakr-cli" }]\n' + _ENTRYPOINTS
+PINNED_RECEIPT = (
+    '[tool]\nrequirements = [{ name = "beakr-cli", specifier = "==0.3.0" }]\n' + _ENTRYPOINTS
+)
+RANGE_RECEIPT = (
+    '[tool]\nrequirements = [{ name = "beakr-cli", specifier = ">=0.3" }]\n' + _ENTRYPOINTS
+)
+SOURCE_RECEIPT = (
+    '[tool]\nrequirements = [{ name = "beakr-cli", directory = "/src/beakr-cli" }]\n'
+    'constraints = [{ name = "mcp", specifier = "<2" }]\n' + _ENTRYPOINTS
+)
+
 
-def test_detects_pypi_uv_tool_install(tmp_path, monkeypatch) -> None:
+def _uv_tool_env(tmp_path, monkeypatch, receipt: str) -> Path:
     tools = tmp_path / "uv" / "tools"
     env = tools / "beakr-cli"
     env.mkdir(parents=True)
-    (env / "uv-receipt.toml").write_text('[tool]\nrequirements = [{ name = "beakr-cli" }]\n')
+    (env / "uv-receipt.toml").write_text(receipt)
     monkeypatch.setenv("UV_TOOL_DIR", str(tools))
-    info = updates.detect_install(env)
+    return env
+
+
+@pytest.mark.parametrize("receipt", [PYPI_RECEIPT, RANGE_RECEIPT])
+def test_detects_pypi_uv_tool_install(receipt, tmp_path, monkeypatch) -> None:
+    info = updates.detect_install(_uv_tool_env(tmp_path, monkeypatch, receipt))
     assert info.method is updates.InstallMethod.uv_tool
-    assert info.upgrade_command == ["uv", "tool", "upgrade", "beakr-cli"]
+    # --reinstall-package implies a refresh of the cached index; without one an
+    # upgrade shortly after a release resolved the old version and still exited 0.
+    assert info.upgrade_command == [
+        "uv", "tool", "upgrade", "--reinstall-package", "beakr-cli", "beakr-cli",
+    ]
+
+
+def test_version_pinned_uv_tool_is_reported_not_upgraded(tmp_path, monkeypatch) -> None:
+    """`uv tool upgrade` keeps a `==X` pin, so running it would upgrade nothing."""
+    info = updates.detect_install(_uv_tool_env(tmp_path, monkeypatch, PINNED_RECEIPT))
+    assert info.method is updates.InstallMethod.uv_tool_pinned
+    assert info.upgrade_command is None
+    assert "uv tool install --force beakr-cli" in info.instructions
 
 
 def test_local_checkout_uv_tool_is_never_upgraded_from_pypi(tmp_path, monkeypatch) -> None:
     """A developer's local build must not be silently replaced by the release."""
-    tools = tmp_path / "uv" / "tools"
-    env = tools / "beakr-cli"
-    env.mkdir(parents=True)
-    (env / "uv-receipt.toml").write_text(
-        '[tool]\nrequirements = [{ name = "beakr-cli", directory = "/src/beakr-cli" }]\n'
-    )
-    monkeypatch.setenv("UV_TOOL_DIR", str(tools))
-    info = updates.detect_install(env)
+    info = updates.detect_install(_uv_tool_env(tmp_path, monkeypatch, SOURCE_RECEIPT))
     assert info.method is updates.InstallMethod.uv_tool_source
     assert info.upgrade_command is None
 
@@ -151,6 +208,16 @@ def test_detects_other_install_methods(prefix, method, can_upgrade, monkeypatch,
     assert (info.upgrade_command is not None) is can_upgrade
 
 
+def test_detects_pipx_with_a_custom_pipx_home(tmp_path, monkeypatch) -> None:
+    monkeypatch.setenv("UV_TOOL_DIR", str(tmp_path / "no-tools-here"))
+    monkeypatch.setenv("PIPX_HOME", str(tmp_path / "custom-home"))
+    env = tmp_path / "custom-home" / "venvs" / "beakr-cli"
+    env.mkdir(parents=True)
+    info = updates.detect_install(env)
+    assert info.method is updates.InstallMethod.pipx
+    assert info.upgrade_command == ["pipx", "upgrade", "--pip-args=--no-cache-dir", "beakr-cli"]
+
+
 def test_upgrade_without_a_safe_command_only_returns_instructions() -> None:
     info = updates.InstallInfo(updates.InstallMethod.uvx, None, "use uvx --refresh")
     result = updates.run_upgrade(info)
@@ -179,6 +246,29 @@ def test_upgrade_refreshes_skills_through_the_new_binary(monkeypatch) -> None:
     assert calls == [["uv", "tool", "upgrade", "x"], ["/bin/beakr", "install", "--refresh"]]
 
 
+def test_upgrade_that_did_not_move_the_version_is_a_failure(monkeypatch) -> None:
+    """A package manager exiting 0 is not an upgrade; skills must not be refreshed."""
+    calls: list[list[str]] = []
+
+    class Done:
+        returncode = 0
+        stdout = ""
+        stderr = ""
+
+    def fake_run(cmd, **_kwargs):
+        calls.append(cmd)
+        return Done()
+
+    monkeypatch.setattr(updates.shutil, "which", lambda name: f"/bin/{name}")
+    monkeypatch.setattr(updates.subprocess, "run", fake_run)
+    monkeypatch.setattr(updates, "installed_version_on_path", lambda: "0.3.0")
+    info = updates.InstallInfo(updates.InstallMethod.uv_tool, ["uv", "tool", "upgrade", "x"], "")
+    result = updates.run_upgrade(info, expected_version="0.3.1")
+    assert not result.ok
+    assert "still 0.3.0" in result.message
+    assert calls == [["uv", "tool", "upgrade", "x"]]
+
+
 # ---------------------------------------------------------------------------
 # Skill refresh
 # ---------------------------------------------------------------------------

{beakr_cli-0.3.0 → beakr_cli-0.3.2}/uv.lock

@@ -63,7 +63,7 @@ wheels = [
 
 [[package]]
 name = "beakr-cli"
-version = "0.3.0"
+version = "0.3.2"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },