code-aide 1.0.0__py3-none-any.whl

code_aide/__init__.py

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

code_aide/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for python -m code_aide."""
+
+from code_aide.entry import main
+
+if __name__ == "__main__":
+    main()

code_aide/commands_actions.py

@@ -0,0 +1,344 @@
+"""Mutating CLI commands: install, upgrade, remove, update-versions."""
+
+import argparse
+import sys
+from typing import Any, Dict, List
+
+from code_aide.constants import TOOLS
+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
+from code_aide.prereqs import (
+    check_path_directories,
+    check_prerequisites,
+    is_tool_installed,
+)
+from code_aide.status import get_tool_status
+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,
+    load_versions_cache,
+    merge_cached_versions,
+    save_updated_versions,
+)
+
+
+def cmd_install(args: argparse.Namespace) -> None:
+    """Handle install command."""
+    dryrun = getattr(args, "dryrun", False)
+
+    if args.tools:
+        tools_to_install = args.tools
+        if dryrun:
+            info(f"[DRYRUN] Checking specified tools: {', '.join(tools_to_install)}")
+        else:
+            info(f"Installing specified tools: {', '.join(tools_to_install)}")
+    else:
+        tools_to_install = [
+            name
+            for name, config in TOOLS.items()
+            if config.get("default_install", True)
+        ]
+        if dryrun:
+            info(f"[DRYRUN] Checking default tools: {', '.join(tools_to_install)}")
+        else:
+            info(
+                "No tools specified, installing default tools: "
+                f"{', '.join(tools_to_install)}"
+            )
+
+    validate_tools(tools_to_install)
+
+    if not dryrun:
+        check_prerequisites(
+            tools_to_install, install_prereqs=args.install_prerequisites
+        )
+
+    installed = []
+    failed = []
+
+    for tool in tools_to_install:
+        print()
+        if dryrun:
+            info(f"=== Checking {tool} ===")
+        else:
+            info(f"=== Installing {tool} ===")
+
+        if install_tool(tool, dryrun=dryrun):
+            installed.append(tool)
+        else:
+            failed.append(tool)
+
+    print()
+    print("=" * 42)
+    if dryrun:
+        info("Verification Summary")
+    else:
+        info("Installation Summary")
+    print("=" * 42)
+
+    if installed:
+        if dryrun:
+            success(f"Verification passed: {', '.join(installed)}")
+        else:
+            success(f"Successfully installed: {', '.join(installed)}")
+
+    if failed:
+        if dryrun:
+            error(f"Verification failed: {', '.join(failed)}")
+        else:
+            error(f"Failed to install: {', '.join(failed)}")
+        sys.exit(1)
+
+    if dryrun:
+        print()
+        success("All verifications completed successfully!")
+    else:
+        print()
+        info("Next steps:")
+        for tool in installed:
+            tool_config = TOOLS.get(tool)
+            if tool_config:
+                print(f"  {tool_config['next_steps']}")
+
+        print()
+        check_path_directories()
+        success("All installations completed successfully!")
+
+
+def cmd_upgrade(args: argparse.Namespace) -> None:
+    """Handle upgrade command."""
+    if args.tools:
+        tools_to_upgrade = args.tools
+        info(f"Upgrading specified tools: {', '.join(tools_to_upgrade)}")
+    else:
+        tools_to_upgrade = []
+        for name, config in TOOLS.items():
+            if not is_tool_installed(name):
+                continue
+            latest = config.get("latest_version")
+            if not latest:
+                continue
+            status = get_tool_status(name, config)
+            if status["version"] and status_version_matches_latest(
+                status["version"], latest
+            ):
+                continue
+            tools_to_upgrade.append(name)
+        if tools_to_upgrade:
+            info(f"Upgrading out-of-date tools: {', '.join(tools_to_upgrade)}")
+        else:
+            info("All installed tools are up to date")
+            return
+
+    validate_tools(tools_to_upgrade)
+
+    upgraded = []
+    failed = []
+    skipped = []
+
+    for tool in tools_to_upgrade:
+        print()
+        info(f"=== Upgrading {tool} ===")
+
+        if not is_tool_installed(tool):
+            skipped.append(tool)
+            continue
+
+        if upgrade_tool(tool):
+            upgraded.append(tool)
+        else:
+            failed.append(tool)
+
+    print()
+    print("=" * 42)
+    info("Upgrade Summary")
+    print("=" * 42)
+
+    if upgraded:
+        success(f"Successfully upgraded: {', '.join(upgraded)}")
+
+    if skipped:
+        warning(f"Skipped (not installed): {', '.join(skipped)}")
+
+    if failed:
+        error(f"Failed to upgrade: {', '.join(failed)}")
+        sys.exit(1)
+
+    if upgraded:
+        success("All upgrades completed successfully!")
+    elif skipped and not upgraded:
+        info(
+            "No tools were upgraded (all were either not installed or already up to date)"
+        )
+
+
+def cmd_remove(args: argparse.Namespace) -> None:
+    """Handle remove command."""
+    if args.tools:
+        tools_to_remove = args.tools
+        info(f"Removing specified tools: {', '.join(tools_to_remove)}")
+    else:
+        tools_to_remove = list(TOOLS.keys())
+        info(f"No tools specified, removing all: {', '.join(tools_to_remove)}")
+
+    validate_tools(tools_to_remove)
+
+    removed = []
+    failed = []
+    skipped = []
+
+    for tool in tools_to_remove:
+        print()
+        info(f"=== Removing {tool} ===")
+
+        if not is_tool_installed(tool):
+            skipped.append(tool)
+            continue
+
+        if remove_tool(tool):
+            removed.append(tool)
+        else:
+            failed.append(tool)
+
+    print()
+    print("=" * 42)
+    info("Removal Summary")
+    print("=" * 42)
+
+    if removed:
+        success(f"Successfully removed: {', '.join(removed)}")
+
+    if skipped:
+        warning(f"Skipped (not installed): {', '.join(skipped)}")
+
+    if failed:
+        error(f"Failed to remove: {', '.join(failed)}")
+        sys.exit(1)
+
+    if removed:
+        success("All removals completed successfully!")
+    elif skipped and not removed:
+        info("No tools were removed (all were not installed)")
+
+
+def cmd_update_versions(args: argparse.Namespace) -> None:
+    """Handle update-versions command: check upstream for latest tool versions."""
+    bundled = load_bundled_tools()
+    tools = bundled.get("tools", {})
+    merge_cached_versions(tools, load_versions_cache())
+
+    config: Dict[str, Any] = {"tools": tools}
+
+    if args.tools:
+        invalid = [tool for tool in args.tools if tool not in tools]
+        if invalid:
+            error(f"Unknown tool(s): {', '.join(invalid)}")
+            print(f"Available: {', '.join(tools.keys())}", file=sys.stderr)
+            sys.exit(1)
+        tool_names = args.tools
+    else:
+        tool_names = list(tools.keys())
+
+    print(f"Checking {len(tool_names)} tool(s) for updates...")
+
+    results: List[Dict[str, Any]] = []
+    for name in tool_names:
+        tool_config = tools[name]
+        install_type = tool_config["install_type"]
+
+        if install_type in ("npm", "self_managed"):
+            results.append(check_npm_tool(name, tool_config, args.verbose))
+        elif install_type in ("script", "direct_download"):
+            results.append(check_script_tool(name, tool_config, args.verbose))
+        else:
+            results.append(
+                {
+                    "tool": name,
+                    "type": install_type,
+                    "version": "-",
+                    "date": "-",
+                    "status": f"unknown type: {install_type}",
+                    "update": None,
+                }
+            )
+
+    print_check_results_table(results, verbose=args.verbose)
+
+    version_info_changed = False
+    for result in results:
+        if result["status"] == "error":
+            continue
+        tool_name = result["tool"]
+        version = result.get("version", "-")
+        date = result.get("date", "-")
+        tool_entry = config["tools"][tool_name]
+        if version and version != "-":
+            normalized = normalize_version(version)
+            if tool_entry.get("latest_version") != normalized:
+                tool_entry["latest_version"] = normalized
+                version_info_changed = True
+        if date and date != "-":
+            if tool_entry.get("latest_date") != date:
+                tool_entry["latest_date"] = date
+                version_info_changed = True
+
+    updates = [result for result in results if result["update"]]
+    if not updates:
+        if version_info_changed and not args.dry_run:
+            save_updated_versions(config["tools"])
+            print("Updated latest version info in ~/.config/code-aide/versions.json.")
+        if version_info_changed:
+            print(
+                "No installer checksum updates required "
+                "(latest version metadata was refreshed)."
+            )
+        else:
+            print("No upstream config changes detected.")
+        print(
+            "Note: 'update-versions' checks upstream metadata, not your installed "
+            "binary versions. Use 'code-aide status' and 'code-aide upgrade' "
+            "for local installs."
+        )
+        return
+
+    print(f"{len(updates)} update(s) available:")
+    for result in updates:
+        print(f"  {result['tool']}: SHA256 changed")
+
+    if args.dry_run:
+        print("\nDry run mode - no changes written.")
+        return
+
+    if not args.yes:
+        try:
+            answer = input("\nApply these updates? [y/N] ").strip().lower()
+        except (EOFError, KeyboardInterrupt):
+            print("\nAborted.")
+            return
+        if answer not in ("y", "yes"):
+            if version_info_changed:
+                save_updated_versions(config["tools"])
+                print(
+                    "Updated latest version info in ~/.config/code-aide/versions.json."
+                )
+            else:
+                print("No changes made.")
+            return
+
+    updated = apply_sha256_updates(config, results)
+    save_updated_versions(config["tools"])
+
+    print(f"\nUpdated {len(updated)} tool(s) in ~/.config/code-aide/versions.json:")
+    for name in updated:
+        print(f"  {name}")
+    if version_info_changed:
+        print("Also updated latest version info for checked tools.")
+    print("\nRun 'code-aide status' to see current state.")

code_aide/commands_tools.py

@@ -0,0 +1,183 @@
+"""Read-only CLI commands: list and status."""
+
+import argparse
+import platform
+import shutil
+from typing import List
+
+from code_aide.constants import Colors, PACKAGE_MANAGERS, TOOLS
+from code_aide.detection import (
+    format_install_method,
+    get_system_package_info,
+    detect_install_method,
+)
+from code_aide.console import command_exists, info, warning
+from code_aide.prereqs import detect_package_manager, is_tool_installed
+from code_aide.status import print_system_version_status, get_tool_status
+from code_aide.versions import (
+    extract_version_from_string,
+    status_version_matches_latest,
+    version_is_newer,
+)
+
+
+def cmd_list(args: argparse.Namespace) -> None:
+    """Handle list command."""
+    print("Available AI Coding CLI Tools:")
+    print("=" * 70)
+    print()
+
+    for tool_name, tool_config in TOOLS.items():
+        installed = is_tool_installed(tool_name)
+        status = (
+            f"{Colors.GREEN}✓ Installed{Colors.NC}"
+            if installed
+            else f"{Colors.RED}✗ Not installed{Colors.NC}"
+        )
+
+        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)")
+
+        if installed:
+            tool_path = shutil.which(tool_config["command"])
+            print(f"  Location:     {tool_path}")
+            install_info = detect_install_method(tool_name)
+            print(
+                "  Installed via: "
+                f"{format_install_method(install_info['method'], install_info['detail'])}"
+            )
+
+        if tool_config.get("min_node_version"):
+            print(f"  Requires:     Node.js v{tool_config['min_node_version']}+")
+
+        if not tool_config.get("default_install", True):
+            print(
+                "  Note:         Opt-in only "
+                f"(specify 'code-aide install {tool_name}')"
+            )
+
+        if tool_config.get("docs_url"):
+            print(f"  Docs:         {tool_config['docs_url']}")
+
+        print()
+
+    print("=" * 70)
+    info("System Information:")
+    print(f"  Platform: {platform.system()}")
+
+    if command_exists("npm"):
+        try:
+            from code_aide.console import run_command
+
+            npm_version = run_command(["npm", "--version"]).stdout.strip()
+            print(f"  npm:      {npm_version}")
+        except Exception:
+            pass
+
+    if command_exists("node"):
+        try:
+            from code_aide.console import run_command
+
+            node_version = run_command(["node", "--version"]).stdout.strip()
+            print(f"  Node.js:  {node_version}")
+        except Exception:
+            pass
+
+    pkg_mgr = detect_package_manager()
+    if pkg_mgr:
+        print(
+            f"  Package manager: {PACKAGE_MANAGERS[pkg_mgr]['description']} ({pkg_mgr})"
+        )
+
+
+def cmd_status(args: argparse.Namespace) -> None:
+    """Handle status command."""
+    print("AI Coding CLI Tools Status:")
+    print("=" * 70)
+    print()
+
+    outdated_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)
+
+        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)
+                    print_system_version_status(
+                        status["version"], latest_version, pkg_info
+                    )
+                elif latest_version:
+                    if status_version_matches_latest(status["version"], latest_version):
+                        version_annotation = (
+                            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}"
+                            )
+                            outdated_count += 1
+                    print(version_annotation)
+                else:
+                    print(f"  Version:      {status['version']}")
+
+            if tool_path:
+                print(f"  Location:     {tool_path}")
+                print(
+                    "  Installed via: "
+                    f"{format_install_method(install_info['method'], install_info['detail'])}"
+                )
+
+            if status["user"]:
+                print(f"  User:         {status['user']}")
+
+            if status["usage"]:
+                print(f"  Usage:        {status['usage']}")
+
+            if status["errors"]:
+                for err_msg in status["errors"]:
+                    warning(f"  {err_msg}")
+
+        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:
+        print(
+            f"{Colors.YELLOW}{outdated_count} tool(s) can be upgraded with "
+            f"'code-aide upgrade'.{Colors.NC}"
+        )

code_aide/config.py

@@ -0,0 +1,105 @@
+"""Configuration management for code-aide.
+
+Handles XDG base directory paths, loading bundled tool definitions from
+package data, loading/saving the user's version cache, and merging
+bundled defaults with cached data.
+"""
+
+import importlib.resources
+import json
+import os
+
+
+def get_config_dir() -> str:
+    """Return XDG config directory for code-aide.
+
+    Uses $XDG_CONFIG_HOME/code-aide if set, else ~/.config/code-aide.
+    Creates the directory if it doesn't exist.
+    """
+    xdg = os.environ.get("XDG_CONFIG_HOME", os.path.expanduser("~/.config"))
+    config_dir = os.path.join(xdg, "code-aide")
+    os.makedirs(config_dir, exist_ok=True)
+    return config_dir
+
+
+def get_versions_cache_path() -> str:
+    """Return path to the user's version cache file."""
+    return os.path.join(get_config_dir(), "versions.json")
+
+
+def load_bundled_tools() -> dict:
+    """Load static tool definitions bundled with the package.
+
+    Uses importlib.resources to read src/code_aide/data/tools.json.
+    """
+    ref = importlib.resources.files("code_aide").joinpath("data/tools.json")
+    with importlib.resources.as_file(ref) as path:
+        with open(path) as f:
+            return json.load(f)
+
+
+def load_versions_cache() -> dict:
+    """Load the user's cached version data, or empty dict if none."""
+    cache_path = get_versions_cache_path()
+    if os.path.exists(cache_path):
+        try:
+            with open(cache_path, encoding="utf-8") as f:
+                data = json.load(f)
+            if isinstance(data, dict):
+                return data
+        except (OSError, json.JSONDecodeError, ValueError):
+            pass
+    return {}
+
+
+def save_versions_cache(data: dict) -> None:
+    """Write version data to the user's cache file."""
+    cache_path = get_versions_cache_path()
+    with open(cache_path, "w") as f:
+        json.dump(data, f, indent=2)
+        f.write("\n")
+
+
+DYNAMIC_FIELDS = ["latest_version", "latest_date", "install_sha256"]
+
+
+def merge_cached_versions(tools: dict, cache: dict) -> None:
+    """Merge cached dynamic fields into tool definitions in-place."""
+    cached_tools = cache.get("tools", {})
+    for tool_key, tool_data in tools.items():
+        if tool_key in cached_tools:
+            for field in DYNAMIC_FIELDS:
+                if field in cached_tools[tool_key]:
+                    tool_data[field] = cached_tools[tool_key][field]
+
+
+def load_tools_config() -> dict:
+    """Load tool config: bundled definitions merged with cached versions.
+
+    The bundled tools.json provides all tool definitions plus a baseline
+    for latest_version, latest_date, and install_sha256. The user's
+    version cache (from update-versions) overrides these dynamic fields
+    when present.
+    """
+    bundled = load_bundled_tools()
+    cache = load_versions_cache()
+    tools = bundled.get("tools", {})
+    merge_cached_versions(tools, cache)
+    return tools
+
+
+def save_updated_versions(tools: dict) -> None:
+    """Save only dynamic version fields to the user's cache.
+
+    Called by update-versions command. Only stores latest_version,
+    latest_date, and install_sha256 per tool.
+    """
+    cache_data = {"tools": {}}
+    for tool_key, tool_data in tools.items():
+        entry = {}
+        for field in DYNAMIC_FIELDS:
+            if field in tool_data:
+                entry[field] = tool_data[field]
+        if entry:
+            cache_data["tools"][tool_key] = entry
+    save_versions_cache(cache_data)

code_aide/console.py

@@ -0,0 +1,58 @@
+"""Console output and subprocess helpers for CLI modules."""
+
+import shutil
+import subprocess
+from typing import List, Union
+
+from code_aide.constants import Colors
+
+
+def info(message: str) -> None:
+    """Print info message."""
+    print(f"{Colors.BLUE}[INFO]{Colors.NC} {message}")
+
+
+def success(message: str) -> None:
+    """Print success message."""
+    print(f"{Colors.GREEN}[SUCCESS]{Colors.NC} {message}")
+
+
+def warning(message: str) -> None:
+    """Print warning message."""
+    print(f"{Colors.YELLOW}[WARNING]{Colors.NC} {message}")
+
+
+def error(message: str) -> None:
+    """Print error message."""
+    print(f"{Colors.RED}[ERROR]{Colors.NC} {message}")
+
+
+def command_exists(command: str) -> bool:
+    """Check if a command exists in PATH."""
+    return shutil.which(command) is not None
+
+
+def run_command(
+    cmd: List[str], check: bool = True, capture: bool = True
+) -> Union[subprocess.CompletedProcess, subprocess.CalledProcessError]:
+    """Run a command and return the result."""
+    try:
+        if capture:
+            result = subprocess.run(
+                cmd,
+                check=check,
+                capture_output=True,
+                text=True,
+                stdin=subprocess.DEVNULL,
+            )
+        else:
+            result = subprocess.run(
+                cmd,
+                check=check,
+                stdin=subprocess.DEVNULL,
+            )
+        return result
+    except subprocess.CalledProcessError as exc:
+        if check:
+            raise
+        return exc