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

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

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

@@ -8,40 +8,108 @@ AMP_STORAGE_BASE="${AMP_STORAGE_BASE:-https://static.ampcode.com}"
 AMP_URL="${AMP_URL:-https://ampcode.com}"
 AMP_VERSION="${AMP_VERSION:-}"
 
-# Colors for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m' # No Color
-
-# Cleanup on interrupt
-cleanup() {
-	echo -e "\n${YELLOW}Installation interrupted...${NC}"
-	rm -f "$AMP_HOME/amp-install-"* 2>/dev/null || true
-	rm -f "$BIN_DIR/tmp."* 2>/dev/null || true
-	exit 1
+if [[ -t 2 ]]; then
+	TTY_OUTPUT=1
+else
+	TTY_OUTPUT=0
+fi
+
+if [[ $TTY_OUTPUT -eq 1 && -z "${NO_COLOR:-}" ]] && command -v tput >/dev/null 2>&1; then
+	COLOR_COUNT="$(tput colors 2>/dev/null || printf '0')"
+else
+	COLOR_COUNT=0
+fi
+
+if [[ "$COLOR_COUNT" =~ ^[0-9]+$ && "$COLOR_COUNT" -ge 8 ]]; then
+	BOLD="$(tput bold 2>/dev/null || true)"
+	DIM="$(tput dim 2>/dev/null || true)"
+	RESET="$(tput sgr0 2>/dev/null || true)"
+	ACCENT="$(tput setaf 6 2>/dev/null || true)"
+	SUCCESS="$(tput setaf 2 2>/dev/null || true)"
+	WARNING="$(tput setaf 3 2>/dev/null || true)"
+	ERROR="$(tput setaf 1 2>/dev/null || true)"
+else
+	BOLD=''
+	DIM=''
+	RESET=''
+	ACCENT=''
+	SUCCESS=''
+	WARNING=''
+	ERROR=''
+fi
+
+case ":$TTY_OUTPUT:${LC_ALL:-${LC_CTYPE:-${LANG:-}}}" in
+	:1:*UTF-8* | :1:*utf8* | :1:*UTF8*)
+		ORB_LINES='      ·  ·  ·
+   ·  ◍  ●  ◍  ·
+  ·  ●  AMP  ●  ·
+   ·  ◍  ●  ◍  ·
+      ·  ·  ·'
+		STEP_GLYPH='·──◍'
+		SUCCESS_GLYPH='◍──·'
+		WARN_GLYPH='·─!'
+		ERROR_GLYPH='·─╳'
+		;;
+	*)
+		ORB_LINES='      .  .  .
+   .  o  O  o  .
+  .  O  AMP  O  .
+   .  o  O  o  .
+      .  .  .'
+		STEP_GLYPH='-->'
+		SUCCESS_GLYPH='<--'
+		WARN_GLYPH='!'
+		ERROR_GLYPH='x'
+		;;
+esac
+
+print_header() {
+	if [[ $TTY_OUTPUT -eq 1 ]]; then
+		printf '\n' >&2
+		printf '%s\n' "$ORB_LINES" | while IFS= read -r line; do
+			printf '%s%s%s\n' "$ACCENT" "$line" "$RESET" >&2
+		done
+		printf '\n%s%s%s\n' "$BOLD$ACCENT" 'AMP CLI INSTALLER' "$RESET" >&2
+		printf '%s%s%s\n\n' "$DIM" \
+			'Installs Amp into ~/.amp/bin and links it onto your PATH.' "$RESET" >&2
+	else
+		printf 'Amp CLI installer\n' >&2
+	fi
 }
 
-trap cleanup INT TERM
-
 log() {
-	echo -e "${BLUE}[INFO]${NC} $1" >&2
+	printf '%s%s%s  %s\n' "$ACCENT" "$STEP_GLYPH" "$RESET" "$1" >&2
 }
 
 warn() {
-	echo -e "${YELLOW}[WARN]${NC} $1" >&2
+	printf '%s%s%s  %s\n' "$WARNING" "$WARN_GLYPH" "$RESET" "$1" >&2
 }
 
 error() {
-	echo -e "${RED}[ERROR]${NC} $1" >&2
+	printf '%s%s%s  %b\n' "$ERROR" "$ERROR_GLYPH" "$RESET" "$1" >&2
 	exit 1
 }
 
 success() {
-	echo -e "${GREEN}[SUCCESS]${NC} $1" >&2
+	printf '%s%s%s  %s%s%s\n' "$SUCCESS" "$SUCCESS_GLYPH" "$RESET" \
+		"$BOLD" "$1" "$RESET" >&2
+}
+
+detail() {
+	printf '      %s%s%s\n' "$DIM" "$1" "$RESET" >&2
 }
 
+# Cleanup on interrupt
+cleanup() {
+	printf '\n' >&2
+	warn 'Installation interrupted'
+	rm -f "$AMP_HOME/amp-install-"* 2>/dev/null || true
+	rm -f "$BIN_DIR/tmp."* 2>/dev/null || true
+	exit 1
+}
+
+trap cleanup INT TERM
+
 # Check if command exists
 command_exists() {
 	command -v "$1" >/dev/null 2>&1
@@ -155,8 +223,9 @@ downloader() {
 download_file() {
 	local url="$1"
 	local output_file="$2"
+	local label="${3:-$(basename "$output_file")}"
 
-	log "Downloading $(basename "$output_file")..."
+	log "Downloading $label"
 
 	# Use secure temporary file
 	local temp_file
@@ -171,8 +240,9 @@ download_file() {
 download_gzipped_file() {
 	local url="$1"
 	local output_file="$2"
+	local label="${3:-$(basename "$output_file").gz}"
 
-	log "Downloading $(basename "$output_file").gz..."
+	log "Downloading $label"
 
 	local temp_gz_file
 	temp_gz_file=$(mktemp "$(dirname "$output_file")/tmp.XXXXXX.gz")
@@ -198,7 +268,7 @@ verify_checksum() {
 	local file="$1"
 	local expected_checksum="$2"
 
-	log "Verifying checksum..."
+	log "Verifying checksum"
 
 	local actual_checksum
 	actual_checksum=$($SHA256_CMD "$file" | cut -d' ' -f1)
@@ -223,8 +293,8 @@ verify_signature() {
 	local signature_path="$AMP_HOME/amp-install-signature.minisign"
 	local pubkey_path="$AMP_HOME/signing-key.pub"
 
-	download_file "$signature_url" "$signature_path"
-	download_file "$AMP_URL/.well-known/signing-key.pub" "$pubkey_path"
+	download_file "$signature_url" "$signature_path" 'signature'
+	download_file "$AMP_URL/.well-known/signing-key.pub" "$pubkey_path" 'signing key'
 
 	if ! minisign -Vm "$file" -x "$signature_path" -p "$pubkey_path" >/dev/null 2>&1; then
 		rm -f "$signature_path" "$pubkey_path"
@@ -240,7 +310,7 @@ fetch_latest_version() {
 	local version_url="$AMP_STORAGE_BASE/cli/cli-version.txt"
 	local version_path="$AMP_HOME/amp-install-version.txt"
 
-	download_file "$version_url" "$version_path"
+	download_file "$version_url" "$version_path" 'latest version'
 	cat "$version_path"
 	rm -f "$version_path"
 }
@@ -262,7 +332,7 @@ install_amp_binary() {
 	else
 		# Fetch version first to ensure consistent downloads (avoids race conditions
 		# where a new version is published mid-download)
-		log "Fetching latest version..."
+		log "Fetching latest version"
 		version=$(fetch_latest_version)
 		log "Installing version: $version"
 	fi
@@ -280,16 +350,16 @@ install_amp_binary() {
 	local checksum_path="$AMP_HOME/amp-install-checksum.txt"
 
 	# Download checksum first
-	download_file "$checksum_url" "$checksum_path"
+	download_file "$checksum_url" "$checksum_path" 'checksum'
 	local expected_checksum
 	expected_checksum=$(cat "$checksum_path")
 
 	if has_gzip_support; then
 		# Download compressed binary and verify the decompressed bytes against checksum
-		download_gzipped_file "${binary_url}.gz" "$binary_path"
+		download_gzipped_file "${binary_url}.gz" "$binary_path" 'Amp binary'
 	else
 		warn "gzip not found; downloading uncompressed binary"
-		download_file "$binary_url" "$binary_path"
+		download_file "$binary_url" "$binary_path" 'Amp binary'
 	fi
 
 	# Verify checksum
@@ -445,20 +515,20 @@ update_shell_profile() {
 
 	# Ask user before modifying shell config
 	local tilde_profile="${shell_profile/#$HOME/\~}"
-	echo ""
+	printf '\n'
 	if [[ -t 0 ]]; then
 		# Interactive: ask user
 		read -p "Add ~/.local/bin to your PATH in $tilde_profile? [y/n] " -n 1 -r
-		echo ""
+		printf '\n'
 		if [[ ! $REPLY =~ ^[Yy]$ ]]; then
 			log "Skipped modifying shell config."
 			log "To use amp, add ~/.local/bin to your PATH manually:"
-			echo "  $path_export"
+			printf '  %s\n' "$path_export"
 			return
 		fi
 	else
 		# Non-interactive: add automatically
-		log "Adding ~/.local/bin to PATH in $tilde_profile..."
+		log "Adding ~/.local/bin to PATH in $tilde_profile"
 	fi
 
 	# Create config file if it doesn't exist
@@ -475,16 +545,18 @@ update_shell_profile() {
 	} >> "$shell_profile"
 
 	success "Added ~/.local/bin to PATH in $tilde_profile"
-	echo ""
+	printf '\n'
 	log "To use amp immediately, run:"
-	echo "  $path_export"
+	printf '  %s\n' "$path_export"
 }
 
 # Main installation
 main() {
-	log "Starting Amp CLI binary installation..."
+	print_header
+	detail "Install directory: $BIN_DIR"
 
 	# Check prerequisites
+	log "Checking prerequisites"
 	check_prereqs
 
 	# Create directories
@@ -501,10 +573,9 @@ main() {
 	# Update shell profile
 	update_shell_profile
 
-	echo ""
-	success "Amp CLI installed successfully!"
-	log "Run 'amp --help' to get started"
-	log "Visit $AMP_URL for documentation"
+	success "Amp CLI installed"
+	detail "Run 'amp --help' to get started"
+	detail "Docs: $AMP_URL/manual"
 }
 
 main "$@"

{code_aide-1.15.5 → code_aide-1.15.7}/script-archive/claude-install.sh

@@ -155,11 +155,39 @@ chmod +x "$binary_path"
 
 # Run claude install to set up launcher and shell integration
 echo "Setting up Claude Code..."
-"$binary_path" install ${TARGET:+"$TARGET"}
+install_code=0
+"$binary_path" install ${TARGET:+"$TARGET"} || install_code=$?
 
 # Clean up downloaded file
 rm -f "$binary_path"
 
+if [ "$install_code" -ne 0 ]; then
+    # A signal death mid-install kills the binary's TUI with no chance to
+    # restore the terminal, leaving the user's shell in raw mode (typed
+    # characters stop echoing). Restore it before printing anything.
+    if [ "$install_code" -ge 128 ] && [ -t 0 ]; then
+        stty sane 2>/dev/null || true
+    fi
+    # Red when stderr is a terminal, so the explanation stands out from the
+    # surrounding install output; plain when piped or captured
+    red="" reset=""
+    if [ -t 2 ]; then
+        red=$'\033[31m'
+        reset=$'\033[0m'
+    fi
+    # Signal deaths (exit code 128+N) print nothing of their own — bash shows
+    # only e.g. "Killed". 137 = SIGKILL, which on Linux is almost always the
+    # kernel OOM killer on small hosts; macOS has no equivalent OOM kill, so
+    # the out-of-memory explanation is Linux-only.
+    if [ "$install_code" -eq 137 ] && [ "$os" = "linux" ]; then
+        echo "${red}Installation was killed before it could finish (exit code 137). This usually means the system ran out of memory.${reset}" >&2
+        echo "${red}Claude Code needs roughly 512MB of free memory to install. Free up memory, then run this script again.${reset}" >&2
+    elif [ "$install_code" -ge 128 ]; then
+        echo "${red}Installation was killed before it could finish (exit code $install_code).${reset}" >&2
+    fi
+    exit "$install_code"
+fi
+
 echo ""
 echo "✅ Installation complete!"
 echo ""

{code_aide-1.15.5 → code_aide-1.15.7}/src/code_aide/__init__.py

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

{code_aide-1.15.5 → 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.5 → code_aide-1.15.7}/src/code_aide/data/tools.json

@@ -28,7 +28,7 @@
       "command": "claude",
       "install_type": "script",
       "install_url": "https://claude.ai/install.sh",
-      "install_sha256": "005ec1a937f32dfbb74f9e810287bcb12cba2d5cae4c9277aa8c6364adbf1787",
+      "install_sha256": "b3f79015b54c751440a6488f07b1b64f9088742b9052bc1bd356d13108320d2a",
       "version_url": "https://storage.googleapis.com/claude-code-dist-86c565f3-f756-42ad-8dfa-d59b1c096819/claude-code-releases/latest",
       "prerequisites": [],
       "min_node_version": null,
@@ -64,7 +64,7 @@
       "command": "amp",
       "install_type": "script",
       "install_url": "https://ampcode.com/install.sh",
-      "install_sha256": "4526d2cacd0254cd8aafd3cd27705f088598a4e21b72a3cdca503d157779e7b7",
+      "install_sha256": "4ceab71af4f5a126d8ffe0e1af3b06f210be67eae93c8e4583793a52064fc2e2",
       "install_script_path_prepend": [
         "~/.local/bin"
       ],

{code_aide-1.15.5 → 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.5 → 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.5 → 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.5 → 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.5 → 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)