code-aide 1.12.2__tar.gz → 1.13.0__tar.gz

{code_aide-1.12.2 → code_aide-1.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-aide
-Version: 1.12.2
+Version: 1.13.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.2 → code_aide-1.13.0}/src/code_aide/__init__.py

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

{code_aide-1.12.2 → code_aide-1.13.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.12.2 → code_aide-1.13.0}/src/code_aide/config.py

@@ -135,15 +135,27 @@ def save_updated_versions(tools: dict) -> None:
     save_versions_cache(cache_data)
 
 
-def versions_cache_is_fresh() -> bool:
-    """Return True if the versions cache exists and is less than 24h old."""
+def versions_cache_is_fresh(tools: dict) -> bool:
+    """Return True if the versions cache exists, is recent, and complete."""
     cache_path = get_versions_cache_path()
     try:
         age = time.time() - os.path.getmtime(cache_path)
-        return age < CACHE_MAX_AGE_SECONDS
+        if age >= CACHE_MAX_AGE_SECONDS:
+            return False
     except OSError:
         return False
 
+    # Check that every versionable tool has latest_version populated.
+    for tool_config in tools.values():
+        install_type = parse_install_type(tool_config.get("install_type"))
+        if install_type == InstallType.NPM:
+            if not tool_config.get("latest_version"):
+                return False
+        elif install_type in (InstallType.SCRIPT, InstallType.DIRECT_DOWNLOAD):
+            if tool_config.get("version_url") and not tool_config.get("latest_version"):
+                return False
+    return True
+
 
 def refresh_versions_cache(tools: dict) -> None:
     """Fetch latest versions from upstream and update tools dict in-place.
@@ -187,6 +199,6 @@ def refresh_versions_cache(tools: dict) -> None:
 
 
 def ensure_versions_cache(tools: dict) -> None:
-    """Refresh versions cache if missing or stale, updating tools in-place."""
-    if not versions_cache_is_fresh():
+    """Refresh versions cache if missing, stale, or incomplete."""
+    if not versions_cache_is_fresh(tools):
         refresh_versions_cache(tools)

code_aide-1.13.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.2 → code_aide-1.13.0}/src/code_aide/operations.py

@@ -14,6 +14,7 @@ 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 (
     install_direct_download,
     install_tool,
@@ -83,6 +84,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 +168,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
 
 

code_aide-1.13.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.2 → code_aide-1.13.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.2 → code_aide-1.13.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.13.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.2/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()