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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-aide
-Version: 1.7.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

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

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

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

@@ -5,10 +5,19 @@ import sys
 from typing import Any, Dict, List
 
 from code_aide.constants import TOOLS
-from code_aide.detection import is_deprecated_install
+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,
@@ -131,6 +140,13 @@ def cmd_upgrade(args: argparse.Namespace) -> None:
             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
@@ -145,7 +161,8 @@ def cmd_upgrade(args: argparse.Namespace) -> None:
 
     validate_tools(tools_to_upgrade)
 
-    upgraded = []
+    updated = []
+    unchanged = []
     failed = []
     skipped = []
 
@@ -157,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)
 
@@ -167,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)}")
@@ -177,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.7.0 → code_aide-1.7.1}/src/code_aide/commands_tools.py

@@ -9,12 +9,17 @@ 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,
@@ -128,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 = (

{code_aide-1.7.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":

{code_aide-1.7.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"]

{code_aide-1.7.0 → code_aide-1.7.1}/src/code_aide/operations.py

@@ -5,7 +5,8 @@ import os
 import shutil
 import subprocess
 import sys
-from typing import List
+from enum import Enum
+from typing import Dict, List
 
 from code_aide.constants import TOOLS
 from code_aide.detection import (
@@ -16,10 +17,60 @@ from code_aide.detection import (
 from code_aide.install import install_direct_download, install_tool, run_install_script
 from code_aide.console import error, info, run_command, success, warning
 from code_aide.prereqs import is_tool_installed
+from code_aide.status import get_tool_status
 
 
-def _migrate_install_method(tool_name: str) -> bool:
-    """Migrate a tool from a deprecated install method to the configured one."""
+class UpgradeResult(Enum):
+    """Possible outcomes from `upgrade_tool()`.
+
+    Values:
+    - `CHANGED`: The upgrade or migration changed the detected install state.
+    - `UNCHANGED`: The upgrade command ran, but the detected install state did
+      not change.
+    - `FAILED`: The upgrade or migration failed.
+    """
+
+    CHANGED = "changed"
+    UNCHANGED = "unchanged"
+    FAILED = "failed"
+
+
+def _get_upgrade_snapshot(
+    tool_name: str, tool_config: Dict[str, str]
+) -> Dict[str, str]:
+    """Capture install method and version before/after a change."""
+    install_info = detect_install_method(tool_name)
+    status = get_tool_status(tool_name, tool_config)
+    return {
+        "method": install_info["method"],
+        "detail": install_info["detail"],
+        "version": status.get("version"),
+    }
+
+
+def _upgrade_result_from_snapshots(
+    tool_config: Dict[str, str], before: Dict[str, str], after: Dict[str, str]
+) -> UpgradeResult:
+    """Classify whether an upgrade actually changed the installed tool."""
+    if before == after:
+        version = after.get("version") or "unknown"
+        info(
+            f"{tool_config['name']} did not change after the upgrade attempt "
+            f"(current version: {version})"
+        )
+        return UpgradeResult.UNCHANGED
+    success(f"{tool_config['name']} upgraded successfully")
+    return UpgradeResult.CHANGED
+
+
+def _migrate_install_method(tool_name: str) -> UpgradeResult:
+    """Migrate a tool from a deprecated install method to the configured one.
+
+    Returns:
+    - `UpgradeResult.CHANGED` when the tool is successfully migrated.
+    - `UpgradeResult.FAILED` when removal, reinstall, or post-check verification
+      fails.
+    """
     tool_config = TOOLS[tool_name]
     install_info = detect_install_method(tool_name)
     old_label = format_install_method(install_info["method"], install_info["detail"])
@@ -36,30 +87,47 @@ def _migrate_install_method(tool_name: str) -> bool:
             f"Failed to remove old {old_label} install of {tool_config['name']}. "
             "Migration aborted."
         )
-        return False
+        return UpgradeResult.FAILED
 
-    if not install_tool(tool_name):
+    if not install_tool(tool_name, force=True):
         error(f"Failed to install {tool_config['name']} via {new_label}.")
         error(
             f"The old {old_label} install has been removed. "
             f"To recover, run: code-aide install {tool_name}"
         )
-        return False
+        return UpgradeResult.FAILED
+
+    after = detect_install_method(tool_name)
+    if after["method"] != tool_config["install_type"]:
+        detected_label = format_install_method(after["method"], after["detail"])
+        error(
+            f"Migration did not complete: {tool_config['name']} is still detected as "
+            f"{detected_label}."
+        )
+        return UpgradeResult.FAILED
 
     success(f"{tool_config['name']} migrated from {old_label} to {new_label}")
-    return True
+    return UpgradeResult.CHANGED
+
 
+def upgrade_tool(tool_name: str) -> UpgradeResult:
+    """Upgrade a tool based on its configuration.
 
-def upgrade_tool(tool_name: str) -> bool:
-    """Upgrade a tool based on its configuration."""
+    Returns:
+    - `UpgradeResult.CHANGED` when the installed tool changed version or install
+      method.
+    - `UpgradeResult.UNCHANGED` when the upgrade command ran but the detected
+      install state did not change.
+    - `UpgradeResult.FAILED` when the upgrade could not be completed.
+    """
     tool_config = TOOLS.get(tool_name)
     if not tool_config:
         error(f"Unknown tool: {tool_name}")
-        return False
+        return UpgradeResult.FAILED
 
     if not is_tool_installed(tool_name):
         warning(f"{tool_config['name']} is not installed. Use 'install' command first.")
-        return False
+        return UpgradeResult.FAILED
 
     if is_deprecated_install(tool_name):
         return _migrate_install_method(tool_name)
@@ -67,62 +135,61 @@ def upgrade_tool(tool_name: str) -> bool:
     install_info = detect_install_method(tool_name)
     method = install_info["method"]
     detail = install_info["detail"]
+    before = _get_upgrade_snapshot(tool_name, tool_config)
 
     info(f"Upgrading {tool_config['name']} (installed via {method})...")
 
     try:
         if method == "brew_formula":
             run_command(["brew", "upgrade", detail], check=True, capture=False)
-            success(f"{tool_config['name']} upgraded successfully")
 
         elif method == "brew_cask":
             run_command(
                 ["brew", "upgrade", "--cask", detail], check=True, capture=False
             )
-            success(f"{tool_config['name']} upgraded successfully")
 
         elif method in ("npm", "brew_npm"):
             npm_package = detail or tool_config.get("npm_package")
             if not npm_package:
                 error(f"No npm package configured for {tool_config['name']}")
-                return False
+                return UpgradeResult.FAILED
             run_command(["npm", "install", "-g", f"{npm_package}@latest"], check=True)
-            success(f"{tool_config['name']} upgraded successfully")
 
         elif method == "script":
             install_url = tool_config["install_url"]
             expected_sha256 = tool_config.get("install_sha256")
             if run_install_script(install_url, tool_config["name"], expected_sha256):
-                success(f"{tool_config['name']} upgraded successfully")
+                pass
             else:
-                return False
+                return UpgradeResult.FAILED
 
         elif method == "direct_download":
             if not install_direct_download(tool_name, tool_config):
-                return False
+                return UpgradeResult.FAILED
 
         elif method == "system":
             error(
                 f"{tool_config['name']} is managed by the system package manager. "
                 "Use your package manager to upgrade it."
             )
-            return False
+            return UpgradeResult.FAILED
 
         else:
             error(
                 f"Don't know how to upgrade {tool_config['name']} "
                 f"(install method: {method})"
             )
-            return False
+            return UpgradeResult.FAILED
 
-        return True
+        after = _get_upgrade_snapshot(tool_name, tool_config)
+        return _upgrade_result_from_snapshots(tool_config, before, after)
 
     except subprocess.CalledProcessError as exc:
         error(f"Failed to upgrade {tool_config['name']}: {exc.stderr}")
-        return False
+        return UpgradeResult.FAILED
     except Exception as exc:
         error(f"Failed to upgrade {tool_config['name']}: {exc}")
-        return False
+        return UpgradeResult.FAILED
 
 
 def remove_tool(tool_name: str) -> bool:

{code_aide-1.7.0 → code_aide-1.7.1}/src/code_aide/status.py

@@ -51,6 +51,36 @@ def print_system_version_status(
             print(f"  Packaged:     {avail_ver} ({pkg_name}{date_suffix})")
 
 
+def print_brew_version_status(
+    cli_version: str,
+    latest_version: Optional[str],
+    pkg_info: Dict[str, Optional[str]],
+) -> None:
+    """Print version status for a Homebrew-managed tool."""
+    avail_ver = pkg_info.get("available_version")
+    outdated = pkg_info.get("outdated")
+
+    if outdated:
+        print(
+            f"  Version:      {cli_version} {Colors.YELLOW}(Homebrew has {avail_ver})"
+            f"{Colors.NC}"
+        )
+    else:
+        print(f"  Version:      {cli_version} {Colors.GREEN}(up to date){Colors.NC}")
+
+    if avail_ver:
+        pkg_name = pkg_info.get("package") or "Homebrew"
+        if latest_version and not status_version_matches_latest(
+            avail_ver, latest_version
+        ):
+            print(
+                f"  Packaged:     {avail_ver} ({pkg_name}) "
+                f"{Colors.YELLOW}(upstream: {latest_version}){Colors.NC}"
+            )
+        else:
+            print(f"  Packaged:     {avail_ver} ({pkg_name})")
+
+
 def get_tool_status(tool_name: str, tool_config: Dict[str, Any]) -> Dict[str, Any]:
     """Get status information for a specific tool."""
     status_info = {

{code_aide-1.7.0 → code_aide-1.7.1}/tests/test_commands_actions.py

@@ -8,6 +8,7 @@ from unittest import mock
 
 from code_aide import commands_actions
 from code_aide import entry
+from code_aide.operations import UpgradeResult
 
 
 class TestCmdInstall(unittest.TestCase):
@@ -136,3 +137,80 @@ class TestUpgradeNoArgsParsing(unittest.TestCase):
         (args,) = mock_upgrade.call_args[0]
         self.assertEqual(args.command, "upgrade")
         self.assertEqual(args.tools, [])
+
+
+class TestCmdUpgrade(unittest.TestCase):
+    """Tests for cmd_upgrade output handling."""
+
+    def test_unchanged_upgrades_are_not_reported_as_updated(self):
+        tools = {
+            "test": {
+                "name": "Test Tool",
+                "command": "test",
+                "latest_version": "2.0.0",
+            }
+        }
+        args = type("Args", (), {"tools": ["test"]})()
+
+        with (
+            mock.patch.dict(commands_actions.TOOLS, tools, clear=True),
+            mock.patch.object(commands_actions, "validate_tools"),
+            mock.patch.object(commands_actions, "is_tool_installed", return_value=True),
+            mock.patch.object(
+                commands_actions,
+                "upgrade_tool",
+                return_value=UpgradeResult.UNCHANGED,
+            ),
+        ):
+            buf = io.StringIO()
+            with contextlib.redirect_stdout(buf):
+                commands_actions.cmd_upgrade(args)
+
+        output = buf.getvalue()
+        self.assertIn("No package-manager change: test", output)
+        self.assertNotIn("Successfully updated: test", output)
+
+    def test_default_upgrade_skips_brew_tool_when_homebrew_not_outdated(self):
+        tools = {
+            "brewtool": {
+                "name": "Brew Tool",
+                "command": "brewtool",
+                "latest_version": "9.9.9",
+            }
+        }
+        args = type("Args", (), {"tools": []})()
+
+        with (
+            mock.patch.dict(commands_actions.TOOLS, tools, clear=True),
+            mock.patch.object(commands_actions, "validate_tools"),
+            mock.patch.object(commands_actions, "is_tool_installed", return_value=True),
+            mock.patch.object(
+                commands_actions, "is_deprecated_install", return_value=False
+            ),
+            mock.patch.object(
+                commands_actions,
+                "detect_install_method",
+                return_value={"method": "brew_formula", "detail": "brewtool"},
+            ),
+            mock.patch.object(
+                commands_actions,
+                "get_brew_package_info",
+                return_value={
+                    "package": "brewtool",
+                    "installed_version": "1.0.0",
+                    "available_version": "1.0.0",
+                    "available_date": None,
+                    "outdated": False,
+                },
+            ),
+            mock.patch.object(commands_actions, "get_tool_status") as mock_status,
+            mock.patch.object(commands_actions, "upgrade_tool") as mock_upgrade,
+        ):
+            buf = io.StringIO()
+            with contextlib.redirect_stdout(buf):
+                commands_actions.cmd_upgrade(args)
+
+        output = buf.getvalue()
+        self.assertIn("All installed tools are up to date", output)
+        mock_status.assert_not_called()
+        mock_upgrade.assert_not_called()

{code_aide-1.7.0 → code_aide-1.7.1}/tests/test_commands_tools.py

@@ -80,6 +80,57 @@ class TestCmdStatus(unittest.TestCase):
         self.assertIn("Example Tool", output)
         self.assertIn("tool(s) can be upgraded", output)
 
+    def test_brew_current_upstream_lag_does_not_count_as_upgradeable(self):
+        tools = {
+            "x": {
+                "name": "Example Tool",
+                "command": "example",
+                "install_type": "npm",
+                "latest_version": "2.0.0",
+            }
+        }
+        status = {
+            "installed": True,
+            "version": "1.0.0",
+            "user": None,
+            "usage": None,
+            "errors": [],
+        }
+        args = type("Args", (), {})()
+        with (
+            mock.patch.dict(commands_tools.TOOLS, tools, clear=True),
+            mock.patch.object(commands_tools, "get_tool_status", return_value=status),
+            mock.patch.object(
+                commands_tools.shutil, "which", return_value="/opt/homebrew/bin/example"
+            ),
+            mock.patch.object(
+                commands_tools,
+                "detect_install_method",
+                return_value={"method": "brew_formula", "detail": "example"},
+            ),
+            mock.patch.object(
+                commands_tools,
+                "get_brew_package_info",
+                return_value={
+                    "package": "example",
+                    "installed_version": "1.0.0",
+                    "available_version": "1.0.0",
+                    "available_date": None,
+                    "outdated": False,
+                },
+            ),
+            mock.patch.object(
+                commands_tools, "format_migration_warning", return_value=None
+            ),
+        ):
+            buf = io.StringIO()
+            with contextlib.redirect_stdout(buf):
+                commands_tools.cmd_status(args)
+        output = buf.getvalue()
+        self.assertIn("Packaged:     1.0.0 (example)", output)
+        self.assertIn("upstream: 2.0.0", output)
+        self.assertNotIn("tool(s) can be upgraded", output)
+
     def test_status_shows_migration_warning(self):
         """cmd_status shows migration warning for deprecated install."""
         tools = {

{code_aide-1.7.0 → code_aide-1.7.1}/tests/test_detection.py

@@ -57,6 +57,19 @@ class TestDetectInstallMethod(unittest.TestCase):
             {"method": "npm", "detail": "@google/gemini-cli"},
         )
 
+    @mock.patch.object(cli_detection.os.path, "realpath")
+    @mock.patch.object(cli_detection.shutil, "which")
+    def test_detects_npm_under_homebrew_prefix_as_npm(self, mock_which, mock_realpath):
+        mock_which.return_value = "/opt/homebrew/bin/copilot"
+        mock_realpath.return_value = (
+            "/opt/homebrew/lib/node_modules/@github/copilot/bin/copilot.js"
+        )
+
+        self.assertEqual(
+            cli_detection.detect_install_method("copilot"),
+            {"method": "npm", "detail": "@github/copilot"},
+        )
+
     @mock.patch.object(cli_detection.os.path, "realpath")
     @mock.patch.object(cli_detection.shutil, "which")
     def test_detects_system_package_opt(self, mock_which, mock_realpath):

{code_aide-1.7.0 → code_aide-1.7.1}/tests/test_install.py

@@ -176,3 +176,60 @@ class TestInstallDirectDownload(unittest.TestCase):
             self.assertTrue(os.path.isdir(os.path.dirname(install_dir)))
             self.assertTrue(os.path.exists(os.path.join(install_dir, "test-bin")))
             self.assertTrue(os.path.islink(os.path.join(bin_dir, "test")))
+
+
+class TestInstallTool(unittest.TestCase):
+    """Tests for install_tool behavior."""
+
+    def test_force_reinstalls_even_when_binary_exists(self):
+        tool_config = {
+            "name": "Test Tool",
+            "command": "test-tool",
+            "install_type": "npm",
+            "npm_package": "test-tool",
+            "next_steps": "Run test-tool",
+        }
+
+        with (
+            mock.patch.dict(cli_install.TOOLS, {"test": tool_config}, clear=True),
+            mock.patch.object(cli_install, "command_exists", return_value=True),
+            mock.patch.object(
+                cli_install.shutil, "which", return_value="/usr/local/bin/test-tool"
+            ),
+            mock.patch.object(cli_install, "run_command") as mock_run,
+        ):
+            result = cli_install.install_tool("test", force=True)
+
+        self.assertTrue(result)
+        mock_run.assert_called_once_with(
+            ["npm", "install", "-g", "test-tool"], check=True
+        )
+
+    def test_force_dryrun_reports_reinstall_when_binary_exists(self):
+        tool_config = {
+            "name": "Test Tool",
+            "command": "test-tool",
+            "install_type": "npm",
+            "npm_package": "test-tool",
+            "next_steps": "Run test-tool",
+        }
+
+        with (
+            mock.patch.dict(cli_install.TOOLS, {"test": tool_config}, clear=True),
+            mock.patch.object(cli_install, "command_exists", return_value=True),
+            mock.patch.object(
+                cli_install.shutil, "which", return_value="/usr/local/bin/test-tool"
+            ),
+            mock.patch.object(cli_install, "info") as mock_info,
+            mock.patch.object(cli_install, "run_command") as mock_run,
+        ):
+            result = cli_install.install_tool("test", dryrun=True, force=True)
+
+        self.assertTrue(result)
+        mock_run.assert_not_called()
+        mock_info.assert_any_call("[DRYRUN] Checking Test Tool...")
+        mock_info.assert_any_call(
+            "[DRYRUN] Would reinstall test-tool despite existing binary at "
+            "/usr/local/bin/test-tool"
+        )
+        mock_info.assert_any_call("[DRYRUN] Would install npm package: test-tool")

{code_aide-1.7.0 → code_aide-1.7.1}/tests/test_operations.py

@@ -7,6 +7,7 @@ from unittest import mock
 
 from code_aide import commands_actions as cli_commands_actions
 from code_aide import operations as cli_operations
+from code_aide.operations import UpgradeResult
 
 
 class TestRemoveToolDirectDownload(unittest.TestCase):
@@ -137,13 +138,16 @@ class TestMigrateInstallMethod(unittest.TestCase):
             mock.patch.object(
                 cli_operations,
                 "detect_install_method",
-                return_value={"method": "npm", "detail": "test-pkg"},
+                side_effect=[
+                    {"method": "npm", "detail": "test-pkg"},
+                    {"method": "script", "detail": None},
+                ],
             ),
         ):
             result = cli_operations.upgrade_tool("test")
-        self.assertTrue(result)
+        self.assertEqual(result, UpgradeResult.CHANGED)
         mock_remove.assert_called_once_with("test")
-        mock_install.assert_called_once_with("test")
+        mock_install.assert_called_once_with("test", force=True)
 
     def test_upgrade_normal_when_not_deprecated(self):
         """upgrade_tool does normal upgrade when not deprecated."""
@@ -163,14 +167,33 @@ class TestMigrateInstallMethod(unittest.TestCase):
             mock.patch.object(
                 cli_operations,
                 "detect_install_method",
-                return_value={"method": "script", "detail": "native installer"},
+                side_effect=[
+                    {"method": "script", "detail": "native installer"},
+                    {"method": "script", "detail": "native installer"},
+                ],
             ),
             mock.patch.object(
                 cli_operations, "run_install_script", return_value=True
             ) as mock_script,
+            mock.patch.object(
+                cli_operations,
+                "_get_upgrade_snapshot",
+                side_effect=[
+                    {
+                        "method": "script",
+                        "detail": "native installer",
+                        "version": "1.0.0",
+                    },
+                    {
+                        "method": "script",
+                        "detail": "native installer",
+                        "version": "2.0.0",
+                    },
+                ],
+            ),
         ):
             result = cli_operations.upgrade_tool("test")
-        self.assertTrue(result)
+        self.assertEqual(result, UpgradeResult.CHANGED)
         mock_script.assert_called_once()
 
     def test_migration_fails_on_remove(self):
@@ -197,7 +220,7 @@ class TestMigrateInstallMethod(unittest.TestCase):
             ),
         ):
             result = cli_operations.upgrade_tool("test")
-        self.assertFalse(result)
+        self.assertEqual(result, UpgradeResult.FAILED)
         mock_install.assert_not_called()
 
     def test_migration_fails_on_install(self):
@@ -222,7 +245,42 @@ class TestMigrateInstallMethod(unittest.TestCase):
             ),
         ):
             result = cli_operations.upgrade_tool("test")
-        self.assertFalse(result)
+        self.assertEqual(result, UpgradeResult.FAILED)
+
+    def test_upgrade_reports_unchanged_when_version_does_not_change(self):
+        """Upgrade result is unchanged when package manager leaves version as-is."""
+        tool_config = {
+            "name": "Test Tool",
+            "command": "test-tool",
+            "install_type": "npm",
+            "npm_package": "test-tool",
+        }
+        with (
+            mock.patch.dict(cli_operations.TOOLS, {"test": tool_config}),
+            mock.patch.object(cli_operations, "is_tool_installed", return_value=True),
+            mock.patch.object(
+                cli_operations, "is_deprecated_install", return_value=False
+            ),
+            mock.patch.object(
+                cli_operations,
+                "detect_install_method",
+                return_value={"method": "npm", "detail": "test-tool"},
+            ),
+            mock.patch.object(cli_operations, "run_command") as mock_run,
+            mock.patch.object(
+                cli_operations,
+                "_get_upgrade_snapshot",
+                side_effect=[
+                    {"method": "npm", "detail": "test-tool", "version": "1.0.0"},
+                    {"method": "npm", "detail": "test-tool", "version": "1.0.0"},
+                ],
+            ),
+        ):
+            result = cli_operations.upgrade_tool("test")
+        self.assertEqual(result, UpgradeResult.UNCHANGED)
+        mock_run.assert_called_once_with(
+            ["npm", "install", "-g", "test-tool@latest"], check=True
+        )
 
 
 class TestCmdUpgradeDefaultSelection(unittest.TestCase):
@@ -268,7 +326,9 @@ class TestCmdUpgradeDefaultSelection(unittest.TestCase):
                 cli_commands_actions, "get_tool_status", side_effect=_status
             ),
             mock.patch.object(
-                cli_commands_actions, "upgrade_tool", return_value=True
+                cli_commands_actions,
+                "upgrade_tool",
+                return_value=UpgradeResult.CHANGED,
             ) as mock_upgrade,
         ):
             cli_commands_actions.cmd_upgrade(args)
@@ -301,7 +361,9 @@ class TestCmdUpgradeDefaultSelection(unittest.TestCase):
                 return_value={"version": "1.0.0"},
             ),
             mock.patch.object(
-                cli_commands_actions, "upgrade_tool", return_value=True
+                cli_commands_actions,
+                "upgrade_tool",
+                return_value=UpgradeResult.CHANGED,
             ) as mock_upgrade,
         ):
             cli_commands_actions.cmd_upgrade(args)