code-aide 1.0.0__py3-none-any.whl

code_aide/constants.py

@@ -0,0 +1,63 @@
+"""Shared constants and mutable tool configuration for CLI modules."""
+
+from typing import Any, Dict
+
+from code_aide.config import load_tools_config
+
+
+class Colors:
+    RED = "\033[0;31m"
+    GREEN = "\033[0;32m"
+    YELLOW = "\033[1;33m"
+    BLUE = "\033[0;34m"
+    BOLD = "\033[1m"
+    NC = "\033[0m"
+
+
+PACKAGE_MANAGERS: Dict[str, Dict[str, Any]] = {
+    "apt-get": {
+        "detect_command": "apt-get",
+        "packages": ["nodejs", "npm"],
+        "pre_install": [["sudo", "apt-get", "update"]],
+        "install_command": ["sudo", "apt-get", "install", "-y"],
+        "description": "Debian/Ubuntu",
+    },
+    "dnf": {
+        "detect_command": "dnf",
+        "packages": ["nodejs", "npm"],
+        "pre_install": [],
+        "install_command": ["sudo", "dnf", "install", "-y"],
+        "description": "Fedora/RHEL 8+",
+    },
+    "yum": {
+        "detect_command": "yum",
+        "packages": ["nodejs", "npm"],
+        "pre_install": [],
+        "install_command": ["sudo", "yum", "install", "-y"],
+        "description": "RHEL/CentOS 7",
+    },
+    "pacman": {
+        "detect_command": "pacman",
+        "packages": ["nodejs", "npm"],
+        "pre_install": [],
+        "install_command": ["sudo", "pacman", "-S", "--noconfirm"],
+        "description": "Arch Linux",
+    },
+    "zypper": {
+        "detect_command": "zypper",
+        "packages": ["nodejs", "npm"],
+        "pre_install": [],
+        "install_command": ["sudo", "zypper", "install", "-y"],
+        "description": "openSUSE",
+    },
+    "emerge": {
+        "detect_command": "emerge",
+        "packages": ["net-libs/nodejs"],
+        "pre_install": [],
+        "install_command": ["sudo", "emerge", "--quiet-build"],
+        "description": "Gentoo",
+    },
+}
+
+
+TOOLS: Dict[str, Dict[str, Any]] = load_tools_config()

code_aide/data/tools.json

@@ -0,0 +1,100 @@
+{
+  "schema_version": 1,
+  "tools": {
+    "cursor": {
+      "name": "Cursor CLI",
+      "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",
+      "symlinks": {
+        "agent": "cursor-agent",
+        "cursor-agent": "cursor-agent"
+      },
+      "prerequisites": [],
+      "min_node_version": null,
+      "next_steps": "Run 'agent login' to authenticate",
+      "version_args": [
+        "--version"
+      ],
+      "docs_url": "https://docs.cursor.com/",
+      "default_install": true,
+      "latest_version": "2026.02.27-e7d2ef6",
+      "latest_date": "2026-02-27"
+    },
+    "claude": {
+      "name": "Claude CLI (Claude Code)",
+      "command": "claude",
+      "install_type": "self_managed",
+      "npm_package": "@anthropic-ai/claude-code",
+      "upgrade_command": ["claude", "upgrade"],
+      "prerequisites": ["npm"],
+      "min_node_version": null,
+      "next_steps": "Run 'claude' and then use '/login' to authenticate",
+      "version_args": [
+        "--version"
+      ],
+      "docs_url": "https://docs.anthropic.com/en/docs/build-with-claude/claude-code",
+      "default_install": true,
+      "latest_version": "2.1.62",
+      "latest_date": "2026-02-27"
+    },
+    "gemini": {
+      "name": "Gemini CLI",
+      "command": "gemini",
+      "install_type": "npm",
+      "npm_package": "@google/gemini-cli",
+      "prerequisites": [
+        "npm"
+      ],
+      "min_node_version": 20,
+      "next_steps": "Run 'gemini' and choose 'Login with Google' to authenticate",
+      "version_args": [
+        "--version"
+      ],
+      "docs_url": "https://github.com/google-gemini/gemini-cli",
+      "default_install": true,
+      "latest_version": "0.30.1",
+      "latest_date": "2026-02-27"
+    },
+    "amp": {
+      "name": "Amp (Sourcegraph)",
+      "command": "amp",
+      "install_type": "script",
+      "install_url": "https://ampcode.com/install.sh",
+      "install_sha256": "852b48bf67bfe0494d1e3536eacbf8f4607617c111921c804b4199a5888a44a4",
+      "version_url": "https://storage.googleapis.com/amp-public-assets-prod-0/cli/cli-version.txt",
+      "prerequisites": [],
+      "min_node_version": null,
+      "next_steps": "Run 'amp login' to authenticate",
+      "version_args": [
+        "--version"
+      ],
+      "docs_url": "https://ampcode.com/manual",
+      "default_install": false,
+      "latest_version": "0.0.1772222620-g1de875",
+      "latest_date": "2026-02-27"
+    },
+    "codex": {
+      "name": "Codex CLI",
+      "command": "codex",
+      "install_type": "npm",
+      "npm_package": "@openai/codex",
+      "prerequisites": [
+        "npm"
+      ],
+      "min_node_version": 22,
+      "next_steps": "Run 'codex' to start",
+      "version_args": [
+        "--version"
+      ],
+      "docs_url": "https://github.com/openai/codex",
+      "default_install": false,
+      "latest_version": "0.106.0",
+      "latest_date": "2026-02-26"
+    }
+  }
+}

code_aide/detection.py

@@ -0,0 +1,184 @@
+"""Install-method and system package detection helpers."""
+
+import glob as globmod
+import os
+import re
+import shutil
+import subprocess
+from datetime import datetime, timezone
+from typing import Dict, Optional
+
+from code_aide.constants import TOOLS
+from code_aide.console import command_exists
+
+
+def detect_install_method(tool_name: str) -> Dict[str, Optional[str]]:
+    """Detect how a tool was actually installed."""
+    tool_config = TOOLS.get(tool_name)
+    if not tool_config:
+        return {"method": None, "detail": None}
+
+    command_path = shutil.which(tool_config["command"])
+    if not command_path:
+        return {"method": None, "detail": None}
+
+    real_path = os.path.realpath(command_path)
+
+    cellar_match = re.search(r"/Cellar/([^/]+)/", real_path)
+    if cellar_match:
+        return {"method": "brew_formula", "detail": cellar_match.group(1)}
+
+    caskroom_match = re.search(r"/Caskroom/([^/]+)/", real_path)
+    if caskroom_match:
+        return {"method": "brew_cask", "detail": caskroom_match.group(1)}
+
+    if "/node_modules/" in real_path:
+        npm_package = tool_config.get("npm_package")
+        if not npm_package:
+            match = re.search(r"/node_modules/((?:@[^/]+/)?[^/]+)", real_path)
+            if match:
+                npm_package = match.group(1)
+
+        if command_path.startswith("/opt/homebrew/bin/") or command_path.startswith(
+            "/usr/local/bin/"
+        ):
+            return {"method": "brew_npm", "detail": npm_package}
+
+        return {"method": "npm", "detail": npm_package}
+
+    system_prefixes = ("/opt/", "/usr/bin/", "/usr/sbin/", "/usr/local/bin/")
+    if any(real_path.startswith(prefix) for prefix in system_prefixes):
+        return {"method": "system", "detail": real_path}
+
+    return {"method": tool_config["install_type"], "detail": None}
+
+
+def get_system_package_info(binary_path: str) -> Dict[str, Optional[str]]:
+    """Get package version info for a system-installed binary."""
+    result: Dict[str, Optional[str]] = {
+        "package": None,
+        "installed_version": None,
+        "available_version": None,
+        "available_date": None,
+    }
+
+    if not command_exists("qfile"):
+        return result
+
+    try:
+        proc = subprocess.run(
+            ["qfile", "-qC", binary_path],
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=False,
+            stdin=subprocess.DEVNULL,
+        )
+        if proc.returncode != 0 or not proc.stdout.strip():
+            return result
+        package = proc.stdout.strip().split("\n")[0]
+        result["package"] = package
+    except Exception:
+        return result
+
+    try:
+        proc = subprocess.run(
+            ["qlist", "-Iv", package],
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=False,
+            stdin=subprocess.DEVNULL,
+        )
+        if proc.returncode == 0 and proc.stdout.strip():
+            installed_cpv = proc.stdout.strip().split("\n")[0]
+            proc2 = subprocess.run(
+                ["qatom", "-F", "%{PV}", installed_cpv],
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
+                stdin=subprocess.DEVNULL,
+            )
+            if proc2.returncode == 0 and proc2.stdout.strip():
+                result["installed_version"] = proc2.stdout.strip()
+    except Exception:
+        pass
+
+    category, package_name = package.split("/", 1)
+    ebuild_dirs = globmod.glob(f"/var/db/repos/*/{category}/{package_name}/")
+    ebuilds = []
+    for ebuild_dir in ebuild_dirs:
+        for entry in os.listdir(ebuild_dir):
+            if entry.endswith(".ebuild") and entry.startswith(f"{package_name}-"):
+                version = entry[len(f"{package_name}-") : -len(".ebuild")]
+                ebuild_path = os.path.join(ebuild_dir, entry)
+                ebuilds.append((version, ebuild_path))
+
+    if ebuilds:
+        best_version = None
+        best_path = None
+        for version, path in ebuilds:
+            if best_version is None:
+                best_version = version
+                best_path = path
+                continue
+            try:
+                proc = subprocess.run(
+                    [
+                        "qatom",
+                        "-c",
+                        f"{package}-{version}",
+                        f"{package}-{best_version}",
+                    ],
+                    capture_output=True,
+                    text=True,
+                    timeout=5,
+                    check=False,
+                    stdin=subprocess.DEVNULL,
+                )
+                if proc.returncode == 0 and ">" in proc.stdout:
+                    best_version = version
+                    best_path = path
+            except Exception:
+                pass
+
+        if best_version:
+            result["available_version"] = best_version
+        if best_path:
+            try:
+                mtime = os.path.getmtime(best_path)
+                result["available_date"] = datetime.fromtimestamp(
+                    mtime, tz=timezone.utc
+                ).strftime("%Y-%m-%d")
+            except Exception:
+                pass
+
+    return result
+
+
+def format_install_method(method: Optional[str], detail: Optional[str]) -> str:
+    """Format detected local install method for display."""
+    if method == "brew_formula":
+        return f"Homebrew formula ({detail})" if detail else "Homebrew formula"
+    if method == "brew_cask":
+        return f"Homebrew cask ({detail})" if detail else "Homebrew cask"
+    if method == "npm":
+        return f"npm ({detail})" if detail else "npm"
+    if method == "brew_npm":
+        return (
+            f"Homebrew prefix npm-global ({detail})"
+            if detail
+            else "Homebrew prefix npm-global"
+        )
+    if method == "system":
+        return f"system package ({detail})" if detail else "system package"
+    if method == "script":
+        return "script"
+    if method == "direct_download":
+        return "direct download"
+    if method == "self_managed":
+        return "self-managed"
+    if method:
+        return method
+    return "unknown"

code_aide/entry.py

@@ -0,0 +1,112 @@
+"""Argument parser and CLI entrypoint."""
+
+import argparse
+
+from code_aide import __version__
+from code_aide.commands_actions import (
+    cmd_install,
+    cmd_remove,
+    cmd_update_versions,
+    cmd_upgrade,
+)
+from code_aide.commands_tools import cmd_list, cmd_status
+from code_aide.constants import TOOLS
+
+
+def main() -> None:
+    """Main function."""
+    available_tools = ", ".join(TOOLS.keys())
+    parser = argparse.ArgumentParser(
+        description="Manage AI coding CLI tools",
+        epilog=f"Available tools: {available_tools}",
+    )
+    parser.add_argument(
+        "--version", action="version", version=f"%(prog)s {__version__}"
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Command to execute")
+
+    list_parser = subparsers.add_parser(
+        "list", help="List available tools and their status"
+    )
+    list_parser.set_defaults(func=cmd_list)
+
+    status_parser = subparsers.add_parser(
+        "status", help="Show detailed status for installed tools"
+    )
+    status_parser.set_defaults(func=cmd_status)
+
+    install_parser = subparsers.add_parser("install", help="Install tools")
+    install_parser.add_argument(
+        "tools",
+        nargs="*",
+        choices=list(TOOLS.keys()),
+        help="Tools to install (default: all)",
+    )
+    install_parser.add_argument(
+        "-p",
+        "--install-prerequisites",
+        action="store_true",
+        help="Automatically install prerequisites (Node.js, npm) "
+        "using system package manager",
+    )
+    install_parser.add_argument(
+        "-n",
+        "--dryrun",
+        action="store_true",
+        help="Verify SHA256 checksums without installing (dry run mode)",
+    )
+    install_parser.set_defaults(func=cmd_install)
+
+    upgrade_parser = subparsers.add_parser("upgrade", help="Upgrade tools")
+    upgrade_parser.add_argument(
+        "tools",
+        nargs="*",
+        choices=list(TOOLS.keys()),
+        help="Tools to upgrade (default: all)",
+    )
+    upgrade_parser.set_defaults(func=cmd_upgrade)
+
+    remove_parser = subparsers.add_parser("remove", help="Remove tools")
+    remove_parser.add_argument(
+        "tools",
+        nargs="*",
+        choices=list(TOOLS.keys()),
+        help="Tools to remove (default: all)",
+    )
+    remove_parser.set_defaults(func=cmd_remove)
+
+    update_versions_parser = subparsers.add_parser(
+        "update-versions",
+        help="Check upstream sources for latest tool versions",
+    )
+    update_versions_parser.add_argument(
+        "tools",
+        nargs="*",
+        help="Specific tools to check (default: all)",
+    )
+    update_versions_parser.add_argument(
+        "-n",
+        "--dry-run",
+        action="store_true",
+        help="Show changes only, do not write updates",
+    )
+    update_versions_parser.add_argument(
+        "-y",
+        "--yes",
+        action="store_true",
+        help="Auto-apply updates without prompting",
+    )
+    update_versions_parser.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="Show full SHA256 hashes",
+    )
+    update_versions_parser.set_defaults(func=cmd_update_versions)
+
+    args = parser.parse_args()
+    if not args.command:
+        cmd_status(args)
+    else:
+        args.func(args)