code-aide 1.7.3__tar.gz → 1.10.0__tar.gz

{code_aide-1.7.3 → code_aide-1.10.0}/.gitignore

@@ -12,3 +12,4 @@
 __pycache__/
 build/
 dist/
+archive/

{code_aide-1.7.3 → code_aide-1.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-aide
-Version: 1.7.3
+Version: 1.10.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.10.0/specs/unify-upgrade-eligibility-with-shared-evaluator.md

@@ -0,0 +1,87 @@
+# Unify upgrade eligibility with a shared evaluator
+
+## Summary
+
+Introduce a single evaluator class that computes tool state once and exposes
+normalized decisions for both `status` and default `upgrade`. Use typed
+`Enum` values, not strings, for all decision outcomes and display states so
+callers cannot drift by comparing ad hoc literals.
+
+## Implementation changes
+
+- Add a small evaluator in `src/code_aide/status.py` as the single source of
+  truth for:
+  - install presence
+  - detected install method
+  - package-manager metadata
+  - version relationship to catalog/package state
+  - normalized outcome for both status rendering and default `upgrade`
+- Define typed enums for evaluator output:
+  - `UpgradeDecision`: `CURRENT`, `UPGRADE`, `MIGRATION`, `PACKAGE_MANAGED`,
+    `NOT_INSTALLED`, `UNKNOWN`
+  - `VersionDisplayState`: `UP_TO_DATE`, `OUTDATED`, `UNAVAILABLE`
+  - optional compact-state enum if needed, otherwise derive compact text
+    from `UpgradeDecision`
+- Return a typed result object/dataclass from the evaluator containing:
+  - `decision: UpgradeDecision`
+  - `version_state: VersionDisplayState`
+  - `actionable_by_upgrade: bool`
+  - optional package/upstream fields needed by full status
+- Keep all decision rules inside the evaluator:
+  - exact catalog match => `CURRENT`
+  - installed newer than catalog => `CURRENT`
+  - deprecated detected install (`npm`/`brew_npm` vs configured non-matching
+    method) => `MIGRATION`
+  - Homebrew outdated => `UPGRADE`
+  - Homebrew current => `CURRENT`
+  - system-managed install => `PACKAGE_MANAGED`, never auto-selected by
+    default `upgrade`
+  - missing latest-version metadata or missing CLI version => `UNKNOWN`, not
+    auto-selected
+- Refactor `cmd_status` and compact status in
+  `src/code_aide/commands_tools.py` to consume evaluator results only.
+- Refactor default-selection logic in `cmd_upgrade` in
+  `src/code_aide/commands_actions.py` to use the same evaluator result.
+- Keep explicit `code-aide upgrade <tool>` behavior unchanged; the evaluator
+  governs automatic selection and status semantics.
+
+## Public interfaces and types
+
+- Add an internal evaluator class, for example `ToolUpgradeEvaluator`.
+- Add internal enums and a typed result/dataclass; no caller should branch
+  on raw strings after this refactor.
+- Do not change CLI flags, command names, or user-facing command flow.
+
+## Test plan
+
+- Add evaluator-focused unit tests covering enum outputs for:
+  - installed version equals catalog latest
+  - installed version newer than catalog latest
+  - installed version older than catalog latest
+  - Homebrew tool with `outdated=True`
+  - Homebrew tool with `outdated=False`
+  - system-managed tool with newer upstream metadata
+  - deprecated npm install requiring migration
+  - missing version metadata or unknown state
+- Add command-level regressions proving shared behavior:
+  - full `status` says `up to date` for newer-than-catalog installs and
+    default `upgrade` does not auto-select them
+  - full/compact `status` and default `upgrade` both treat Homebrew current
+    installs as non-upgradeable
+  - system-managed installs are not auto-selected by default `upgrade`
+  - migration-required installs still appear as actionable for default
+    `upgrade`
+- Run the targeted suite:
+  - `tests/test_status.py`
+  - `tests/test_commands_tools.py`
+  - `tests/test_commands_actions.py`
+  - any existing detection/operations tests touched by the refactor
+
+## Assumptions
+
+- The evaluator, enums, and result dataclass remain internal APIs.
+- Full `status` still shows migration warnings separately from upgrade
+  footers, but both are derived from the same enum-backed evaluator result.
+- `Upgradeable` in the footer means `selected by default code-aide upgrade`.
+- Display text remains string-based at the CLI boundary only; decision logic
+  uses enums throughout.

{code_aide-1.7.3 → code_aide-1.10.0}/src/code_aide/__init__.py

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

{code_aide-1.7.3 → code_aide-1.10.0}/src/code_aide/commands_actions.py

@@ -5,12 +5,14 @@ import sys
 from typing import Any, Dict, List
 
 from code_aide.constants import TOOLS
-from code_aide.detection import (
-    detect_install_method,
-    get_brew_package_info,
-    is_deprecated_install,
-)
+from code_aide.detection import detect_install_method, get_brew_package_info
 from code_aide.install import install_tool
+from code_aide.install_types import (
+    InstallMethod,
+    InstallType,
+    parse_install_method,
+    parse_install_type,
+)
 from code_aide.console import error, info, success, warning
 from code_aide.operations import (
     UpgradeResult,
@@ -23,14 +25,13 @@ from code_aide.prereqs import (
     check_prerequisites,
     is_tool_installed,
 )
-from code_aide.status import get_tool_status
+from code_aide.status import ToolUpgradeEvaluator
 from code_aide.versions import (
     apply_sha256_updates,
     check_npm_tool,
     check_script_tool,
     normalize_version,
     print_check_results_table,
-    status_version_matches_latest,
 )
 from code_aide.config import (
     load_bundled_tools,
@@ -131,28 +132,9 @@ def cmd_upgrade(args: argparse.Namespace) -> None:
     else:
         tools_to_upgrade = []
         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
-            install_info = detect_install_method(name)
-            if install_info["method"] in ("brew_formula", "brew_cask"):
-                pkg_info = get_brew_package_info(
-                    install_info["method"], install_info["detail"]
-                )
-                if pkg_info.get("outdated") is False:
-                    continue
-            status = get_tool_status(name, config)
-            if status["version"] and status_version_matches_latest(
-                status["version"], latest
-            ):
-                continue
-            tools_to_upgrade.append(name)
+            assessment = ToolUpgradeEvaluator(name, config).evaluate()
+            if assessment.actionable_by_upgrade and name not in tools_to_upgrade:
+                tools_to_upgrade.append(name)
         if tools_to_upgrade:
             info(f"Upgrading out-of-date tools: {', '.join(tools_to_upgrade)}")
         else:
@@ -282,20 +264,20 @@ def cmd_update_versions(args: argparse.Namespace) -> None:
     results: List[Dict[str, Any]] = []
     for name in tool_names:
         tool_config = tools[name]
-        install_type = tool_config["install_type"]
+        install_type = parse_install_type(tool_config["install_type"])
 
-        if install_type == "npm":
+        if install_type == InstallType.NPM:
             results.append(check_npm_tool(name, tool_config, args.verbose))
-        elif install_type in ("script", "direct_download"):
+        elif install_type in (InstallType.SCRIPT, InstallType.DIRECT_DOWNLOAD):
             results.append(check_script_tool(name, tool_config, args.verbose))
         else:
             results.append(
                 {
                     "tool": name,
-                    "type": install_type,
+                    "type": tool_config["install_type"],
                     "version": "-",
                     "date": "-",
-                    "status": f"unknown type: {install_type}",
+                    "status": f"unknown type: {tool_config['install_type']}",
                     "update": None,
                 }
             )
@@ -320,6 +302,23 @@ def cmd_update_versions(args: argparse.Namespace) -> None:
                 tool_entry["latest_date"] = date
                 version_info_changed = True
 
+    # Refresh latest_version from Homebrew for tools installed via brew, so
+    # "upstream" in status reflects the correct source for those installs.
+    for tool_name in tool_names:
+        install_info = detect_install_method(tool_name)
+        method = parse_install_method(install_info["method"])
+        if method not in (InstallMethod.BREW_FORMULA, InstallMethod.BREW_CASK):
+            continue
+        pkg_info = get_brew_package_info(method, install_info["detail"])
+        avail = pkg_info.get("available_version")
+        if not avail:
+            continue
+        normalized = normalize_version(avail)
+        tool_entry = config["tools"][tool_name]
+        if tool_entry.get("latest_version") != normalized:
+            tool_entry["latest_version"] = normalized
+            version_info_changed = True
+
     def _save(tools: dict) -> str:
         """Save versions to user cache. Returns description."""
         save_updated_versions(tools)

{code_aide-1.7.3 → code_aide-1.10.0}/src/code_aide/commands_tools.py

@@ -1,5 +1,7 @@
 """Read-only CLI commands: list and status."""
 
+from __future__ import annotations
+
 import argparse
 import platform
 import shutil
@@ -9,21 +11,24 @@ from code_aide.constants import Colors, PACKAGE_MANAGERS, TOOLS
 from code_aide.detection import (
     format_install_method,
     format_migration_warning,
-    get_brew_package_info,
-    get_system_package_info,
     detect_install_method,
 )
 from code_aide.console import command_exists, info, warning
+from code_aide.install_types import (
+    InstallMethod,
+    parse_install_method,
+    parse_install_type,
+)
 from code_aide.prereqs import detect_package_manager, is_tool_installed
 from code_aide.status import (
-    get_tool_status,
     print_brew_version_status,
     print_system_version_status,
+    ToolUpgradeEvaluator,
+    UpgradeDecision,
+    VersionDisplayState,
 )
 from code_aide.versions import (
     extract_version_from_string,
-    status_version_matches_latest,
-    version_is_newer,
 )
 
 
@@ -44,7 +49,9 @@ def cmd_list(args: argparse.Namespace) -> None:
         print(f"{Colors.BLUE}{tool_config['name']}{Colors.NC}")
         print(f"  Command:      {tool_config['command']}")
         print(f"  Status:       {status}")
-        print(f"  Managed by:   {tool_config['install_type']} (code-aide)")
+        install_type = parse_install_type(tool_config["install_type"])
+        managed_by = install_type.value if install_type else tool_config["install_type"]
+        print(f"  Managed by:   {managed_by} (code-aide)")
 
         if installed:
             tool_path = shutil.which(tool_config["command"])
@@ -104,31 +111,45 @@ def cmd_list(args: argparse.Namespace) -> None:
 def _short_install_method(method: str | None) -> str:
     """Return a short label for an install method."""
     labels = {
-        "brew_formula": "brew",
-        "brew_cask": "cask",
-        "npm": "npm",
-        "brew_npm": "brew-npm",
-        "system": "system",
-        "script": "script",
-        "direct_download": "download",
+        InstallMethod.BREW_FORMULA: "brew",
+        InstallMethod.BREW_CASK: "cask",
+        InstallMethod.NPM: "npm",
+        InstallMethod.BREW_NPM: "brew-npm",
+        InstallMethod.SYSTEM: "system",
+        InstallMethod.SCRIPT: "script",
+        InstallMethod.DIRECT_DOWNLOAD: "download",
     }
-    return labels.get(method or "", method or "unknown")
+    install_method = parse_install_method(method)
+    if install_method is None:
+        return str(method or "unknown")
+    return labels.get(install_method, str(install_method))
 
 
 def _compact_version_status(
-    version: str | None, latest_version: str | None
+    installed_version: str | None, version_state: VersionDisplayState
 ) -> tuple[str, str]:
     """Return (version_str, status_indicator) for compact display."""
-    if not version:
+    if not installed_version:
         return ("", "")
-    ver = extract_version_from_string(version) or version
-    if not latest_version:
-        return (ver, "")
-    if status_version_matches_latest(version, latest_version):
+    ver = extract_version_from_string(installed_version) or installed_version
+    if version_state == VersionDisplayState.UP_TO_DATE:
         return (ver, f"{Colors.GREEN}ok{Colors.NC}")
-    if ver and version_is_newer(ver, latest_version):
-        return (ver, f"{Colors.YELLOW}newer{Colors.NC}")
-    return (ver, f"{Colors.YELLOW}old{Colors.NC}")
+    if version_state == VersionDisplayState.OUTDATED:
+        return (ver, f"{Colors.YELLOW}old{Colors.NC}")
+    return (ver, "")
+
+
+def _generic_version_annotation(
+    installed_version: str, latest_version: str | None
+) -> str:
+    """Return the generic version line for non-package-managed status."""
+    if not latest_version:
+        return f"  Version:      {installed_version}"
+
+    return (
+        f"  Version:      {installed_version} "
+        f"{Colors.YELLOW}(latest: {latest_version}){Colors.NC}"
+    )
 
 
 def cmd_status_compact() -> None:
@@ -136,7 +157,8 @@ def cmd_status_compact() -> None:
     rows: list[tuple[str, str, str, str, str]] = []
     for tool_name, tool_config in TOOLS.items():
         name = tool_config["command"]
-        status = get_tool_status(tool_name, tool_config)
+        assessment = ToolUpgradeEvaluator(tool_name, tool_config).evaluate()
+        status = assessment.status
 
         if not status["installed"]:
             opt_in = not tool_config.get("default_install", True)
@@ -148,10 +170,10 @@ def cmd_status_compact() -> None:
             continue
 
         tool_path = shutil.which(tool_config["command"]) or ""
-        install_info = detect_install_method(tool_name)
-        method = _short_install_method(install_info["method"])
-        latest_version = tool_config.get("latest_version")
-        ver, ver_status = _compact_version_status(status["version"], latest_version)
+        method = _short_install_method(assessment.install_method)
+        ver, ver_status = _compact_version_status(
+            assessment.installed_version, assessment.version_state
+        )
 
         state = f"{Colors.GREEN}ok{Colors.NC}"
         if ver_status:
@@ -193,106 +215,90 @@ def cmd_status(args: argparse.Namespace) -> None:
     print()
 
     outdated_count = 0
+    outdated_tools: List[str] = []
     migration_count = 0
-    config_outdated: List[str] = []
 
     for tool_name, tool_config in TOOLS.items():
         print(f"{Colors.BLUE}{tool_config['name']}{Colors.NC}")
 
-        status = get_tool_status(tool_name, tool_config)
+        tool_path = shutil.which(tool_config["command"])
+        assessment = ToolUpgradeEvaluator(
+            tool_name, tool_config, tool_path=tool_path
+        ).evaluate()
+        status = assessment.status
 
         if not status["installed"]:
             print(f"  Status:       {Colors.RED}✗ Not installed{Colors.NC}")
         else:
             print(f"  Status:       {Colors.GREEN}✓ Installed{Colors.NC}")
 
-            tool_path = shutil.which(tool_config["command"])
-            install_info = detect_install_method(tool_name)
-            is_system = install_info["method"] == "system"
-
             if status["version"]:
-                latest_version = tool_config.get("latest_version")
-
-                if is_system and tool_path:
-                    pkg_info = get_system_package_info(tool_path)
+                if (
+                    assessment.install_method == InstallMethod.SYSTEM
+                    and tool_path
+                    and assessment.package_info
+                ):
                     print_system_version_status(
-                        status["version"], latest_version, pkg_info
-                    )
-                elif install_info["method"] in ("brew_formula", "brew_cask"):
-                    pkg_info = get_brew_package_info(
-                        install_info["method"], install_info["detail"]
+                        status["version"],
+                        assessment.latest_version,
+                        assessment.package_info,
                     )
-                    if pkg_info.get("available_version"):
+                elif assessment.install_method in (
+                    InstallMethod.BREW_FORMULA,
+                    InstallMethod.BREW_CASK,
+                ):
+                    if assessment.package_info and assessment.package_info.get(
+                        "available_version"
+                    ):
                         print_brew_version_status(
-                            status["version"], latest_version, pkg_info
+                            status["version"],
+                            assessment.latest_version,
+                            assessment.package_info,
                         )
-                        if pkg_info.get("outdated"):
-                            outdated_count += 1
-                    elif latest_version:
-                        if status_version_matches_latest(
-                            status["version"], latest_version
-                        ):
-                            version_annotation = (
+                    elif assessment.latest_version:
+                        if assessment.version_state == VersionDisplayState.UP_TO_DATE:
+                            print(
                                 f"  Version:      {status['version']} "
                                 f"{Colors.GREEN}(up to date){Colors.NC}"
                             )
                         else:
-                            installed_ver = extract_version_from_string(
-                                status["version"]
-                            )
-                            if installed_ver and version_is_newer(
-                                installed_ver, latest_version
-                            ):
-                                version_annotation = (
-                                    f"  Version:      {status['version']} "
-                                    f"{Colors.YELLOW}(newer than configured "
-                                    f"{latest_version}){Colors.NC}"
-                                )
-                                config_outdated.append(tool_name)
-                            else:
-                                version_annotation = (
-                                    f"  Version:      {status['version']} "
-                                    f"{Colors.YELLOW}(latest: {latest_version}){Colors.NC}"
+                            print(
+                                _generic_version_annotation(
+                                    status["version"], assessment.latest_version
                                 )
-                                outdated_count += 1
-                        print(version_annotation)
-                elif latest_version:
-                    if status_version_matches_latest(status["version"], latest_version):
-                        version_annotation = (
+                            )
+                    else:
+                        print(f"  Version:      {status['version']}")
+                elif assessment.latest_version:
+                    if assessment.version_state == VersionDisplayState.UP_TO_DATE:
+                        print(
                             f"  Version:      {status['version']} "
                             f"{Colors.GREEN}(up to date){Colors.NC}"
                         )
                     else:
-                        installed_ver = extract_version_from_string(status["version"])
-                        if installed_ver and version_is_newer(
-                            installed_ver, latest_version
-                        ):
-                            version_annotation = (
-                                f"  Version:      {status['version']} "
-                                f"{Colors.YELLOW}(newer than configured "
-                                f"{latest_version}){Colors.NC}"
-                            )
-                            config_outdated.append(tool_name)
-                        else:
-                            version_annotation = (
-                                f"  Version:      {status['version']} "
-                                f"{Colors.YELLOW}(latest: {latest_version}){Colors.NC}"
+                        print(
+                            _generic_version_annotation(
+                                status["version"], assessment.latest_version
                             )
-                            outdated_count += 1
-                    print(version_annotation)
+                        )
                 else:
                     print(f"  Version:      {status['version']}")
 
+                if assessment.decision == UpgradeDecision.UPGRADE:
+                    outdated_count += 1
+                    outdated_tools.append(tool_name)
+
             if tool_path:
                 print(f"  Location:     {tool_path}")
                 print(
                     "  Installed via: "
-                    f"{format_install_method(install_info['method'], install_info['detail'])}"
+                    f"{format_install_method(assessment.install_method, assessment.install_detail)}"
                 )
-                migration_msg = format_migration_warning(tool_name)
-                if migration_msg:
-                    warning(f"  {migration_msg}")
+                if assessment.decision == UpgradeDecision.MIGRATION:
                     migration_count += 1
+                    migration_msg = format_migration_warning(tool_name)
+                    if migration_msg:
+                        warning(f"  {migration_msg}")
 
             if status["user"]:
                 print(f"  User:         {status['user']}")
@@ -306,17 +312,11 @@ def cmd_status(args: argparse.Namespace) -> None:
 
         print()
 
-    if config_outdated:
-        tools_str = " ".join(config_outdated)
-        print(
-            f"{Colors.YELLOW}Configured version outdated for: "
-            f"{', '.join(config_outdated)}. Run 'code-aide update-versions "
-            f"{tools_str}' to update.{Colors.NC}"
-        )
     if outdated_count > 0:
+        names = ", ".join(outdated_tools)
         print(
             f"{Colors.YELLOW}{outdated_count} tool(s) can be upgraded with "
-            f"'code-aide upgrade'.{Colors.NC}"
+            f"'code-aide upgrade': {names}.{Colors.NC}"
         )
     if migration_count > 0:
         print(

{code_aide-1.7.3 → code_aide-1.10.0}/src/code_aide/config.py

@@ -9,6 +9,8 @@ import importlib.resources
 import json
 import os
 
+from code_aide.install_types import InstallType, parse_install_type
+
 
 def get_config_dir() -> str:
     """Return XDG config directory for code-aide.
@@ -70,6 +72,14 @@ def merge_cached_versions(tools: dict, cache: dict) -> None:
         if tool_key in cached_tools:
             for field in DYNAMIC_FIELDS:
                 if field in cached_tools[tool_key]:
+                    if (
+                        field == "install_sha256"
+                        and parse_install_type(tool_data.get("install_type"))
+                        == InstallType.DIRECT_DOWNLOAD
+                    ):
+                        # Script checksum does not apply to tarball installs; ignore
+                        # stale cache from older releases or mistaken updates.
+                        continue
                     tool_data[field] = cached_tools[tool_key][field]
 
 
@@ -77,9 +87,10 @@ def load_tools_config() -> dict:
     """Load tool config: bundled definitions merged with cached versions.
 
     Two-layer model: the bundled tools.json provides tool definitions and
-    install_sha256 checksums. The user's version cache (from
-    update-versions) provides latest_version, latest_date, and updated
-    install_sha256 values when present.
+    install_sha256 checksums (for script-type tools). The user's version
+    cache (from update-versions) provides latest_version, latest_date,
+    and updated install_sha256 values when present. Cached install_sha256
+    is ignored for direct_download tools (tarball installs).
     """
     bundled = load_bundled_tools()
     cache = load_versions_cache()
@@ -99,6 +110,12 @@ def save_updated_versions(tools: dict) -> None:
         entry = {}
         for field in DYNAMIC_FIELDS:
             if field in tool_data:
+                if (
+                    field == "install_sha256"
+                    and parse_install_type(tool_data.get("install_type"))
+                    == InstallType.DIRECT_DOWNLOAD
+                ):
+                    continue
                 entry[field] = tool_data[field]
         if entry:
             cache_data["tools"][tool_key] = entry

{code_aide-1.7.3 → code_aide-1.10.0}/src/code_aide/data/tools.json

@@ -6,7 +6,6 @@
       "command": "agent",
       "install_type": "direct_download",
       "install_url": "https://cursor.com/install",
-      "install_sha256": "7ccf2992a4de12c040854a833db0255a08cdfc91d40c75b78cf66a8746d9bd24",
       "download_url_template": "https://downloads.cursor.com/lab/{version}/{os}/{arch}/agent-cli-package.tar.gz",
       "install_dir": "~/.local/share/cursor-agent/versions/{version}",
       "bin_dir": "~/.local/bin",