code-aide 1.15.6__tar.gz → 1.15.7__tar.gz

{code_aide-1.15.6 → code_aide-1.15.7}/PKG-INFO

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

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

{code_aide-1.15.6 → code_aide-1.15.7}/src/code_aide/commands_actions.py

@@ -73,6 +73,7 @@ def cmd_install(args: argparse.Namespace) -> None:
         )
 
     installed = []
+    installed_bin_dirs = []
     failed = []
 
     for tool in tools_to_install:
@@ -82,8 +83,10 @@ def cmd_install(args: argparse.Namespace) -> None:
         else:
             info(f"=== Installing {tool} ===")
 
-        if install_tool(tool, dryrun=dryrun):
+        outcome = install_tool(tool, dryrun=dryrun)
+        if outcome:
             installed.append(tool)
+            installed_bin_dirs.extend(outcome.bin_dirs)
         else:
             failed.append(tool)
 
@@ -120,7 +123,7 @@ def cmd_install(args: argparse.Namespace) -> None:
                 print(f"  {tool_config['next_steps']}")
 
         print()
-        check_path_directories(installed)
+        check_path_directories(installed_bin_dirs)
         success("All installations completed successfully!")
 
 

{code_aide-1.15.6 → code_aide-1.15.7}/src/code_aide/install.py

@@ -8,6 +8,7 @@ import shutil
 import subprocess
 import tarfile
 import tempfile
+from dataclasses import dataclass
 from typing import Any, Dict, Optional
 
 from code_aide.constants import TOOLS
@@ -18,6 +19,29 @@ from code_aide.versions import check_script_tool, fetch_url
 DOWNLOAD_TIMEOUT_SECONDS = 120
 
 
+@dataclass(frozen=True)
+class InstallOutcome:
+    """Result of an install, including directories that may need PATH setup."""
+
+    succeeded: bool
+    bin_dirs: tuple[str, ...] = ()
+
+    def __bool__(self) -> bool:
+        return self.succeeded
+
+
+def get_npm_global_bin_dir() -> Optional[str]:
+    """Return the directory where the active npm installs global executables."""
+    try:
+        prefix = run_command(["npm", "prefix", "--global"]).stdout.strip()
+    except (OSError, subprocess.CalledProcessError):
+        return None
+
+    if not prefix:
+        return None
+    return os.path.join(prefix, "bin")
+
+
 def run_pkg_command(
     base_cmd: list,
     pkg_name: str,
@@ -265,12 +289,14 @@ def install_direct_download(
         return False
 
 
-def install_tool(tool_name: str, dryrun: bool = False, force: bool = False) -> bool:
+def install_tool(
+    tool_name: str, dryrun: bool = False, force: bool = False
+) -> InstallOutcome:
     """Install a tool based on its configuration."""
     tool_config = TOOLS.get(tool_name)
     if not tool_config:
         error(f"Unknown tool: {tool_name}")
-        return False
+        return InstallOutcome(False)
 
     if dryrun:
         info(f"[DRYRUN] Checking {tool_config['name']}...")
@@ -283,7 +309,7 @@ def install_tool(tool_name: str, dryrun: bool = False, force: bool = False) -> b
             info(f"{tool_config['command']} already installed at {tool_path}")
         else:
             warning(f"{tool_config['command']} already installed at {tool_path}")
-        return True
+        return InstallOutcome(True)
     if command_exists(tool_config["command"]) and force:
         tool_path = shutil.which(tool_config["command"])
         if dryrun:
@@ -301,7 +327,7 @@ def install_tool(tool_name: str, dryrun: bool = False, force: bool = False) -> b
         freebsd_port = tool_config.get("freebsd_port")
         if not freebsd_port:
             error(f"{tool_config['name']} is not available on FreeBSD (no port exists)")
-            return False
+            return InstallOutcome(False)
         pkg_repo = tool_config.get("freebsd_pkg_repo")
         if dryrun:
             repo_flag = f" -r {pkg_repo}" if pkg_repo else ""
@@ -309,7 +335,7 @@ def install_tool(tool_name: str, dryrun: bool = False, force: bool = False) -> b
                 f"[DRYRUN] Would install FreeBSD port: "
                 f"pkg install{repo_flag} {freebsd_port}"
             )
-            return True
+            return InstallOutcome(True)
         try:
             run_pkg_command(
                 ["sudo", "pkg", "install", "-y"],
@@ -321,27 +347,32 @@ def install_tool(tool_name: str, dryrun: bool = False, force: bool = False) -> b
             info(tool_config["next_steps"])
             if "docs_url" in tool_config:
                 info(f"Documentation: {tool_config['docs_url']}")
-            return True
+            return InstallOutcome(True)
         except subprocess.CalledProcessError as exc:
             error(f"Failed to install {tool_config['name']}: {exc.stderr}")
-            return False
+            return InstallOutcome(False)
         except Exception as exc:
             error(f"Failed to install {tool_config['name']}: {exc}")
-            return False
+            return InstallOutcome(False)
 
     try:
         install_type = get_tool_install_type(tool_config)
 
         if install_type == InstallType.NPM:
             npm_package = tool_config["npm_package"]
+            bin_dirs = ()
             if dryrun:
                 info(f"[DRYRUN] Would install npm package: {npm_package}")
             else:
                 run_command(["npm", "install", "-g", npm_package], check=True)
+                npm_bin_dir = get_npm_global_bin_dir()
+                if npm_bin_dir:
+                    bin_dirs = (npm_bin_dir,)
                 success(f"{tool_config['name']} installed successfully")
                 info(tool_config["next_steps"])
                 if "docs_url" in tool_config:
                     info(f"Documentation: {tool_config['docs_url']}")
+            return InstallOutcome(True, bin_dirs)
 
         elif install_type == InstallType.SCRIPT:
             install_url = tool_config["install_url"]
@@ -361,7 +392,7 @@ def install_tool(tool_name: str, dryrun: bool = False, force: bool = False) -> b
                     if "docs_url" in tool_config:
                         info(f"Documentation: {tool_config['docs_url']}")
             else:
-                return False
+                return InstallOutcome(False)
 
         elif install_type == InstallType.DIRECT_DOWNLOAD:
             if install_direct_download(tool_name, tool_config, dryrun):
@@ -373,13 +404,18 @@ def install_tool(tool_name: str, dryrun: bool = False, force: bool = False) -> b
                     if "docs_url" in tool_config:
                         info(f"Documentation: {tool_config['docs_url']}")
             else:
-                return False
+                return InstallOutcome(False)
 
-        return True
+            if not dryrun and tool_config.get("bin_dir"):
+                return InstallOutcome(
+                    True, (os.path.expanduser(tool_config["bin_dir"]),)
+                )
+
+        return InstallOutcome(True)
 
     except subprocess.CalledProcessError as exc:
         error(f"Failed to install {tool_config['name']}: {exc.stderr}")
-        return False
+        return InstallOutcome(False)
     except Exception as exc:
         error(f"Failed to install {tool_config['name']}: {exc}")
-        return False
+        return InstallOutcome(False)

{code_aide-1.15.6 → code_aide-1.15.7}/src/code_aide/prereqs.py

@@ -149,28 +149,23 @@ def is_tool_installed(tool_name: str) -> bool:
     return command_exists(tool_config["command"])
 
 
-def check_path_directories(tools_installed: Optional[List[str]] = None) -> None:
+def check_path_directories(directories: Optional[List[str]] = None) -> None:
     """Check if binary installation directories are in PATH and warn if not.
 
-    When *tools_installed* is given, only directories relevant to those
-    tools are checked.  Otherwise a small set of common directories is used.
+    When *directories* is given, only those directories are checked. Otherwise
+    a small set of common directories is used.
     """
     current_path = os.environ.get("PATH", "")
     path_entries = current_path.split(os.pathsep)
 
-    if tools_installed:
+    if directories is not None:
         seen: set = set()
         dirs_to_check: List[str] = []
-        for tool_name in tools_installed:
-            tool_config = TOOLS.get(tool_name)
-            if not tool_config:
-                continue
-            bin_dir = tool_config.get("bin_dir")
-            if bin_dir:
-                expanded = os.path.expanduser(bin_dir)
-                if expanded not in seen:
-                    seen.add(expanded)
-                    dirs_to_check.append(expanded)
+        for directory in directories:
+            expanded = os.path.expanduser(directory)
+            if expanded not in seen:
+                seen.add(expanded)
+                dirs_to_check.append(expanded)
     else:
         dirs_to_check = [
             os.path.expanduser("~/.local/bin"),

{code_aide-1.15.6 → code_aide-1.15.7}/tests/test_commands_actions.py

@@ -8,6 +8,7 @@ from unittest import mock
 
 from code_aide import constants, commands_actions
 from code_aide import entry
+from code_aide.install import InstallOutcome
 from code_aide.operations import UpgradeResult
 
 
@@ -39,7 +40,7 @@ class TestCmdInstall(unittest.TestCase):
             mock.patch.dict(constants._TOOLS_DATA, tools, clear=True),
             mock.patch.object(commands_actions, "validate_tools"),
             mock.patch.object(
-                commands_actions, "install_tool", return_value=True
+                commands_actions, "install_tool", return_value=InstallOutcome(True)
             ) as mock_install_tool,
             mock.patch.object(commands_actions, "check_prerequisites") as mock_prereqs,
         ):
@@ -50,6 +51,38 @@ class TestCmdInstall(unittest.TestCase):
         mock_install_tool.assert_called_once_with("default_tool", dryrun=True)
         mock_prereqs.assert_not_called()
 
+    def test_checks_bin_directories_reported_by_installers(self):
+        tools = {
+            "test": {
+                "name": "Test Tool",
+                "command": "test",
+                "install_type": "npm",
+                "next_steps": "run test",
+            }
+        }
+        args = type(
+            "Args",
+            (),
+            {"tools": ["test"], "dryrun": False, "install_prerequisites": False},
+        )()
+
+        with (
+            mock.patch.dict(constants._TOOLS_DATA, tools, clear=True),
+            mock.patch.object(commands_actions, "validate_tools"),
+            mock.patch.object(commands_actions, "check_prerequisites"),
+            mock.patch.object(
+                commands_actions,
+                "install_tool",
+                return_value=InstallOutcome(True, ("/home/test/.npm-packages/bin",)),
+            ),
+            mock.patch.object(
+                commands_actions, "check_path_directories"
+            ) as mock_check_path,
+        ):
+            commands_actions.cmd_install(args)
+
+        mock_check_path.assert_called_once_with(["/home/test/.npm-packages/bin"])
+
 
 class TestCmdUpdateVersions(unittest.TestCase):
     """Tests for cmd_update_versions."""

{code_aide-1.15.6 → code_aide-1.15.7}/tests/test_install.py

@@ -286,6 +286,16 @@ class TestInstallDirectDownload(unittest.TestCase):
 class TestInstallTool(unittest.TestCase):
     """Tests for install_tool behavior."""
 
+    def test_get_npm_global_bin_dir_uses_active_prefix(self):
+        npm_prefix = mock.Mock(stdout="/home/test/.npm-packages\n")
+        with mock.patch.object(
+            cli_install, "run_command", return_value=npm_prefix
+        ) as mock_run:
+            result = cli_install.get_npm_global_bin_dir()
+
+        self.assertEqual(result, "/home/test/.npm-packages/bin")
+        mock_run.assert_called_once_with(["npm", "prefix", "--global"])
+
     def test_force_reinstalls_even_when_binary_exists(self):
         tool_config = {
             "name": "Test Tool",
@@ -301,11 +311,17 @@ class TestInstallTool(unittest.TestCase):
             mock.patch.object(
                 cli_install.shutil, "which", return_value="/usr/local/bin/test-tool"
             ),
+            mock.patch.object(
+                cli_install,
+                "get_npm_global_bin_dir",
+                return_value="/home/test/.npm-packages/bin",
+            ),
             mock.patch.object(cli_install, "run_command") as mock_run,
         ):
             result = cli_install.install_tool("test", force=True)
 
         self.assertTrue(result)
+        self.assertEqual(result.bin_dirs, ("/home/test/.npm-packages/bin",))
         mock_run.assert_called_once_with(
             ["npm", "install", "-g", "test-tool"], check=True
         )

{code_aide-1.15.6 → code_aide-1.15.7}/tests/test_prereqs.py

@@ -210,14 +210,12 @@ class TestCheckPathDirectories(unittest.TestCase):
     """Tests for check_path_directories."""
 
     def test_warns_when_existing_bin_dir_not_in_path(self):
-        tool_config = {"name": "Test", "command": "test", "bin_dir": "/custom/bin"}
         with (
-            mock.patch.dict(constants._TOOLS_DATA, {"test": tool_config}, clear=True),
             mock.patch.dict("os.environ", {"PATH": "/usr/bin"}, clear=False),
             mock.patch.object(cli_prereqs.os.path, "isdir", return_value=True),
             mock.patch("builtins.print") as mock_print,
         ):
-            cli_prereqs.check_path_directories(["test"])
+            cli_prereqs.check_path_directories(["/custom/bin"])
         # Should have printed at least the bin dir as a warning detail
         printed = " ".join(
             str(call.args[0]) for call in mock_print.call_args_list if call.args
@@ -225,27 +223,23 @@ class TestCheckPathDirectories(unittest.TestCase):
         self.assertIn("/custom/bin", printed)
 
     def test_silent_when_dir_already_in_path(self):
-        tool_config = {"name": "Test", "command": "test", "bin_dir": "/custom/bin"}
         with (
-            mock.patch.dict(constants._TOOLS_DATA, {"test": tool_config}, clear=True),
             mock.patch.dict(
                 "os.environ", {"PATH": "/custom/bin:/usr/bin"}, clear=False
             ),
             mock.patch.object(cli_prereqs.os.path, "isdir", return_value=True),
             mock.patch("builtins.print") as mock_print,
         ):
-            cli_prereqs.check_path_directories(["test"])
+            cli_prereqs.check_path_directories(["/custom/bin"])
         self.assertFalse(mock_print.called)
 
     def test_silent_when_bin_dir_does_not_exist(self):
-        tool_config = {"name": "Test", "command": "test", "bin_dir": "/missing/bin"}
         with (
-            mock.patch.dict(constants._TOOLS_DATA, {"test": tool_config}, clear=True),
             mock.patch.dict("os.environ", {"PATH": "/usr/bin"}, clear=False),
             mock.patch.object(cli_prereqs.os.path, "isdir", return_value=False),
             mock.patch("builtins.print") as mock_print,
         ):
-            cli_prereqs.check_path_directories(["test"])
+            cli_prereqs.check_path_directories(["/missing/bin"])
         self.assertFalse(mock_print.called)