dotbrain 0.4.2__tar.gz → 0.4.4__tar.gz

{dotbrain-0.4.2 → dotbrain-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: dotbrain
-Version: 0.4.2
+Version: 0.4.4
 Summary: Wires project Brainspaces and skills into coding agents.
 Project-URL: Homepage, https://github.com/arminzou/dotbrain
 Project-URL: Repository, https://github.com/arminzou/dotbrain

{dotbrain-0.4.2 → dotbrain-0.4.4}/docs/cli-reference.md

@@ -22,7 +22,8 @@ Reference for the public `dotbrain` CLI.
 │            links.                                                            │
 │ doctor     Read-only health check: machine readiness, project wiring, beads  │
 │            state drift.                                                      │
-│ update     Update this released CLI to the latest stable PyPI release.       │
+│ update     Print the command that upgrades this CLI with the tool that       │
+│            installed it.                                                     │
 │ wire       Create or repair a project Brainspace and wire an adopter repo.   │
 │ refresh    Refresh Brain/workspace files, repo links, beads state, and       │
 │            project skills.                                                   │
@@ -348,7 +349,7 @@ Reference for the public `dotbrain` CLI.
 
  Usage: dotbrain update [OPTIONS]
 
- Update this released CLI to the latest stable PyPI release.
+ Print the command that upgrades this CLI with the tool that installed it.
 
 ┌─ Options ────────────────────────────────────────────────────────────────────┐
 │ --help  -h        Show this message and exit.                                │

{dotbrain-0.4.2 → dotbrain-0.4.4}/docs/getting-started.md

@@ -179,16 +179,20 @@ codex plugin add dotbrain@dotbrain
 Then refresh the CLI to match, either by asking your agent or by re-running the install command
 from step 2 with the new tag.
 
-To update only the released CLI, run:
+To update only the released CLI, upgrade it with the tool that installed it:
 
 ```bash
-dotbrain update
+uv tool install dotbrain@latest              # uv
+pipx upgrade dotbrain                        # pipx
+python -m pip install --upgrade dotbrain     # pip, using the Python dotbrain is installed in
 ```
 
-It installs the latest stable release from PyPI and does not update plugins or private dotbrain
-data. On Windows, wait a moment for the running launcher to exit, then confirm with
-`dotbrain --version`. `uv tool upgrade dotbrain` (or `pipx upgrade dotbrain`) works too.
-Contributor checkouts remain editable: update the checkout with Git instead of using this command.
+With uv, use `dotbrain@latest` rather than `uv tool upgrade dotbrain`: an install pinned to one
+version, such as the plugin installer's, stays on that version under `uv tool upgrade`. Not sure
+which tool you used? `dotbrain update` prints the right command for your install.
+
+Updating the CLI does not update plugins or private dotbrain data. Contributor checkouts remain
+editable: update the checkout with Git instead.
 
 ## Edit Config Only When Needed
 

{dotbrain-0.4.2 → dotbrain-0.4.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dotbrain"
-version = "0.4.2"
+version = "0.4.4"
 description = "Wires project Brainspaces and skills into coding agents."
 requires-python = ">=3.11"
 license = "MIT"

{dotbrain-0.4.2 → dotbrain-0.4.4}/src/dotbrain/__init__.py

@@ -4,4 +4,4 @@ A testable Python CLI for wiring repos into Brainspaces, seeding Brains, and
 managing skills. Exposes the workflow commands plus pure path/contract helpers.
 """
 
-__version__ = "0.4.2"
+__version__ = "0.4.4"

{dotbrain-0.4.2 → dotbrain-0.4.4}/src/dotbrain/cli.py

@@ -2,13 +2,16 @@
 
 from __future__ import annotations
 
+import json
+import subprocess
 import sys
+from importlib import metadata
 from pathlib import Path
 from typing import Optional
 
 import typer
 
-from dotbrain import __version__, updater
+from dotbrain import __version__
 from dotbrain import doctor as doctor_mod
 from dotbrain import adopter_repos, beads as beads_mod, bootstrap as bootstrap_mod, config, brainspaces, hooks, migrate, paths, resource_loader, skills, subagents, workflows
 
@@ -167,18 +170,27 @@ def doctor() -> None:
 
 @app.command()
 def update() -> None:
-    """Update this released CLI to the latest stable PyPI release."""
+    """Print the command that upgrades this CLI with the tool that installed it."""
+    typer.echo(_upgrade_hint())
+
+
+def _upgrade_hint() -> str:
     try:
-        target = updater.update_cli(__version__)
-    except updater.UpdateError as exc:
-        typer.echo(f"dotbrain update: {exc}", err=True)
-        raise typer.Exit(1) from exc
-    if target is None:
-        typer.echo(f"dotbrain {__version__} is already current")
-    elif sys.platform == "win32":
-        typer.echo(f"dotbrain update to {target} is starting; run 'dotbrain --version' in a moment to verify")
-    else:
-        typer.echo(f"dotbrain updated from {__version__} to {target}; run 'dotbrain --version' to verify")
+        files = metadata.distribution("dotbrain").files or ()
+        record = next((f for f in files if f.name == "direct_url.json"), None)
+        direct_url = json.loads(record.read_text(encoding="utf-8")) if record else {}
+    except (metadata.PackageNotFoundError, OSError, ValueError):
+        direct_url = {}
+    if direct_url.get("dir_info", {}).get("editable"):
+        return "dotbrain is an editable install; update its checkout with git pull"
+    prefix = Path(sys.prefix)
+    if (prefix / "uv-receipt.toml").exists():
+        # @latest also clears the exact-version pin that `uv tool upgrade` would honor.
+        return "To update dotbrain, run: uv tool install dotbrain@latest"
+    if (prefix / "pipx_metadata.json").exists():
+        return "To update dotbrain, run: pipx upgrade dotbrain"
+    pip = subprocess.list2cmdline([sys.executable, "-m", "pip", "install", "--upgrade", "dotbrain"])
+    return f"To update dotbrain, run: {pip}"
 
 
 @app.command()

dotbrain-0.4.2/src/dotbrain/updater.py

@@ -1,117 +0,0 @@
-"""Update released dotbrain CLI installations from PyPI."""
-
-from __future__ import annotations
-
-import json
-import os
-import re
-import subprocess
-from importlib import metadata
-from typing import Any, Callable
-from urllib.error import URLError
-from urllib.request import Request, urlopen
-
-PACKAGE = "dotbrain"
-_PYPI_URL = f"https://pypi.org/pypi/{PACKAGE}/json"
-_VERSION_RE = re.compile(r"^(\d+)\.(\d+)\.(\d+)$")
-Fetch = Callable[[str], dict[str, Any]]
-Run = Callable[..., subprocess.CompletedProcess[str]]
-
-
-class UpdateError(RuntimeError):
-    """The CLI could not safely update itself."""
-
-
-def update_cli(current_version: str, *, fetch: Fetch | None = None,
-               run: Run = subprocess.run) -> str | None:
-    """Install the latest stable release, returning its version or ``None`` when current."""
-    if _is_editable_install():
-        raise UpdateError("editable installs are updated from their checkout; use git pull there")
-
-    fetch = fetch or _fetch_json
-    target_version = _latest_version(fetch(_PYPI_URL))
-    if _version_parts(target_version) <= _version_parts(current_version):
-        return None
-
-    command = ["uv", "tool", "install", "--force", f"{PACKAGE}=={target_version}"]
-    if _is_windows():
-        _defer_install(command)
-        return target_version
-    try:
-        result = run(command, check=False)
-    except FileNotFoundError as exc:
-        raise UpdateError("uv is not on PATH; install uv and retry") from exc
-    if result.returncode:
-        raise UpdateError(f"uv could not install {target_version}; the existing CLI was left unchanged")
-    return target_version
-
-
-def _is_windows() -> bool:
-    return os.name == "nt"
-
-
-def _defer_install(command: list[str]) -> None:
-    """Run detached, after this Windows launcher releases its executable lock.
-
-    The child must not share this process's console: otherwise its output and
-    lifetime bleed into the caller's shell, and the prompt looks hung until the
-    install finishes. It gets a hidden console rather than none: a console-less
-    cmd makes Windows open a visible window for each console child it runs.
-    """
-    script = f"ping -n 2 127.0.0.1 >NUL & {subprocess.list2cmdline(command)}"
-    subprocess.Popen(
-        ["cmd", "/c", script],
-        stdin=subprocess.DEVNULL,
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL,
-        creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0)
-        | getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0),
-    )
-
-
-def _is_editable_install() -> bool:
-    try:
-        distribution = metadata.distribution("dotbrain")
-    except metadata.PackageNotFoundError:
-        return False
-    raw = next(
-        (
-            distribution.locate_file(path).read_text(encoding="utf-8")
-            for path in distribution.files or ()
-            if path.name == "direct_url.json"
-        ),
-        None,
-    )
-    if not raw:
-        return False
-    try:
-        return bool(json.loads(raw).get("dir_info", {}).get("editable"))
-    except (ValueError, AttributeError):
-        return False
-
-
-def _fetch_json(url: str) -> dict[str, Any]:
-    request = Request(url, headers={"Accept": "application/json", "User-Agent": "dotbrain"})
-    try:
-        with urlopen(request, timeout=10) as response:  # noqa: S310 - fixed PyPI URL
-            data = json.load(response)
-    except (OSError, URLError, ValueError) as exc:
-        raise UpdateError("could not reach PyPI to check for updates") from exc
-    if not isinstance(data, dict):
-        raise UpdateError("PyPI returned an invalid update response")
-    return data
-
-
-def _latest_version(release: dict[str, Any]) -> str:
-    info = release.get("info", {}) if isinstance(release.get("info"), dict) else {}
-    version = str(info.get("version", ""))
-    if not _VERSION_RE.fullmatch(version):
-        raise UpdateError("PyPI did not return a stable dotbrain release")
-    return version
-
-
-def _version_parts(version: str) -> tuple[int, int, int]:
-    match = _VERSION_RE.fullmatch(version)
-    if not match:
-        raise UpdateError(f"unsupported installed version: {version}")
-    return tuple(int(part) for part in match.groups())