code-aide 1.12.3__tar.gz → 1.14.0__tar.gz

{code_aide-1.12.3 → code_aide-1.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-aide
-Version: 1.12.3
+Version: 1.14.0
 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.12.3 → code_aide-1.14.0}/script-archive/amp-install.sh

@@ -1,10 +1,6 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-# Amp CLI Binary Installation Script (EXPERIMENTAL - NOT DOCUMENTED)
-# This is a secondary install script for testing binary distribution
-# Downloads pre-compiled Amp CLI binary instead of using npm
-
 # Configuration
 AMP_HOME="${AMP_HOME:-$HOME/.amp}"
 BIN_DIR="$AMP_HOME/bin"
@@ -437,11 +433,8 @@ update_shell_profile() {
 			return
 		fi
 	else
-		# Non-interactive: show instructions instead
-		log "Non-interactive mode: skipping shell config modification."
-		log "To use amp, add ~/.local/bin to your PATH:"
-		echo "  $path_export"
-		return
+		# Non-interactive: add automatically
+		log "Adding ~/.local/bin to PATH in $tilde_profile..."
 	fi
 
 	# Create config file if it doesn't exist

{code_aide-1.12.3 → code_aide-1.14.0}/src/code_aide/__init__.py

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

{code_aide-1.12.3 → code_aide-1.14.0}/src/code_aide/commands_tools.py

@@ -8,7 +8,7 @@ import shutil
 from typing import List
 
 from code_aide.config import ensure_versions_cache
-from code_aide.constants import Colors, PACKAGE_MANAGERS, TOOLS
+from code_aide.constants import Colors, TOOLS
 from code_aide.detection import (
     format_install_method,
     format_migration_warning,
@@ -20,7 +20,10 @@ from code_aide.install_types import (
     parse_install_method,
     parse_install_type,
 )
-from code_aide.prereqs import detect_package_manager, is_tool_installed
+from code_aide.package_managers import (
+    detect_package_manager as _detect_package_manager,
+)
+from code_aide.prereqs import is_tool_installed
 from code_aide.detection import is_freebsd
 from code_aide.status import (
     print_brew_version_status,
@@ -107,11 +110,9 @@ def cmd_list(args: argparse.Namespace) -> None:
         except Exception:
             pass
 
-    pkg_mgr = detect_package_manager()
+    pkg_mgr = _detect_package_manager()
     if pkg_mgr:
-        print(
-            f"  Package manager: {PACKAGE_MANAGERS[pkg_mgr]['description']} ({pkg_mgr})"
-        )
+        print(f"  Package manager: {pkg_mgr.description} ({pkg_mgr.detect_command})")
 
 
 def _short_install_method(method: str | None) -> str:

code_aide-1.14.0/src/code_aide/constants.py

@@ -0,0 +1,51 @@
+"""Shared constants and mutable tool configuration for CLI modules."""
+
+import os
+import sys
+from typing import Any, Dict
+
+from code_aide.config import load_tools_config
+
+
+def _use_color() -> bool:
+    """Determine whether to emit ANSI color codes.
+
+    Checks (in priority order):
+      NO_COLOR          — if set (any value), no color (https://no-color.org/)
+      FORCE_COLOR       — if set (any value), force color
+      CLICOLOR_FORCE    — if non-empty, force color
+      TERM=dumb         — no color
+      CLICOLOR=0        — no color
+      stdout is not a TTY — no color
+    """
+    if os.environ.get("NO_COLOR") is not None:
+        return False
+    if os.environ.get("FORCE_COLOR") is not None:
+        return True
+    if os.environ.get("CLICOLOR_FORCE", ""):
+        return True
+    if os.environ.get("TERM") == "dumb":
+        return False
+    if os.environ.get("CLICOLOR") == "0":
+        return False
+    return sys.stdout.isatty()
+
+
+class Colors:
+    if _use_color():
+        RED = "\033[0;31m"
+        GREEN = "\033[0;32m"
+        YELLOW = "\033[1;33m"
+        BLUE = "\033[0;34m"
+        BOLD = "\033[1m"
+        NC = "\033[0m"
+    else:
+        RED = ""
+        GREEN = ""
+        YELLOW = ""
+        BLUE = ""
+        BOLD = ""
+        NC = ""
+
+
+TOOLS: Dict[str, Dict[str, Any]] = load_tools_config()

{code_aide-1.12.3 → code_aide-1.14.0}/src/code_aide/data/tools.json

@@ -64,7 +64,10 @@
       "command": "amp",
       "install_type": "script",
       "install_url": "https://ampcode.com/install.sh",
-      "install_sha256": "a529b01e1e3653ad3e77cf8e5ec1f2cede5d65c880a62e783a3365bbd825be6d",
+      "install_sha256": "2442f20759a2be3beaef6691c7e5bf349f469eb0ff7ea2885746500243446e24",
+      "install_script_path_prepend": [
+        "~/.local/bin"
+      ],
       "version_url": "https://storage.googleapis.com/amp-public-assets-prod-0/cli/cli-version.txt",
       "prerequisites": [],
       "min_node_version": null,

{code_aide-1.12.3 → code_aide-1.14.0}/src/code_aide/install.py

@@ -43,6 +43,7 @@ def run_install_script(
     tool_name: str,
     expected_sha256: Optional[str] = None,
     dryrun: bool = False,
+    env: Optional[Dict[str, str]] = None,
 ) -> bool:
     """Download and run an installation script with SHA256 verification."""
     try:
@@ -82,6 +83,7 @@ def run_install_script(
             ["bash"],
             stdin=subprocess.PIPE,
             stderr=subprocess.PIPE,
+            env=env,
         )
         _, stderr = bash_process.communicate(input=script_content)
 
@@ -99,6 +101,22 @@ def run_install_script(
         return False
 
 
+def get_install_script_env(tool_config: Dict[str, Any]) -> Optional[Dict[str, str]]:
+    """Return environment overrides for running a tool's install script."""
+    path_prepend = tool_config.get("install_script_path_prepend", [])
+    if not path_prepend:
+        return None
+
+    env = os.environ.copy()
+    expanded_paths = [os.path.expanduser(path) for path in path_prepend]
+    current_path = env.get("PATH", "")
+    path_parts = [*expanded_paths]
+    if current_path:
+        path_parts.append(current_path)
+    env["PATH"] = os.pathsep.join(path_parts)
+    return env
+
+
 ARCH_MAP = {
     "x86_64": "x64",
     "amd64": "x64",
@@ -327,7 +345,11 @@ def install_tool(tool_name: str, dryrun: bool = False, force: bool = False) -> b
             install_url = tool_config["install_url"]
             expected_sha256 = tool_config.get("install_sha256")
             if run_install_script(
-                install_url, tool_config["name"], expected_sha256, dryrun
+                install_url,
+                tool_config["name"],
+                expected_sha256,
+                dryrun,
+                env=get_install_script_env(tool_config),
             ):
                 if dryrun:
                     success(f"{tool_config['name']} verification passed")

{code_aide-1.12.3 → code_aide-1.14.0}/src/code_aide/operations.py

@@ -14,7 +14,9 @@ from code_aide.detection import (
     format_install_method,
     is_deprecated_install,
 )
+from code_aide.package_managers import query_package_owner
 from code_aide.install import (
+    get_install_script_env,
     install_direct_download,
     install_tool,
     run_install_script,
@@ -83,6 +85,44 @@ def _upgrade_result_from_snapshots(
     return UpgradeResult.CHANGED
 
 
+def _warn_duplicate_system_install(tool_name: str) -> None:
+    """Warn if a duplicate system-packaged binary shadows or coexists."""
+    tool_config = TOOLS[tool_name]
+    command = tool_config["command"]
+
+    # Find all instances of the command in PATH
+    seen = set()
+    paths = []
+    for directory in os.environ.get("PATH", "").split(os.pathsep):
+        candidate = os.path.join(directory, command)
+        if os.path.isfile(candidate) and os.access(candidate, os.X_OK):
+            real = os.path.realpath(candidate)
+            if real not in seen:
+                seen.add(real)
+                paths.append(real)
+
+    if len(paths) < 2:
+        return
+
+    system_prefixes = ("/opt/", "/usr/bin/", "/usr/sbin/", "/usr/local/bin/")
+    for path in paths:
+        if not any(path.startswith(p) for p in system_prefixes):
+            continue
+        package, remove_cmd = query_package_owner(path)
+        if package and remove_cmd:
+            warning(
+                f"A system-packaged {command} is also installed at {path} "
+                f"(package: {package})."
+            )
+            info(f"To remove it, run:  {remove_cmd}")
+        else:
+            warning(
+                f"A system-packaged {command} is also installed at {path}. "
+                "You may want to remove it with your package manager."
+            )
+        return
+
+
 def _migrate_install_method(tool_name: str) -> UpgradeResult:
     """Migrate a tool from a deprecated install method to the configured one.
 
@@ -129,6 +169,7 @@ def _migrate_install_method(tool_name: str) -> UpgradeResult:
         return UpgradeResult.FAILED
 
     success(f"{tool_config['name']} migrated from {old_label} to {new_label}")
+    _warn_duplicate_system_install(tool_name)
     return UpgradeResult.CHANGED
 
 
@@ -185,7 +226,10 @@ def upgrade_tool(tool_name: str) -> UpgradeResult:
                 install_url = tool_config["install_url"]
                 expected_sha256 = tool_config.get("install_sha256")
                 if run_install_script(
-                    install_url, tool_config["name"], expected_sha256
+                    install_url,
+                    tool_config["name"],
+                    expected_sha256,
+                    env=get_install_script_env(tool_config),
                 ):
                     pass
                 else:

code_aide-1.14.0/src/code_aide/package_managers.py

@@ -0,0 +1,188 @@
+"""System package manager definitions and helpers."""
+
+import os
+import platform
+import shutil
+import subprocess
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import List, Optional
+
+
+class PackageManager(Enum):
+    """Known system package managers."""
+
+    APT = "apt-get"
+    DNF = "dnf"
+    YUM = "yum"
+    PACMAN = "pacman"
+    ZYPPER = "zypper"
+    EMERGE = "emerge"
+    PKG = "pkg"
+    HOMEBREW = "brew"
+
+
+@dataclass(frozen=True)
+class PackageManagerInfo:
+    """Configuration for a system package manager."""
+
+    manager: PackageManager
+    description: str
+    detect_command: str
+    packages: List[str]
+    install_command: List[str]
+    pre_install: List[List[str]] = field(default_factory=list)
+    query_owner_command: List[str] = field(default_factory=list)
+    remove_command: List[str] = field(default_factory=list)
+
+
+_MANAGERS: List[PackageManagerInfo] = [
+    PackageManagerInfo(
+        manager=PackageManager.APT,
+        description="Debian/Ubuntu",
+        detect_command="apt-get",
+        packages=["nodejs", "npm"],
+        pre_install=[["sudo", "apt-get", "update"]],
+        install_command=["sudo", "apt-get", "install", "-y"],
+        query_owner_command=["dpkg", "-S"],
+        remove_command=["sudo", "apt-get", "remove"],
+    ),
+    PackageManagerInfo(
+        manager=PackageManager.DNF,
+        description="Fedora/RHEL 8+",
+        detect_command="dnf",
+        packages=["nodejs", "npm"],
+        install_command=["sudo", "dnf", "install", "-y"],
+        query_owner_command=["rpm", "-qf"],
+        remove_command=["sudo", "dnf", "remove"],
+    ),
+    PackageManagerInfo(
+        manager=PackageManager.YUM,
+        description="RHEL/CentOS 7",
+        detect_command="yum",
+        packages=["nodejs", "npm"],
+        install_command=["sudo", "yum", "install", "-y"],
+        query_owner_command=["rpm", "-qf"],
+        remove_command=["sudo", "yum", "remove"],
+    ),
+    PackageManagerInfo(
+        manager=PackageManager.PACMAN,
+        description="Arch Linux",
+        detect_command="pacman",
+        packages=["nodejs", "npm"],
+        install_command=["sudo", "pacman", "-S", "--noconfirm"],
+        query_owner_command=["pacman", "-Qo"],
+        remove_command=["sudo", "pacman", "-R"],
+    ),
+    PackageManagerInfo(
+        manager=PackageManager.ZYPPER,
+        description="openSUSE",
+        detect_command="zypper",
+        packages=["nodejs", "npm"],
+        install_command=["sudo", "zypper", "install", "-y"],
+        query_owner_command=["rpm", "-qf"],
+        remove_command=["sudo", "zypper", "remove"],
+    ),
+    PackageManagerInfo(
+        manager=PackageManager.EMERGE,
+        description="Gentoo",
+        detect_command="emerge",
+        packages=["net-libs/nodejs"],
+        install_command=["sudo", "emerge", "--quiet-build"],
+        query_owner_command=["qfile", "-qC"],
+        remove_command=["sudo", "emerge", "--unmerge"],
+    ),
+    PackageManagerInfo(
+        manager=PackageManager.PKG,
+        description="FreeBSD",
+        detect_command="pkg",
+        packages=["node22", "npm-node22"],
+        install_command=["sudo", "pkg", "install", "-y"],
+        query_owner_command=["pkg", "which", "-q"],
+        remove_command=["sudo", "pkg", "delete"],
+    ),
+    PackageManagerInfo(
+        manager=PackageManager.HOMEBREW,
+        description="macOS/Linux (Homebrew)",
+        detect_command="brew",
+        packages=["node"],
+        install_command=["brew", "install"],
+        query_owner_command=["brew", "which-formula"],
+        remove_command=["brew", "uninstall"],
+    ),
+]
+
+PACKAGE_MANAGER_BY_ENUM = {info.manager: info for info in _MANAGERS}
+
+
+def detect_package_manager() -> Optional[PackageManagerInfo]:
+    """Detect the system package manager, or None on unsupported platforms."""
+    if platform.system() not in ("Linux", "FreeBSD", "Darwin"):
+        return None
+
+    for info in _MANAGERS:
+        if shutil.which(info.detect_command):
+            return info
+
+    return None
+
+
+def _parse_package_name(manager: PackageManager, query_output: str) -> Optional[str]:
+    """Extract a package name from query-owner output."""
+    line = query_output.strip().split("\n")[0]
+    if not line:
+        return None
+
+    if manager == PackageManager.APT:
+        # dpkg -S output: "package: /path/to/file"
+        return line.split(":")[0].strip() or None
+    if manager == PackageManager.PACMAN:
+        # pacman -Qo output: "/path is owned by package version"
+        parts = line.split("is owned by")
+        if len(parts) > 1:
+            return parts[1].strip().rsplit(" ", 1)[0] or None
+        return None
+    # rpm -qf (dnf/yum/zypper): "package-version-release.arch"
+    # qfile -qC (emerge): "category/package"
+    # pkg which -q (FreeBSD): "package-name"
+    return line.strip() or None
+
+
+def query_package_owner(
+    binary_path: str,
+) -> tuple:
+    """Identify the system package that owns a binary path.
+
+    Returns (package_name, remove_command_str) or (None, None).
+    """
+    mgr = detect_package_manager()
+    if not mgr or not mgr.query_owner_command or not mgr.remove_command:
+        return None, None
+
+    # brew which-formula takes the command name, not the full path.
+    query_arg = (
+        os.path.basename(binary_path)
+        if mgr.manager == PackageManager.HOMEBREW
+        else binary_path
+    )
+
+    try:
+        proc = subprocess.run(
+            [*mgr.query_owner_command, query_arg],
+            capture_output=True,
+            text=True,
+            timeout=10,
+            check=False,
+            stdin=subprocess.DEVNULL,
+        )
+        if proc.returncode != 0 or not proc.stdout.strip():
+            return None, None
+    except Exception:
+        return None, None
+
+    package = _parse_package_name(mgr.manager, proc.stdout)
+    if not package:
+        return None, None
+
+    remove_cmd = " ".join([*mgr.remove_command, package])
+    return package, remove_cmd

{code_aide-1.12.3 → code_aide-1.14.0}/src/code_aide/prereqs.py

@@ -6,7 +6,7 @@ import subprocess
 import sys
 from typing import List, Optional
 
-from code_aide.constants import PACKAGE_MANAGERS, TOOLS
+from code_aide.constants import TOOLS
 from code_aide.console import (
     command_exists,
     error,
@@ -15,42 +15,38 @@ from code_aide.console import (
     success,
     warning,
 )
+from code_aide.package_managers import (
+    _MANAGERS,
+    detect_package_manager,
+)
 
 
-def detect_package_manager() -> Optional[str]:
-    """Detect the Linux distribution and return package manager name."""
-    if platform.system() not in ("Linux", "FreeBSD"):
-        return None
-
-    for pkg_mgr_name, config in PACKAGE_MANAGERS.items():
-        if command_exists(config["detect_command"]):
-            return pkg_mgr_name
-
-    return None
+def _print_all_install_hints() -> None:
+    """Print install commands for all known package managers."""
+    for mgr in _MANAGERS:
+        install_cmd = " ".join(mgr.install_command + mgr.packages)
+        print(f"  {mgr.description}: {install_cmd}")
+    print("  Or visit: https://nodejs.org/")
 
 
 def install_nodejs_npm() -> bool:
     """Install Node.js and npm using the system package manager."""
-    pkg_mgr_name = detect_package_manager()
+    mgr = detect_package_manager()
 
-    if not pkg_mgr_name:
+    if not mgr:
         error("Could not detect package manager. Please install Node.js manually:")
-        for manager_name, config in PACKAGE_MANAGERS.items():
-            install_cmd = " ".join(config["install_command"] + config["packages"])
-            print(f"  {config['description']}: {install_cmd}")
-        print("  Or visit: https://nodejs.org/")
+        _print_all_install_hints()
         return False
 
-    config = PACKAGE_MANAGERS[pkg_mgr_name]
-    info(f"Detected package manager: {pkg_mgr_name} ({config['description']})")
+    info(f"Detected package manager: {mgr.detect_command} ({mgr.description})")
     info("Installing Node.js and npm...")
 
     try:
-        for pre_cmd in config["pre_install"]:
+        for pre_cmd in mgr.pre_install:
             info(f"Running: {' '.join(pre_cmd)}")
-            run_command(pre_cmd, check=True, capture=False)
+            run_command(list(pre_cmd), check=True, capture=False)
 
-        install_cmd = config["install_command"] + config["packages"]
+        install_cmd = list(mgr.install_command) + list(mgr.packages)
         run_command(install_cmd, check=True, capture=False)
 
         if not command_exists("npm"):
@@ -102,12 +98,7 @@ def check_prerequisites(
             else:
                 error("npm is required but not installed.")
                 error("Please install Node.js and npm first:")
-                for manager_name, config in PACKAGE_MANAGERS.items():
-                    install_cmd = " ".join(
-                        config["install_command"] + config["packages"]
-                    )
-                    print(f"  {config['description']}: {install_cmd}")
-                print("  Or visit: https://nodejs.org/")
+                _print_all_install_hints()
                 print("\nOr use -p/--install-prerequisites to install automatically")
                 sys.exit(1)
 

{code_aide-1.12.3 → code_aide-1.14.0}/tests/test_commands_tools.py

@@ -26,7 +26,7 @@ class TestCmdList(unittest.TestCase):
             mock.patch.object(commands_tools, "is_tool_installed", return_value=False),
             mock.patch.object(commands_tools, "command_exists", return_value=False),
             mock.patch.object(
-                commands_tools, "detect_package_manager", return_value=None
+                commands_tools, "_detect_package_manager", return_value=None
             ),
         ):
             buf = io.StringIO()
@@ -314,7 +314,7 @@ class TestCmdStatus(unittest.TestCase):
             ),
             mock.patch.object(commands_tools, "command_exists", return_value=False),
             mock.patch.object(
-                commands_tools, "detect_package_manager", return_value=None
+                commands_tools, "_detect_package_manager", return_value=None
             ),
         ):
             buf = io.StringIO()

{code_aide-1.12.3 → code_aide-1.14.0}/tests/test_install.py

@@ -148,6 +148,67 @@ class TestExtractTarMember(unittest.TestCase):
             self.assertTrue(os.path.exists(extracted))
 
 
+class TestInstallScriptEnv(unittest.TestCase):
+    """Tests for install script environment handling."""
+
+    def test_no_env_without_path_prepend(self):
+        self.assertIsNone(cli_install.get_install_script_env({}))
+
+    def test_prepends_expanded_paths(self):
+        with tempfile.TemporaryDirectory() as td:
+            with mock.patch.dict(
+                os.environ,
+                {"HOME": td, "PATH": "/usr/bin"},
+                clear=True,
+            ):
+                env = cli_install.get_install_script_env(
+                    {"install_script_path_prepend": ["~/.local/bin"]}
+                )
+
+        self.assertIsNotNone(env)
+        self.assertEqual(
+            env["PATH"],
+            os.path.join(td, ".local", "bin") + os.pathsep + "/usr/bin",
+        )
+
+    def test_path_prepend_without_existing_path(self):
+        with tempfile.TemporaryDirectory() as td:
+            with mock.patch.dict(os.environ, {"HOME": td}, clear=True):
+                env = cli_install.get_install_script_env(
+                    {"install_script_path_prepend": ["~/.local/bin"]}
+                )
+
+        self.assertIsNotNone(env)
+        self.assertEqual(env["PATH"], os.path.join(td, ".local", "bin"))
+
+    @mock.patch.object(cli_install, "fetch_url")
+    @mock.patch.object(cli_install.subprocess, "Popen")
+    def test_run_install_script_passes_env_to_bash(self, mock_popen, mock_fetch):
+        script_content = b"#!/usr/bin/env bash\n"
+        expected_sha256 = cli_install.hashlib.sha256(script_content).hexdigest()
+        process = mock.Mock()
+        process.communicate.return_value = (b"", b"")
+        process.returncode = 0
+        mock_popen.return_value = process
+        mock_fetch.return_value = (script_content, None)
+        env = {"PATH": "/tmp/bin:/usr/bin"}
+
+        result = cli_install.run_install_script(
+            "https://example.com/install.sh",
+            "Example",
+            expected_sha256,
+            env=env,
+        )
+
+        self.assertTrue(result)
+        mock_popen.assert_called_once_with(
+            ["bash"],
+            stdin=cli_install.subprocess.PIPE,
+            stderr=cli_install.subprocess.PIPE,
+            env=env,
+        )
+
+
 class TestInstallDirectDownloadDryrun(unittest.TestCase):
     """Tests for install_direct_download in dryrun mode."""
 
@@ -270,3 +331,38 @@ class TestInstallTool(unittest.TestCase):
             "/usr/local/bin/test-tool"
         )
         mock_info.assert_any_call("[DRYRUN] Would install npm package: test-tool")
+
+    def test_script_install_passes_configured_env(self):
+        tool_config = {
+            "name": "Test Tool",
+            "command": "test-tool",
+            "install_type": "script",
+            "install_url": "https://example.com/install.sh",
+            "install_sha256": "abc123",
+            "install_script_path_prepend": ["~/.local/bin"],
+            "next_steps": "Run test-tool",
+        }
+        env = {"PATH": "/tmp/bin:/usr/bin"}
+
+        with (
+            mock.patch.dict(cli_install.TOOLS, {"test": tool_config}, clear=True),
+            mock.patch.object(cli_install, "command_exists", return_value=False),
+            mock.patch.object(cli_install.platform, "system", return_value="Darwin"),
+            mock.patch.object(
+                cli_install, "get_install_script_env", return_value=env
+            ) as mock_env,
+            mock.patch.object(
+                cli_install, "run_install_script", return_value=True
+            ) as mock_script,
+        ):
+            result = cli_install.install_tool("test")
+
+        self.assertTrue(result)
+        mock_env.assert_called_once_with(tool_config)
+        mock_script.assert_called_once_with(
+            "https://example.com/install.sh",
+            "Test Tool",
+            "abc123",
+            False,
+            env=env,
+        )

{code_aide-1.12.3 → code_aide-1.14.0}/tests/test_operations.py

@@ -244,6 +244,65 @@ class TestMigrateInstallMethod(unittest.TestCase):
         mock_dd.assert_called_once_with("cursor", tool_config)
         mock_script.assert_not_called()
 
+    def test_upgrade_script_passes_configured_env(self):
+        """Script upgrades pass per-tool install environment overrides."""
+        tool_config = {
+            "name": "Amp (Sourcegraph)",
+            "command": "amp",
+            "install_type": "script",
+            "install_url": "https://ampcode.com/install.sh",
+            "install_sha256": "abc123",
+            "install_script_path_prepend": ["~/.local/bin"],
+        }
+        env = {"PATH": "/tmp/bin:/usr/bin"}
+        with (
+            mock.patch.dict(cli_operations.TOOLS, {"amp": 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",
+                side_effect=[
+                    {"method": "script", "detail": "native installer"},
+                    {"method": "script", "detail": "native installer"},
+                ],
+            ),
+            mock.patch.object(
+                cli_operations, "get_install_script_env", return_value=env
+            ) as mock_env,
+            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("amp")
+
+        self.assertEqual(result, UpgradeResult.CHANGED)
+        mock_env.assert_called_once_with(tool_config)
+        mock_script.assert_called_once_with(
+            "https://ampcode.com/install.sh",
+            "Amp (Sourcegraph)",
+            "abc123",
+            env=env,
+        )
+
     def test_migration_fails_on_remove(self):
         """Migration fails if remove_tool returns False."""
         tool_config = {

code_aide-1.14.0/tests/test_package_managers.py

@@ -0,0 +1,277 @@
+"""Unit tests for the package_managers module."""
+
+import subprocess
+import unittest
+from unittest import mock
+
+from code_aide.package_managers import (
+    PACKAGE_MANAGER_BY_ENUM,
+    PackageManager,
+    _MANAGERS,
+    _parse_package_name,
+    detect_package_manager,
+    query_package_owner,
+)
+
+
+class TestPackageManagerEnum(unittest.TestCase):
+    """Tests for the PackageManager enum."""
+
+    def test_all_managers_have_entries(self):
+        for mgr in PackageManager:
+            self.assertIn(mgr, PACKAGE_MANAGER_BY_ENUM)
+
+    def test_manager_list_matches_enum(self):
+        managers_in_list = {info.manager for info in _MANAGERS}
+        self.assertEqual(managers_in_list, set(PackageManager))
+
+    def test_no_duplicate_detect_commands(self):
+        commands = [info.detect_command for info in _MANAGERS]
+        self.assertEqual(len(commands), len(set(commands)))
+
+
+class TestPackageManagerInfo(unittest.TestCase):
+    """Tests for PackageManagerInfo completeness."""
+
+    def test_all_managers_have_install_command(self):
+        for info in _MANAGERS:
+            self.assertTrue(
+                len(info.install_command) > 0,
+                f"{info.manager.name} missing install_command",
+            )
+
+    def test_all_managers_have_query_owner_command(self):
+        for info in _MANAGERS:
+            self.assertTrue(
+                len(info.query_owner_command) > 0,
+                f"{info.manager.name} missing query_owner_command",
+            )
+
+    def test_all_managers_have_remove_command(self):
+        for info in _MANAGERS:
+            self.assertTrue(
+                len(info.remove_command) > 0,
+                f"{info.manager.name} missing remove_command",
+            )
+
+    def test_all_managers_have_description(self):
+        for info in _MANAGERS:
+            self.assertTrue(
+                len(info.description) > 0,
+                f"{info.manager.name} missing description",
+            )
+
+    def test_all_managers_have_packages(self):
+        for info in _MANAGERS:
+            self.assertTrue(
+                len(info.packages) > 0,
+                f"{info.manager.name} missing packages",
+            )
+
+    def test_info_is_frozen(self):
+        info = PACKAGE_MANAGER_BY_ENUM[PackageManager.APT]
+        with self.assertRaises(AttributeError):
+            info.description = "changed"
+
+
+class TestDetectPackageManager(unittest.TestCase):
+    """Tests for detect_package_manager."""
+
+    @mock.patch("code_aide.package_managers.platform.system", return_value="Windows")
+    def test_returns_none_on_windows(self, _mock_sys):
+        self.assertIsNone(detect_package_manager())
+
+    @mock.patch("code_aide.package_managers.shutil.which", return_value=None)
+    @mock.patch("code_aide.package_managers.platform.system", return_value="Linux")
+    def test_returns_none_when_no_manager_found(self, _mock_sys, _mock_which):
+        self.assertIsNone(detect_package_manager())
+
+    @mock.patch("code_aide.package_managers.shutil.which")
+    @mock.patch("code_aide.package_managers.platform.system", return_value="Linux")
+    def test_detects_apt(self, _mock_sys, mock_which):
+        mock_which.side_effect = lambda cmd: (
+            "/usr/bin/apt-get" if cmd == "apt-get" else None
+        )
+        result = detect_package_manager()
+        self.assertIsNotNone(result)
+        self.assertEqual(result.manager, PackageManager.APT)
+
+    @mock.patch("code_aide.package_managers.shutil.which")
+    @mock.patch("code_aide.package_managers.platform.system", return_value="Linux")
+    def test_detects_emerge(self, _mock_sys, mock_which):
+        mock_which.side_effect = lambda cmd: (
+            "/usr/bin/emerge" if cmd == "emerge" else None
+        )
+        result = detect_package_manager()
+        self.assertIsNotNone(result)
+        self.assertEqual(result.manager, PackageManager.EMERGE)
+
+    @mock.patch("code_aide.package_managers.shutil.which")
+    @mock.patch("code_aide.package_managers.platform.system", return_value="FreeBSD")
+    def test_detects_pkg_on_freebsd(self, _mock_sys, mock_which):
+        mock_which.side_effect = lambda cmd: "/usr/sbin/pkg" if cmd == "pkg" else None
+        result = detect_package_manager()
+        self.assertIsNotNone(result)
+        self.assertEqual(result.manager, PackageManager.PKG)
+
+    @mock.patch("code_aide.package_managers.shutil.which")
+    @mock.patch("code_aide.package_managers.platform.system", return_value="Darwin")
+    def test_detects_brew_on_macos(self, _mock_sys, mock_which):
+        mock_which.side_effect = lambda cmd: (
+            "/opt/homebrew/bin/brew" if cmd == "brew" else None
+        )
+        result = detect_package_manager()
+        self.assertIsNotNone(result)
+        self.assertEqual(result.manager, PackageManager.HOMEBREW)
+
+    @mock.patch("code_aide.package_managers.shutil.which")
+    @mock.patch("code_aide.package_managers.platform.system", return_value="Linux")
+    def test_returns_first_match(self, _mock_sys, mock_which):
+        # apt-get is first in the list
+        mock_which.side_effect = lambda cmd: f"/usr/bin/{cmd}"
+        result = detect_package_manager()
+        self.assertEqual(result.manager, PackageManager.APT)
+
+
+class TestParsePackageName(unittest.TestCase):
+    """Tests for _parse_package_name output parsing."""
+
+    def test_apt_dpkg_output(self):
+        self.assertEqual(
+            _parse_package_name(PackageManager.APT, "libfoo:amd64: /usr/lib/libfoo.so"),
+            "libfoo",
+        )
+
+    def test_apt_simple_output(self):
+        self.assertEqual(
+            _parse_package_name(PackageManager.APT, "claude-code: /usr/bin/claude"),
+            "claude-code",
+        )
+
+    def test_dnf_rpm_output(self):
+        self.assertEqual(
+            _parse_package_name(PackageManager.DNF, "claude-code-2.1.50-1.x86_64"),
+            "claude-code-2.1.50-1.x86_64",
+        )
+
+    def test_pacman_output(self):
+        self.assertEqual(
+            _parse_package_name(
+                PackageManager.PACMAN,
+                "/usr/bin/claude is owned by claude-code 2.1.50",
+            ),
+            "claude-code",
+        )
+
+    def test_pacman_no_match(self):
+        self.assertIsNone(
+            _parse_package_name(PackageManager.PACMAN, "error: no package"),
+        )
+
+    def test_emerge_output(self):
+        self.assertEqual(
+            _parse_package_name(PackageManager.EMERGE, "dev-util/claude-code"),
+            "dev-util/claude-code",
+        )
+
+    def test_pkg_output(self):
+        self.assertEqual(
+            _parse_package_name(PackageManager.PKG, "claude-code-2.1.50"),
+            "claude-code-2.1.50",
+        )
+
+    def test_brew_output(self):
+        self.assertEqual(
+            _parse_package_name(PackageManager.HOMEBREW, "gemini-cli"),
+            "gemini-cli",
+        )
+
+    def test_empty_output(self):
+        self.assertIsNone(_parse_package_name(PackageManager.APT, ""))
+        self.assertIsNone(_parse_package_name(PackageManager.APT, "\n"))
+
+    def test_multiline_takes_first(self):
+        self.assertEqual(
+            _parse_package_name(PackageManager.EMERGE, "dev-util/foo\ndev-util/bar"),
+            "dev-util/foo",
+        )
+
+
+class TestQueryPackageOwner(unittest.TestCase):
+    """Tests for query_package_owner."""
+
+    @mock.patch("code_aide.package_managers.detect_package_manager", return_value=None)
+    def test_returns_none_when_no_manager(self, _mock):
+        pkg, cmd = query_package_owner("/usr/bin/example")
+        self.assertIsNone(pkg)
+        self.assertIsNone(cmd)
+
+    @mock.patch("code_aide.package_managers.subprocess.run")
+    @mock.patch("code_aide.package_managers.detect_package_manager")
+    def test_emerge_query(self, mock_detect, mock_run):
+        mock_detect.return_value = PACKAGE_MANAGER_BY_ENUM[PackageManager.EMERGE]
+        mock_run.return_value = subprocess.CompletedProcess(
+            args=[], returncode=0, stdout="dev-util/claude-code\n"
+        )
+        pkg, cmd = query_package_owner("/opt/bin/claude")
+        self.assertEqual(pkg, "dev-util/claude-code")
+        self.assertEqual(cmd, "sudo emerge --unmerge dev-util/claude-code")
+        mock_run.assert_called_once_with(
+            ["qfile", "-qC", "/opt/bin/claude"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+            check=False,
+            stdin=subprocess.DEVNULL,
+        )
+
+    @mock.patch("code_aide.package_managers.subprocess.run")
+    @mock.patch("code_aide.package_managers.detect_package_manager")
+    def test_apt_query(self, mock_detect, mock_run):
+        mock_detect.return_value = PACKAGE_MANAGER_BY_ENUM[PackageManager.APT]
+        mock_run.return_value = subprocess.CompletedProcess(
+            args=[], returncode=0, stdout="claude-code: /usr/bin/claude\n"
+        )
+        pkg, cmd = query_package_owner("/usr/bin/claude")
+        self.assertEqual(pkg, "claude-code")
+        self.assertEqual(cmd, "sudo apt-get remove claude-code")
+
+    @mock.patch("code_aide.package_managers.subprocess.run")
+    @mock.patch("code_aide.package_managers.detect_package_manager")
+    def test_brew_uses_basename(self, mock_detect, mock_run):
+        mock_detect.return_value = PACKAGE_MANAGER_BY_ENUM[PackageManager.HOMEBREW]
+        mock_run.return_value = subprocess.CompletedProcess(
+            args=[], returncode=0, stdout="gemini-cli\n"
+        )
+        pkg, cmd = query_package_owner("/opt/homebrew/bin/gemini")
+        self.assertEqual(pkg, "gemini-cli")
+        self.assertEqual(cmd, "brew uninstall gemini-cli")
+        # Verify basename was passed, not full path
+        mock_run.assert_called_once_with(
+            ["brew", "which-formula", "gemini"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+            check=False,
+            stdin=subprocess.DEVNULL,
+        )
+
+    @mock.patch("code_aide.package_managers.subprocess.run")
+    @mock.patch("code_aide.package_managers.detect_package_manager")
+    def test_returns_none_on_query_failure(self, mock_detect, mock_run):
+        mock_detect.return_value = PACKAGE_MANAGER_BY_ENUM[PackageManager.APT]
+        mock_run.return_value = subprocess.CompletedProcess(
+            args=[], returncode=1, stdout=""
+        )
+        pkg, cmd = query_package_owner("/usr/bin/example")
+        self.assertIsNone(pkg)
+        self.assertIsNone(cmd)
+
+    @mock.patch("code_aide.package_managers.subprocess.run")
+    @mock.patch("code_aide.package_managers.detect_package_manager")
+    def test_returns_none_on_exception(self, mock_detect, mock_run):
+        mock_detect.return_value = PACKAGE_MANAGER_BY_ENUM[PackageManager.APT]
+        mock_run.side_effect = OSError("timeout")
+        pkg, cmd = query_package_owner("/usr/bin/example")
+        self.assertIsNone(pkg)
+        self.assertIsNone(cmd)

code_aide-1.12.3/src/code_aide/constants.py

@@ -1,104 +0,0 @@
-"""Shared constants and mutable tool configuration for CLI modules."""
-
-import os
-import sys
-from typing import Any, Dict
-
-from code_aide.config import load_tools_config
-
-
-def _use_color() -> bool:
-    """Determine whether to emit ANSI color codes.
-
-    Checks (in priority order):
-      NO_COLOR          — if set (any value), no color (https://no-color.org/)
-      FORCE_COLOR       — if set (any value), force color
-      CLICOLOR_FORCE    — if non-empty, force color
-      TERM=dumb         — no color
-      CLICOLOR=0        — no color
-      stdout is not a TTY — no color
-    """
-    if os.environ.get("NO_COLOR") is not None:
-        return False
-    if os.environ.get("FORCE_COLOR") is not None:
-        return True
-    if os.environ.get("CLICOLOR_FORCE", ""):
-        return True
-    if os.environ.get("TERM") == "dumb":
-        return False
-    if os.environ.get("CLICOLOR") == "0":
-        return False
-    return sys.stdout.isatty()
-
-
-class Colors:
-    if _use_color():
-        RED = "\033[0;31m"
-        GREEN = "\033[0;32m"
-        YELLOW = "\033[1;33m"
-        BLUE = "\033[0;34m"
-        BOLD = "\033[1m"
-        NC = "\033[0m"
-    else:
-        RED = ""
-        GREEN = ""
-        YELLOW = ""
-        BLUE = ""
-        BOLD = ""
-        NC = ""
-
-
-PACKAGE_MANAGERS: Dict[str, Dict[str, Any]] = {
-    "apt-get": {
-        "detect_command": "apt-get",
-        "packages": ["nodejs", "npm"],
-        "pre_install": [["sudo", "apt-get", "update"]],
-        "install_command": ["sudo", "apt-get", "install", "-y"],
-        "description": "Debian/Ubuntu",
-    },
-    "dnf": {
-        "detect_command": "dnf",
-        "packages": ["nodejs", "npm"],
-        "pre_install": [],
-        "install_command": ["sudo", "dnf", "install", "-y"],
-        "description": "Fedora/RHEL 8+",
-    },
-    "yum": {
-        "detect_command": "yum",
-        "packages": ["nodejs", "npm"],
-        "pre_install": [],
-        "install_command": ["sudo", "yum", "install", "-y"],
-        "description": "RHEL/CentOS 7",
-    },
-    "pacman": {
-        "detect_command": "pacman",
-        "packages": ["nodejs", "npm"],
-        "pre_install": [],
-        "install_command": ["sudo", "pacman", "-S", "--noconfirm"],
-        "description": "Arch Linux",
-    },
-    "zypper": {
-        "detect_command": "zypper",
-        "packages": ["nodejs", "npm"],
-        "pre_install": [],
-        "install_command": ["sudo", "zypper", "install", "-y"],
-        "description": "openSUSE",
-    },
-    "emerge": {
-        "detect_command": "emerge",
-        "packages": ["net-libs/nodejs"],
-        "pre_install": [],
-        "install_command": ["sudo", "emerge", "--quiet-build"],
-        "description": "Gentoo",
-    },
-    "pkg": {
-        "detect_command": "pkg",
-        "packages": ["node22", "npm-node22"],
-        "pre_install": [],
-        "install_command": ["sudo", "pkg", "install", "-y"],
-        "description": "FreeBSD",
-    },
-}
-
-
-TOOLS: Dict[str, Dict[str, Any]] = load_tools_config()