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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-aide
-Version: 1.6.0
+Version: 1.7.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
@@ -157,7 +157,8 @@ uv run pytest tests/test_install.py::TestDetectOsArch -v
    - Example: `Fixed timeout handling in status command`
 5. Tag and push:
    - `git tag vX.Y.Z`
-   - `git push origin main --follow-tags`
+   - `git push origin main`
+   - `git push origin vX.Y.Z`
 6. Confirm GitHub Actions:
    - CI should pass.
    - Publish workflow should upload to PyPI and create GitHub Release notes.

{code_aide-1.6.0 → code_aide-1.7.0}/README.md

@@ -131,7 +131,8 @@ uv run pytest tests/test_install.py::TestDetectOsArch -v
    - Example: `Fixed timeout handling in status command`
 5. Tag and push:
    - `git tag vX.Y.Z`
-   - `git push origin main --follow-tags`
+   - `git push origin main`
+   - `git push origin vX.Y.Z`
 6. Confirm GitHub Actions:
    - CI should pass.
    - Publish workflow should upload to PyPI and create GitHub Release notes.

{code_aide-1.6.0 → code_aide-1.7.0}/TODO.md

@@ -7,8 +7,8 @@ remove, status, and version metadata).
 
 - [x] Standardize `--dryrun` flag: `update-versions` uses `--dry-run` but
   `install` uses `--dryrun`. Change `update-versions` to `--dryrun`.
-- [x] Add missing `success()` message for direct-download installs in non-dryrun
-  mode (`install.py`, `install_tool()`).
+- [x] Add missing `success()` message for direct-download installs in
+  non-dryrun mode (`install.py`, `install_tool()`).
 - [x] Replace PID-based temp directory naming with `tempfile.mkdtemp()` in
   `install.py` `install_direct_download()`.
 - [x] Guard `package.split("/", 1)` in `detection.py`
@@ -18,21 +18,21 @@ remove, status, and version metadata).
 
 - [ ] Handle missing `node` cleanly during prerequisite checks
   (`FileNotFoundError` path in Node version probing).
-- [ ] Read tool version output from both stdout and stderr so status does not
-  miss installed versions.
+- [ ] Read tool version output from both stdout and stderr so status does
+  not miss installed versions.
 - [ ] Make version cache writes atomic (write temp file + rename) to avoid
-  partial/corrupted `versions.json`. Apply to `save_bundled_versions()` too.
-- [ ] Warn when `versions.json` cache contains invalid JSON instead of silently
-  returning empty data.
+  partial/corrupted `versions.json`.
+- [ ] Warn when `versions.json` cache contains invalid JSON instead of
+  silently returning empty data.
 - [ ] Use `os.pathsep` instead of hardcoded `":"` in `prereqs.py`
   `check_path_directories()`.
 
 ## Security and Integrity
 
-- [ ] Add integrity verification for direct-download tarballs (not only install
-  script SHA256).
-- [ ] Extend tool metadata to support tarball checksum/signature fields where
-  applicable.
+- [ ] Add integrity verification for direct-download tarballs (not only
+  install script SHA256).
+- [ ] Extend tool metadata to support tarball checksum/signature fields
+  where applicable.
 
 ## CLI and Automation UX
 
@@ -40,21 +40,23 @@ remove, status, and version metadata).
 - [ ] Add a focused `doctor` command for environment checks (PATH,
   prerequisites, command health).
 - [ ] Consider `install --force` for reinstall/repair flows.
-- [ ] Add cleanup support for stale direct-download versions no longer in use.
-- [ ] Expand `upgrade` help text to mention the default "only out-of-date tools"
-  behavior.
+- [ ] Add cleanup support for stale direct-download versions no longer in
+  use.
+- [ ] Expand `upgrade` help text to mention the default "only out-of-date
+  tools" behavior.
 
 ## Documentation
 
-- [ ] Document that running `code-aide` with no subcommand defaults to `status`.
+- [ ] Document that running `code-aide` with no subcommand defaults to
+  `status`.
 - [ ] Add `install --dryrun` to the README usage examples.
 - [ ] Document environment variables and config file paths
   (`~/.config/code-aide/versions.json`).
 
 ## Platform and Package Detection
 
-- [ ] Broaden system package metadata detection beyond Gentoo-specific tooling
-  where practical.
+- [ ] Broaden system package metadata detection beyond Gentoo-specific
+  tooling where practical.
 
 ## Maintainability and Tests
 
@@ -65,6 +67,5 @@ remove, status, and version metadata).
   - `cmd_remove()` (completely untested)
   - `fetch_url()` (completely untested)
   - `check_prerequisites()` / `install_nodejs_npm()` (completely untested)
-  - `save_bundled_versions()` (untested)
   - `get_system_package_info()` (completely untested)
 - [ ] Add tests for prerequisite edge cases and cache write behavior.

code_aide-1.7.0/specs/auto-migrate-deprecated-installs.md

@@ -0,0 +1,128 @@
+# Auto-migrate deprecated install methods
+
+## Context
+
+Claude Code switched from npm to a native installer. Users who installed
+Claude via npm are stuck: `code-aide upgrade` runs `npm install -g @latest`
+(the detected method) instead of the native script installer (the configured
+method). `code-aide install` exits early because the command already exists.
+There is no migration path. code-aide should detect this and fix it
+automatically.
+
+This is a general pattern -- any tool could change install methods in the
+future. The solution should not be Claude-specific.
+
+## Approach
+
+A detected install method is "deprecated" when:
+
+- Detected method is `npm` or `brew_npm` AND config `install_type` is
+  `script` or `direct_download`
+
+Methods that are never considered deprecated (user-managed choices):
+
+- `brew_formula`, `brew_cask` -- user explicitly chose Homebrew
+- `system` -- managed by system package manager
+
+Migration flow: remove old (npm), install new (configured method), with
+clear messaging. If the new install fails after removal, provide recovery
+instructions.
+
+## Changes
+
+### 1. `src/code_aide/data/tools.json` -- add deprecated_npm_package
+
+Add a `deprecated_npm_package` field to Claude's entry:
+
+```json
+"claude": {
+  "name": "Claude CLI (Claude Code)",
+  "install_type": "script",
+  "deprecated_npm_package": "@anthropic-ai/claude-code",
+  ...
+}
+```
+
+This records the old npm package name explicitly so the migration removal
+step does not rely solely on extracting the package name from the binary
+path.
+
+### 2. `src/code_aide/detection.py` -- add deprecation detection
+
+Add two functions:
+
+- `is_deprecated_install(tool_name)` -- returns True when the detected
+  install method is `npm` or `brew_npm` but the configured `install_type` is
+  something else (script, direct_download). Also returns True when
+  `deprecated_npm_package` is set and the detected method is npm. Brew
+  formula/cask and system installs are never deprecated (user-managed).
+- `format_migration_warning(tool_name)` -- returns a human-readable warning
+  string, or None if not deprecated. Uses existing `format_install_method()`
+  for labels.
+
+### 3. `src/code_aide/operations.py` -- auto-migrate in upgrade
+
+Add `_migrate_install_method()` private function that:
+
+1. Warns about the deprecated method
+2. Calls `remove_tool()` to remove the old npm install
+3. Calls `install_tool()` to install via the configured method
+4. If install fails after remove, prints recovery instructions (`code-aide
+   install <tool>` and manual curl command for script types)
+
+Modify `upgrade_tool()`: after `detect_install_method()`, check
+`is_deprecated_install()`. If True, call `_migrate_install_method()` instead
+of the normal upgrade branch.
+
+Modify `remove_tool()` npm branch: fall back to
+`tool_config.get("deprecated_npm_package")` when looking up the npm package
+name. Current code: `npm_package = detail or
+tool_config.get("npm_package")`. Change to also check
+`deprecated_npm_package`.
+
+New imports needed: `is_deprecated_install`, `format_install_method` from
+detection, `install_tool` from install.
+
+Note: after `remove_tool()` succeeds, `command_exists()` returns False so
+`install_tool()` proceeds normally with the configured `install_type`.
+
+### 4. `src/code_aide/commands_actions.py` -- include deprecated in auto-upgrade
+
+Modify `cmd_upgrade()` no-args path: after building the version-outdated
+list, also add any installed tools with deprecated install methods. Without
+this, a tool whose version is current but install method is deprecated would
+be silently skipped by `code-aide upgrade`.
+
+New import: `is_deprecated_install` from detection.
+
+### 5. `src/code_aide/commands_tools.py` -- show warnings in status/list
+
+In both `cmd_list()` and `cmd_status()`, after displaying "Installed via:",
+call `format_migration_warning()` and display the warning if present.
+
+At the end of `cmd_status()`, add a summary line counting tools that need
+migration.
+
+New imports: `format_migration_warning`, `is_deprecated_install` from
+detection.
+
+### 6. Tests
+
+- `tests/test_detection.py`: Tests for `is_deprecated_install()` covering
+  npm to script (deprecated), npm to npm (not deprecated), brew_formula
+  (never deprecated), system (never deprecated), not installed, unknown
+  tool, npm to direct_download. Tests for `format_migration_warning()`.
+- `tests/test_operations.py`: Tests for migration in `upgrade_tool()`:
+  triggers migration, normal upgrade when not deprecated, migration fails on
+  remove, migration fails on install with recovery message.
+- `tests/test_commands_tools.py`: Test that status/list show migration
+  warnings for deprecated installs.
+
+## Verification
+
+1. `pre-commit run --all-files` -- formatting passes
+2. `uv run pytest tests/ -v` -- all tests pass
+3. `uv run python -m code_aide status` -- shows migration warning for
+   npm-installed Claude (if applicable)
+4. `uv run python -m code_aide upgrade claude` -- performs migration (remove
+   npm, install via script)

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

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

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

@@ -5,6 +5,7 @@ import sys
 from typing import Any, Dict, List
 
 from code_aide.constants import TOOLS
+from code_aide.detection import is_deprecated_install
 from code_aide.install import install_tool
 from code_aide.console import error, info, success, warning
 from code_aide.operations import remove_tool, upgrade_tool, validate_tools
@@ -123,6 +124,10 @@ def cmd_upgrade(args: argparse.Namespace) -> None:
         for name, config in TOOLS.items():
             if not is_tool_installed(name):
                 continue
+            if is_deprecated_install(name):
+                if name not in tools_to_upgrade:
+                    tools_to_upgrade.append(name)
+                continue
             latest = config.get("latest_version")
             if not latest:
                 continue

{code_aide-1.6.0 → code_aide-1.7.0}/src/code_aide/commands_tools.py

@@ -8,6 +8,7 @@ from typing import List
 from code_aide.constants import Colors, PACKAGE_MANAGERS, TOOLS
 from code_aide.detection import (
     format_install_method,
+    format_migration_warning,
     get_system_package_info,
     detect_install_method,
 )
@@ -48,6 +49,9 @@ def cmd_list(args: argparse.Namespace) -> None:
                 "  Installed via: "
                 f"{format_install_method(install_info['method'], install_info['detail'])}"
             )
+            migration_msg = format_migration_warning(tool_name)
+            if migration_msg:
+                warning(f"  {migration_msg}")
 
         if tool_config.get("min_node_version"):
             print(f"  Requires:     Node.js v{tool_config['min_node_version']}+")
@@ -99,6 +103,7 @@ def cmd_status(args: argparse.Namespace) -> None:
     print()
 
     outdated_count = 0
+    migration_count = 0
     config_outdated: List[str] = []
 
     for tool_name, tool_config in TOOLS.items():
@@ -156,6 +161,10 @@ def cmd_status(args: argparse.Namespace) -> None:
                     "  Installed via: "
                     f"{format_install_method(install_info['method'], install_info['detail'])}"
                 )
+                migration_msg = format_migration_warning(tool_name)
+                if migration_msg:
+                    warning(f"  {migration_msg}")
+                    migration_count += 1
 
             if status["user"]:
                 print(f"  User:         {status['user']}")
@@ -181,3 +190,8 @@ def cmd_status(args: argparse.Namespace) -> None:
             f"{Colors.YELLOW}{outdated_count} tool(s) can be upgraded with "
             f"'code-aide upgrade'.{Colors.NC}"
         )
+    if migration_count > 0:
+        print(
+            f"{Colors.YELLOW}{migration_count} tool(s) need migration to a "
+            f"new install method. Run 'code-aide upgrade' to migrate.{Colors.NC}"
+        )

{code_aide-1.6.0 → code_aide-1.7.0}/src/code_aide/detection.py

@@ -186,3 +186,63 @@ def format_install_method(method: Optional[str], detail: Optional[str]) -> str:
     if method:
         return method
     return "unknown"
+
+
+# Install methods that are user-managed and never considered deprecated
+_USER_MANAGED_METHODS = frozenset({"brew_formula", "brew_cask", "system"})
+
+# Install methods that are considered deprecated when they don't match
+# the configured install_type
+_DEPRECATED_METHODS = frozenset({"npm", "brew_npm"})
+
+
+def is_deprecated_install(tool_name: str) -> bool:
+    """Check if a tool's detected install method is deprecated.
+
+    Returns True when the detected install method is npm or brew_npm
+    but the configured install_type is something else (e.g. script,
+    direct_download).  Brew formula/cask and system installs are
+    user-managed and never considered deprecated.
+    """
+    tool_config = TOOLS.get(tool_name)
+    if not tool_config:
+        return False
+
+    install_info = detect_install_method(tool_name)
+    detected = install_info["method"]
+
+    if not detected:
+        return False
+
+    if detected in _USER_MANAGED_METHODS:
+        return False
+
+    configured = tool_config.get("install_type")
+    if not configured:
+        return False
+
+    if detected in _DEPRECATED_METHODS and detected != configured:
+        return True
+
+    return False
+
+
+def format_migration_warning(tool_name: str) -> Optional[str]:
+    """Return a human-readable migration warning, or None if not needed."""
+    if not is_deprecated_install(tool_name):
+        return None
+
+    tool_config = TOOLS.get(tool_name)
+    if not tool_config:
+        return None
+
+    install_info = detect_install_method(tool_name)
+    detected_label = format_install_method(
+        install_info["method"], install_info["detail"]
+    )
+    configured_label = format_install_method(tool_config["install_type"], None)
+
+    return (
+        f"Installed via {detected_label} but configured method is "
+        f"{configured_label}. Run 'code-aide upgrade {tool_name}' to migrate."
+    )

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

@@ -8,12 +8,48 @@ import sys
 from typing import List
 
 from code_aide.constants import TOOLS
-from code_aide.detection import detect_install_method
-from code_aide.install import install_direct_download, run_install_script
+from code_aide.detection import (
+    detect_install_method,
+    format_install_method,
+    is_deprecated_install,
+)
+from code_aide.install import install_direct_download, install_tool, run_install_script
 from code_aide.console import error, info, run_command, success, warning
 from code_aide.prereqs import is_tool_installed
 
 
+def _migrate_install_method(tool_name: str) -> bool:
+    """Migrate a tool from a deprecated install method to the configured one."""
+    tool_config = TOOLS[tool_name]
+    install_info = detect_install_method(tool_name)
+    old_label = format_install_method(install_info["method"], install_info["detail"])
+    new_label = format_install_method(tool_config["install_type"], None)
+
+    warning(
+        f"{tool_config['name']} is installed via {old_label} "
+        f"but the configured method is {new_label}."
+    )
+    info(f"Migrating {tool_config['name']} from {old_label} to {new_label}...")
+
+    if not remove_tool(tool_name):
+        error(
+            f"Failed to remove old {old_label} install of {tool_config['name']}. "
+            "Migration aborted."
+        )
+        return False
+
+    if not install_tool(tool_name):
+        error(f"Failed to install {tool_config['name']} via {new_label}.")
+        error(
+            f"The old {old_label} install has been removed. "
+            f"To recover, run: code-aide install {tool_name}"
+        )
+        return False
+
+    success(f"{tool_config['name']} migrated from {old_label} to {new_label}")
+    return True
+
+
 def upgrade_tool(tool_name: str) -> bool:
     """Upgrade a tool based on its configuration."""
     tool_config = TOOLS.get(tool_name)
@@ -25,6 +61,9 @@ def upgrade_tool(tool_name: str) -> bool:
         warning(f"{tool_config['name']} is not installed. Use 'install' command first.")
         return False
 
+    if is_deprecated_install(tool_name):
+        return _migrate_install_method(tool_name)
+
     install_info = detect_install_method(tool_name)
     method = install_info["method"]
     detail = install_info["detail"]

code_aide-1.7.0/tests/test_commands_tools.py

@@ -0,0 +1,163 @@
+"""Unit tests for read-only CLI commands."""
+
+import contextlib
+import io
+import unittest
+from unittest import mock
+
+from code_aide import commands_tools
+
+
+class TestCmdList(unittest.TestCase):
+    """Tests for cmd_list."""
+
+    def test_lists_tools_without_runtime_probes(self):
+        tools = {
+            "x": {
+                "name": "Example Tool",
+                "command": "example",
+                "install_type": "npm",
+                "default_install": True,
+            }
+        }
+        args = type("Args", (), {})()
+        with (
+            mock.patch.dict(commands_tools.TOOLS, tools, clear=True),
+            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
+            ),
+        ):
+            buf = io.StringIO()
+            with contextlib.redirect_stdout(buf):
+                commands_tools.cmd_list(args)
+        output = buf.getvalue()
+        self.assertIn("Example Tool", output)
+        self.assertIn("Managed by:   npm (code-aide)", output)
+        self.assertIn("System Information:", output)
+
+
+class TestCmdStatus(unittest.TestCase):
+    """Tests for cmd_status."""
+
+    def test_shows_upgradeable_count_for_outdated_tool(self):
+        tools = {
+            "x": {
+                "name": "Example Tool",
+                "command": "example",
+                "install_type": "npm",
+                "latest_version": "2.0.0",
+            }
+        }
+        status = {
+            "installed": True,
+            "version": "1.0.0",
+            "user": None,
+            "usage": None,
+            "errors": [],
+        }
+        args = type("Args", (), {})()
+        with (
+            mock.patch.dict(commands_tools.TOOLS, tools, clear=True),
+            mock.patch.object(commands_tools, "get_tool_status", return_value=status),
+            mock.patch.object(
+                commands_tools.shutil, "which", return_value="/tmp/example"
+            ),
+            mock.patch.object(
+                commands_tools,
+                "detect_install_method",
+                return_value={"method": "npm", "detail": "example-pkg"},
+            ),
+            mock.patch.object(
+                commands_tools, "format_migration_warning", return_value=None
+            ),
+        ):
+            buf = io.StringIO()
+            with contextlib.redirect_stdout(buf):
+                commands_tools.cmd_status(args)
+        output = buf.getvalue()
+        self.assertIn("Example Tool", output)
+        self.assertIn("tool(s) can be upgraded", output)
+
+    def test_status_shows_migration_warning(self):
+        """cmd_status shows migration warning for deprecated install."""
+        tools = {
+            "x": {
+                "name": "Example Tool",
+                "command": "example",
+                "install_type": "script",
+                "latest_version": "1.0.0",
+            }
+        }
+        status = {
+            "installed": True,
+            "version": "1.0.0",
+            "user": None,
+            "usage": None,
+            "errors": [],
+        }
+        args = type("Args", (), {})()
+        with (
+            mock.patch.dict(commands_tools.TOOLS, tools, clear=True),
+            mock.patch.object(commands_tools, "get_tool_status", return_value=status),
+            mock.patch.object(
+                commands_tools.shutil, "which", return_value="/tmp/example"
+            ),
+            mock.patch.object(
+                commands_tools,
+                "detect_install_method",
+                return_value={"method": "npm", "detail": "example-pkg"},
+            ),
+            mock.patch.object(
+                commands_tools,
+                "format_migration_warning",
+                return_value="Installed via npm but configured method is script. "
+                "Run 'code-aide upgrade x' to migrate.",
+            ),
+        ):
+            buf = io.StringIO()
+            with contextlib.redirect_stdout(buf):
+                commands_tools.cmd_status(args)
+        output = buf.getvalue()
+        self.assertIn("configured method is script", output)
+        self.assertIn("tool(s) need migration", output)
+
+    def test_list_shows_migration_warning(self):
+        """cmd_list shows migration warning for deprecated install."""
+        tools = {
+            "x": {
+                "name": "Example Tool",
+                "command": "example",
+                "install_type": "script",
+                "default_install": True,
+            }
+        }
+        args = type("Args", (), {})()
+        with (
+            mock.patch.dict(commands_tools.TOOLS, tools, clear=True),
+            mock.patch.object(commands_tools, "is_tool_installed", return_value=True),
+            mock.patch.object(
+                commands_tools.shutil, "which", return_value="/tmp/example"
+            ),
+            mock.patch.object(
+                commands_tools,
+                "detect_install_method",
+                return_value={"method": "npm", "detail": "example-pkg"},
+            ),
+            mock.patch.object(
+                commands_tools,
+                "format_migration_warning",
+                return_value="Installed via npm but configured method is script. "
+                "Run 'code-aide upgrade x' to migrate.",
+            ),
+            mock.patch.object(commands_tools, "command_exists", return_value=False),
+            mock.patch.object(
+                commands_tools, "detect_package_manager", return_value=None
+            ),
+        ):
+            buf = io.StringIO()
+            with contextlib.redirect_stdout(buf):
+                commands_tools.cmd_list(args)
+        output = buf.getvalue()
+        self.assertIn("configured method is script", output)