code-aide 1.6.0__tar.gz → 1.7.1__tar.gz

{code_aide-1.6.0 → code_aide-1.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-aide
-Version: 1.6.0
+Version: 1.7.1
 Summary: Manage AI coding CLI tools (Claude, Copilot, Cursor, Gemini, Amp, Codex)
 Project-URL: Homepage, https://github.com/dajobe/code-aide
 Project-URL: Repository, https://github.com/dajobe/code-aide
@@ -157,7 +157,8 @@ uv run pytest tests/test_install.py::TestDetectOsArch -v
    - Example: `Fixed timeout handling in status command`
 5. Tag and push:
    - `git tag vX.Y.Z`
-   - `git push origin main --follow-tags`
+   - `git push origin main`
+   - `git push origin vX.Y.Z`
 6. Confirm GitHub Actions:
    - CI should pass.
    - Publish workflow should upload to PyPI and create GitHub Release notes.

{code_aide-1.6.0 → code_aide-1.7.1}/README.md

@@ -131,7 +131,8 @@ uv run pytest tests/test_install.py::TestDetectOsArch -v
    - Example: `Fixed timeout handling in status command`
 5. Tag and push:
    - `git tag vX.Y.Z`
-   - `git push origin main --follow-tags`
+   - `git push origin main`
+   - `git push origin vX.Y.Z`
 6. Confirm GitHub Actions:
    - CI should pass.
    - Publish workflow should upload to PyPI and create GitHub Release notes.

{code_aide-1.6.0 → code_aide-1.7.1}/TODO.md

@@ -7,8 +7,8 @@ remove, status, and version metadata).
 
 - [x] Standardize `--dryrun` flag: `update-versions` uses `--dry-run` but
   `install` uses `--dryrun`. Change `update-versions` to `--dryrun`.
-- [x] Add missing `success()` message for direct-download installs in non-dryrun
-  mode (`install.py`, `install_tool()`).
+- [x] Add missing `success()` message for direct-download installs in
+  non-dryrun mode (`install.py`, `install_tool()`).
 - [x] Replace PID-based temp directory naming with `tempfile.mkdtemp()` in
   `install.py` `install_direct_download()`.
 - [x] Guard `package.split("/", 1)` in `detection.py`
@@ -18,21 +18,21 @@ remove, status, and version metadata).
 
 - [ ] Handle missing `node` cleanly during prerequisite checks
   (`FileNotFoundError` path in Node version probing).
-- [ ] Read tool version output from both stdout and stderr so status does not
-  miss installed versions.
+- [ ] Read tool version output from both stdout and stderr so status does
+  not miss installed versions.
 - [ ] Make version cache writes atomic (write temp file + rename) to avoid
-  partial/corrupted `versions.json`. Apply to `save_bundled_versions()` too.
-- [ ] Warn when `versions.json` cache contains invalid JSON instead of silently
-  returning empty data.
+  partial/corrupted `versions.json`.
+- [ ] Warn when `versions.json` cache contains invalid JSON instead of
+  silently returning empty data.
 - [ ] Use `os.pathsep` instead of hardcoded `":"` in `prereqs.py`
   `check_path_directories()`.
 
 ## Security and Integrity
 
-- [ ] Add integrity verification for direct-download tarballs (not only install
-  script SHA256).
-- [ ] Extend tool metadata to support tarball checksum/signature fields where
-  applicable.
+- [ ] Add integrity verification for direct-download tarballs (not only
+  install script SHA256).
+- [ ] Extend tool metadata to support tarball checksum/signature fields
+  where applicable.
 
 ## CLI and Automation UX
 
@@ -40,21 +40,23 @@ remove, status, and version metadata).
 - [ ] Add a focused `doctor` command for environment checks (PATH,
   prerequisites, command health).
 - [ ] Consider `install --force` for reinstall/repair flows.
-- [ ] Add cleanup support for stale direct-download versions no longer in use.
-- [ ] Expand `upgrade` help text to mention the default "only out-of-date tools"
-  behavior.
+- [ ] Add cleanup support for stale direct-download versions no longer in
+  use.
+- [ ] Expand `upgrade` help text to mention the default "only out-of-date
+  tools" behavior.
 
 ## Documentation
 
-- [ ] Document that running `code-aide` with no subcommand defaults to `status`.
+- [ ] Document that running `code-aide` with no subcommand defaults to
+  `status`.
 - [ ] Add `install --dryrun` to the README usage examples.
 - [ ] Document environment variables and config file paths
   (`~/.config/code-aide/versions.json`).
 
 ## Platform and Package Detection
 
-- [ ] Broaden system package metadata detection beyond Gentoo-specific tooling
-  where practical.
+- [ ] Broaden system package metadata detection beyond Gentoo-specific
+  tooling where practical.
 
 ## Maintainability and Tests
 
@@ -65,6 +67,5 @@ remove, status, and version metadata).
   - `cmd_remove()` (completely untested)
   - `fetch_url()` (completely untested)
   - `check_prerequisites()` / `install_nodejs_npm()` (completely untested)
-  - `save_bundled_versions()` (untested)
   - `get_system_package_info()` (completely untested)
 - [ ] Add tests for prerequisite edge cases and cache write behavior.

code_aide-1.7.1/specs/auto-migrate-deprecated-installs.md

@@ -0,0 +1,128 @@
+# Auto-migrate deprecated install methods
+
+## Context
+
+Claude Code switched from npm to a native installer. Users who installed
+Claude via npm are stuck: `code-aide upgrade` runs `npm install -g @latest`
+(the detected method) instead of the native script installer (the configured
+method). `code-aide install` exits early because the command already exists.
+There is no migration path. code-aide should detect this and fix it
+automatically.
+
+This is a general pattern -- any tool could change install methods in the
+future. The solution should not be Claude-specific.
+
+## Approach
+
+A detected install method is "deprecated" when:
+
+- Detected method is `npm` or `brew_npm` AND config `install_type` is
+  `script` or `direct_download`
+
+Methods that are never considered deprecated (user-managed choices):
+
+- `brew_formula`, `brew_cask` -- user explicitly chose Homebrew
+- `system` -- managed by system package manager
+
+Migration flow: remove old (npm), install new (configured method), with
+clear messaging. If the new install fails after removal, provide recovery
+instructions.
+
+## Changes
+
+### 1. `src/code_aide/data/tools.json` -- add deprecated_npm_package
+
+Add a `deprecated_npm_package` field to Claude's entry:
+
+```json
+"claude": {
+  "name": "Claude CLI (Claude Code)",
+  "install_type": "script",
+  "deprecated_npm_package": "@anthropic-ai/claude-code",
+  ...
+}
+```
+
+This records the old npm package name explicitly so the migration removal
+step does not rely solely on extracting the package name from the binary
+path.
+
+### 2. `src/code_aide/detection.py` -- add deprecation detection
+
+Add two functions:
+
+- `is_deprecated_install(tool_name)` -- returns True when the detected
+  install method is `npm` or `brew_npm` but the configured `install_type` is
+  something else (script, direct_download). Also returns True when
+  `deprecated_npm_package` is set and the detected method is npm. Brew
+  formula/cask and system installs are never deprecated (user-managed).
+- `format_migration_warning(tool_name)` -- returns a human-readable warning
+  string, or None if not deprecated. Uses existing `format_install_method()`
+  for labels.
+
+### 3. `src/code_aide/operations.py` -- auto-migrate in upgrade
+
+Add `_migrate_install_method()` private function that:
+
+1. Warns about the deprecated method
+2. Calls `remove_tool()` to remove the old npm install
+3. Calls `install_tool()` to install via the configured method
+4. If install fails after remove, prints recovery instructions (`code-aide
+   install <tool>` and manual curl command for script types)
+
+Modify `upgrade_tool()`: after `detect_install_method()`, check
+`is_deprecated_install()`. If True, call `_migrate_install_method()` instead
+of the normal upgrade branch.
+
+Modify `remove_tool()` npm branch: fall back to
+`tool_config.get("deprecated_npm_package")` when looking up the npm package
+name. Current code: `npm_package = detail or
+tool_config.get("npm_package")`. Change to also check
+`deprecated_npm_package`.
+
+New imports needed: `is_deprecated_install`, `format_install_method` from
+detection, `install_tool` from install.
+
+Note: after `remove_tool()` succeeds, `command_exists()` returns False so
+`install_tool()` proceeds normally with the configured `install_type`.
+
+### 4. `src/code_aide/commands_actions.py` -- include deprecated in auto-upgrade
+
+Modify `cmd_upgrade()` no-args path: after building the version-outdated
+list, also add any installed tools with deprecated install methods. Without
+this, a tool whose version is current but install method is deprecated would
+be silently skipped by `code-aide upgrade`.
+
+New import: `is_deprecated_install` from detection.
+
+### 5. `src/code_aide/commands_tools.py` -- show warnings in status/list
+
+In both `cmd_list()` and `cmd_status()`, after displaying "Installed via:",
+call `format_migration_warning()` and display the warning if present.
+
+At the end of `cmd_status()`, add a summary line counting tools that need
+migration.
+
+New imports: `format_migration_warning`, `is_deprecated_install` from
+detection.
+
+### 6. Tests
+
+- `tests/test_detection.py`: Tests for `is_deprecated_install()` covering
+  npm to script (deprecated), npm to npm (not deprecated), brew_formula
+  (never deprecated), system (never deprecated), not installed, unknown
+  tool, npm to direct_download. Tests for `format_migration_warning()`.
+- `tests/test_operations.py`: Tests for migration in `upgrade_tool()`:
+  triggers migration, normal upgrade when not deprecated, migration fails on
+  remove, migration fails on install with recovery message.
+- `tests/test_commands_tools.py`: Test that status/list show migration
+  warnings for deprecated installs.
+
+## Verification
+
+1. `pre-commit run --all-files` -- formatting passes
+2. `uv run pytest tests/ -v` -- all tests pass
+3. `uv run python -m code_aide status` -- shows migration warning for
+   npm-installed Claude (if applicable)
+4. `uv run python -m code_aide upgrade claude` -- performs migration (remove
+   npm, install via script)

{code_aide-1.6.0 → code_aide-1.7.1}/src/code_aide/__init__.py

@@ -1,3 +1,3 @@
 """code-aide - Manage AI coding CLI tools."""
 
-__version__ = "1.6.0"
+__version__ = "1.7.1"

{code_aide-1.6.0 → code_aide-1.7.1}/src/code_aide/commands_actions.py

@@ -5,9 +5,19 @@ import sys
 from typing import Any, Dict, List
 
 from code_aide.constants import TOOLS
+from code_aide.detection import (
+    detect_install_method,
+    get_brew_package_info,
+    is_deprecated_install,
+)
 from code_aide.install import install_tool
 from code_aide.console import error, info, success, warning
-from code_aide.operations import remove_tool, upgrade_tool, validate_tools
+from code_aide.operations import (
+    UpgradeResult,
+    remove_tool,
+    upgrade_tool,
+    validate_tools,
+)
 from code_aide.prereqs import (
     check_path_directories,
     check_prerequisites,
@@ -123,9 +133,20 @@ def cmd_upgrade(args: argparse.Namespace) -> None:
         for name, config in TOOLS.items():
             if not is_tool_installed(name):
                 continue
+            if is_deprecated_install(name):
+                if name not in tools_to_upgrade:
+                    tools_to_upgrade.append(name)
+                continue
             latest = config.get("latest_version")
             if not latest:
                 continue
+            install_info = detect_install_method(name)
+            if install_info["method"] in ("brew_formula", "brew_cask"):
+                pkg_info = get_brew_package_info(
+                    install_info["method"], install_info["detail"]
+                )
+                if pkg_info.get("outdated") is False:
+                    continue
             status = get_tool_status(name, config)
             if status["version"] and status_version_matches_latest(
                 status["version"], latest
@@ -140,7 +161,8 @@ def cmd_upgrade(args: argparse.Namespace) -> None:
 
     validate_tools(tools_to_upgrade)
 
-    upgraded = []
+    updated = []
+    unchanged = []
     failed = []
     skipped = []
 
@@ -152,8 +174,11 @@ def cmd_upgrade(args: argparse.Namespace) -> None:
             skipped.append(tool)
             continue
 
-        if upgrade_tool(tool):
-            upgraded.append(tool)
+        result = upgrade_tool(tool)
+        if result == UpgradeResult.CHANGED:
+            updated.append(tool)
+        elif result == UpgradeResult.UNCHANGED:
+            unchanged.append(tool)
         else:
             failed.append(tool)
 
@@ -162,8 +187,11 @@ def cmd_upgrade(args: argparse.Namespace) -> None:
     info("Upgrade Summary")
     print("=" * 42)
 
-    if upgraded:
-        success(f"Successfully upgraded: {', '.join(upgraded)}")
+    if updated:
+        success(f"Successfully updated: {', '.join(updated)}")
+
+    if unchanged:
+        info(f"No package-manager change: {', '.join(unchanged)}")
 
     if skipped:
         warning(f"Skipped (not installed): {', '.join(skipped)}")
@@ -172,9 +200,11 @@ def cmd_upgrade(args: argparse.Namespace) -> None:
         error(f"Failed to upgrade: {', '.join(failed)}")
         sys.exit(1)
 
-    if upgraded:
+    if updated:
         success("All upgrades completed successfully!")
-    elif skipped and not upgraded:
+    elif unchanged and not updated and not failed:
+        info("No tools changed version during the upgrade attempt")
+    elif skipped and not updated:
         info(
             "No tools were upgraded (all were either not installed or already up to date)"
         )

{code_aide-1.6.0 → code_aide-1.7.1}/src/code_aide/commands_tools.py

@@ -8,12 +8,18 @@ from typing import List
 from code_aide.constants import Colors, PACKAGE_MANAGERS, TOOLS
 from code_aide.detection import (
     format_install_method,
+    format_migration_warning,
+    get_brew_package_info,
     get_system_package_info,
     detect_install_method,
 )
 from code_aide.console import command_exists, info, warning
 from code_aide.prereqs import detect_package_manager, is_tool_installed
-from code_aide.status import print_system_version_status, get_tool_status
+from code_aide.status import (
+    get_tool_status,
+    print_brew_version_status,
+    print_system_version_status,
+)
 from code_aide.versions import (
     extract_version_from_string,
     status_version_matches_latest,
@@ -48,6 +54,9 @@ def cmd_list(args: argparse.Namespace) -> None:
                 "  Installed via: "
                 f"{format_install_method(install_info['method'], install_info['detail'])}"
             )
+            migration_msg = format_migration_warning(tool_name)
+            if migration_msg:
+                warning(f"  {migration_msg}")
 
         if tool_config.get("min_node_version"):
             print(f"  Requires:     Node.js v{tool_config['min_node_version']}+")
@@ -99,6 +108,7 @@ def cmd_status(args: argparse.Namespace) -> None:
     print()
 
     outdated_count = 0
+    migration_count = 0
     config_outdated: List[str] = []
 
     for tool_name, tool_config in TOOLS.items():
@@ -123,6 +133,44 @@ def cmd_status(args: argparse.Namespace) -> None:
                     print_system_version_status(
                         status["version"], latest_version, pkg_info
                     )
+                elif install_info["method"] in ("brew_formula", "brew_cask"):
+                    pkg_info = get_brew_package_info(
+                        install_info["method"], install_info["detail"]
+                    )
+                    if pkg_info.get("available_version"):
+                        print_brew_version_status(
+                            status["version"], latest_version, pkg_info
+                        )
+                        if pkg_info.get("outdated"):
+                            outdated_count += 1
+                    elif latest_version:
+                        if status_version_matches_latest(
+                            status["version"], latest_version
+                        ):
+                            version_annotation = (
+                                f"  Version:      {status['version']} "
+                                f"{Colors.GREEN}(up to date){Colors.NC}"
+                            )
+                        else:
+                            installed_ver = extract_version_from_string(
+                                status["version"]
+                            )
+                            if installed_ver and version_is_newer(
+                                installed_ver, latest_version
+                            ):
+                                version_annotation = (
+                                    f"  Version:      {status['version']} "
+                                    f"{Colors.YELLOW}(newer than configured "
+                                    f"{latest_version}){Colors.NC}"
+                                )
+                                config_outdated.append(tool_name)
+                            else:
+                                version_annotation = (
+                                    f"  Version:      {status['version']} "
+                                    f"{Colors.YELLOW}(latest: {latest_version}){Colors.NC}"
+                                )
+                                outdated_count += 1
+                        print(version_annotation)
                 elif latest_version:
                     if status_version_matches_latest(status["version"], latest_version):
                         version_annotation = (
@@ -156,6 +204,10 @@ def cmd_status(args: argparse.Namespace) -> None:
                     "  Installed via: "
                     f"{format_install_method(install_info['method'], install_info['detail'])}"
                 )
+                migration_msg = format_migration_warning(tool_name)
+                if migration_msg:
+                    warning(f"  {migration_msg}")
+                    migration_count += 1
 
             if status["user"]:
                 print(f"  User:         {status['user']}")
@@ -181,3 +233,8 @@ def cmd_status(args: argparse.Namespace) -> None:
             f"{Colors.YELLOW}{outdated_count} tool(s) can be upgraded with "
             f"'code-aide upgrade'.{Colors.NC}"
         )
+    if migration_count > 0:
+        print(
+            f"{Colors.YELLOW}{migration_count} tool(s) need migration to a "
+            f"new install method. Run 'code-aide upgrade' to migrate.{Colors.NC}"
+        )

{code_aide-1.6.0 → code_aide-1.7.1}/src/code_aide/detection.py

@@ -1,6 +1,7 @@
 """Install-method and system package detection helpers."""
 
 import glob as globmod
+import json
 import os
 import re
 import shutil
@@ -41,12 +42,6 @@ def detect_install_method(tool_name: str) -> Dict[str, Optional[str]]:
             match = re.search(r"/node_modules/((?:@[^/]+/)?[^/]+)", real_path)
             if match:
                 npm_package = match.group(1)
-
-        if command_path.startswith("/opt/homebrew/bin/") or command_path.startswith(
-            "/usr/local/bin/"
-        ):
-            return {"method": "brew_npm", "detail": npm_package}
-
         return {"method": "npm", "detail": npm_package}
 
     system_prefixes = ("/opt/", "/usr/bin/", "/usr/sbin/", "/usr/local/bin/")
@@ -163,6 +158,72 @@ def get_system_package_info(binary_path: str) -> Dict[str, Optional[str]]:
     return result
 
 
+def get_brew_package_info(
+    method: str, package_name: Optional[str]
+) -> Dict[str, Optional[str]]:
+    """Get package version info for a Homebrew-managed tool."""
+    result: Dict[str, Optional[str]] = {
+        "package": package_name,
+        "installed_version": None,
+        "available_version": None,
+        "available_date": None,
+        "outdated": None,
+    }
+
+    if method not in ("brew_formula", "brew_cask") or not package_name:
+        return result
+
+    if not command_exists("brew"):
+        return result
+
+    command = ["brew", "info", "--json=v2"]
+    if method == "brew_cask":
+        command.append("--cask")
+    command.append(package_name)
+
+    try:
+        proc = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            timeout=10,
+            check=False,
+            stdin=subprocess.DEVNULL,
+        )
+        if proc.returncode != 0 or not proc.stdout.strip():
+            return result
+
+        payload = json.loads(proc.stdout)
+        if method == "brew_formula":
+            formulae = payload.get("formulae", [])
+            if not formulae:
+                return result
+            formula = formulae[0]
+            installed = formula.get("installed", [])
+            if installed:
+                result["installed_version"] = installed[-1].get("version")
+            linked_keg = formula.get("linked_keg")
+            if linked_keg:
+                result["installed_version"] = linked_keg
+            result["available_version"] = formula.get("versions", {}).get("stable")
+            result["outdated"] = bool(formula.get("outdated"))
+        else:
+            casks = payload.get("casks", [])
+            if not casks:
+                return result
+            cask = casks[0]
+            installed_version = cask.get("installed")
+            if isinstance(installed_version, list):
+                installed_version = installed_version[0] if installed_version else None
+            result["installed_version"] = installed_version
+            result["available_version"] = cask.get("version")
+            result["outdated"] = bool(cask.get("outdated"))
+    except Exception:
+        return result
+
+    return result
+
+
 def format_install_method(method: Optional[str], detail: Optional[str]) -> str:
     """Format detected local install method for display."""
     if method == "brew_formula":
@@ -186,3 +247,63 @@ def format_install_method(method: Optional[str], detail: Optional[str]) -> str:
     if method:
         return method
     return "unknown"
+
+
+# Install methods that are user-managed and never considered deprecated
+_USER_MANAGED_METHODS = frozenset({"brew_formula", "brew_cask", "system"})
+
+# Install methods that are considered deprecated when they don't match
+# the configured install_type
+_DEPRECATED_METHODS = frozenset({"npm", "brew_npm"})
+
+
+def is_deprecated_install(tool_name: str) -> bool:
+    """Check if a tool's detected install method is deprecated.
+
+    Returns True when the detected install method is npm or brew_npm
+    but the configured install_type is something else (e.g. script,
+    direct_download).  Brew formula/cask and system installs are
+    user-managed and never considered deprecated.
+    """
+    tool_config = TOOLS.get(tool_name)
+    if not tool_config:
+        return False
+
+    install_info = detect_install_method(tool_name)
+    detected = install_info["method"]
+
+    if not detected:
+        return False
+
+    if detected in _USER_MANAGED_METHODS:
+        return False
+
+    configured = tool_config.get("install_type")
+    if not configured:
+        return False
+
+    if detected in _DEPRECATED_METHODS and detected != configured:
+        return True
+
+    return False
+
+
+def format_migration_warning(tool_name: str) -> Optional[str]:
+    """Return a human-readable migration warning, or None if not needed."""
+    if not is_deprecated_install(tool_name):
+        return None
+
+    tool_config = TOOLS.get(tool_name)
+    if not tool_config:
+        return None
+
+    install_info = detect_install_method(tool_name)
+    detected_label = format_install_method(
+        install_info["method"], install_info["detail"]
+    )
+    configured_label = format_install_method(tool_config["install_type"], None)
+
+    return (
+        f"Installed via {detected_label} but configured method is "
+        f"{configured_label}. Run 'code-aide upgrade {tool_name}' to migrate."
+    )

{code_aide-1.6.0 → code_aide-1.7.1}/src/code_aide/install.py

@@ -234,7 +234,7 @@ def install_direct_download(
         return False
 
 
-def install_tool(tool_name: str, dryrun: bool = False) -> bool:
+def install_tool(tool_name: str, dryrun: bool = False, force: bool = False) -> bool:
     """Install a tool based on its configuration."""
     tool_config = TOOLS.get(tool_name)
     if not tool_config:
@@ -246,13 +246,25 @@ def install_tool(tool_name: str, dryrun: bool = False) -> bool:
     else:
         info(f"Installing {tool_config['name']}...")
 
-    if command_exists(tool_config["command"]):
+    if command_exists(tool_config["command"]) and not force:
         tool_path = shutil.which(tool_config["command"])
         if dryrun:
             info(f"{tool_config['command']} already installed at {tool_path}")
         else:
             warning(f"{tool_config['command']} already installed at {tool_path}")
         return True
+    if command_exists(tool_config["command"]) and force:
+        tool_path = shutil.which(tool_config["command"])
+        if dryrun:
+            info(
+                f"[DRYRUN] Would reinstall {tool_config['command']} despite existing "
+                f"binary at {tool_path}"
+            )
+        else:
+            info(
+                f"Reinstalling {tool_config['command']} despite existing binary at "
+                f"{tool_path}"
+            )
 
     try:
         install_type = tool_config["install_type"]