code-aide 1.0.0__py3-none-any.whl

code_aide/prereqs.py

@@ -0,0 +1,179 @@
+"""Prerequisite and environment checks for tool installation."""
+
+import os
+import platform
+import subprocess
+import sys
+from typing import List, Optional
+
+from code_aide.constants import PACKAGE_MANAGERS, TOOLS
+from code_aide.console import (
+    command_exists,
+    error,
+    info,
+    run_command,
+    success,
+    warning,
+)
+
+
+def detect_package_manager() -> Optional[str]:
+    """Detect the Linux distribution and return package manager name."""
+    if platform.system() != "Linux":
+        return None
+
+    for pkg_mgr_name, config in PACKAGE_MANAGERS.items():
+        if command_exists(config["detect_command"]):
+            return pkg_mgr_name
+
+    return None
+
+
+def install_nodejs_npm() -> bool:
+    """Install Node.js and npm using the system package manager."""
+    pkg_mgr_name = detect_package_manager()
+
+    if not pkg_mgr_name:
+        error("Could not detect package manager. Please install Node.js manually:")
+        for manager_name, config in PACKAGE_MANAGERS.items():
+            install_cmd = " ".join(config["install_command"] + config["packages"])
+            print(f"  {config['description']}: {install_cmd}")
+        print("  Or visit: https://nodejs.org/")
+        return False
+
+    config = PACKAGE_MANAGERS[pkg_mgr_name]
+    info(f"Detected package manager: {pkg_mgr_name} ({config['description']})")
+    info("Installing Node.js and npm...")
+
+    try:
+        for pre_cmd in config["pre_install"]:
+            info(f"Running: {' '.join(pre_cmd)}")
+            run_command(pre_cmd, check=True, capture=False)
+
+        install_cmd = config["install_command"] + config["packages"]
+        run_command(install_cmd, check=True, capture=False)
+
+        if not command_exists("npm"):
+            error("npm installation completed but npm command not found in PATH")
+            error("You may need to restart your shell or add npm to your PATH")
+            return False
+
+        success("Node.js and npm installed successfully")
+        return True
+    except subprocess.CalledProcessError as exc:
+        stderr_msg = (
+            getattr(exc, "stderr", None) or getattr(exc, "stdout", None) or str(exc)
+        )
+        error(f"Failed to install Node.js and npm: {stderr_msg}")
+        return False
+    except Exception as exc:
+        error(f"Failed to install Node.js and npm: {exc}")
+        return False
+
+
+def check_prerequisites(
+    tools_to_install: List[str], install_prereqs: bool = False
+) -> None:
+    """Check if prerequisites are met, optionally installing them."""
+    needed_prereqs = set()
+    tools_needing_node = []
+
+    for tool_name in tools_to_install:
+        tool_config = TOOLS.get(tool_name)
+        if not tool_config:
+            continue
+
+        needed_prereqs.update(tool_config.get("prerequisites", []))
+        if tool_config.get("min_node_version"):
+            tools_needing_node.append((tool_name, tool_config["min_node_version"]))
+
+    if "npm" in needed_prereqs:
+        if not command_exists("npm"):
+            if install_prereqs:
+                info("npm not found, attempting to install prerequisites...")
+                if not install_nodejs_npm():
+                    sys.exit(1)
+            else:
+                error("npm is required but not installed.")
+                error("Please install Node.js and npm first:")
+                for manager_name, config in PACKAGE_MANAGERS.items():
+                    install_cmd = " ".join(
+                        config["install_command"] + config["packages"]
+                    )
+                    print(f"  {config['description']}: {install_cmd}")
+                print("  Or visit: https://nodejs.org/")
+                print("\nOr use -p/--install-prerequisites to install automatically")
+                sys.exit(1)
+
+        try:
+            npm_version = run_command(["npm", "--version"]).stdout.strip()
+            info(f"Prerequisites check passed (npm found: {npm_version})")
+        except subprocess.CalledProcessError:
+            error("Failed to check npm version")
+            sys.exit(1)
+
+    for tool_name, min_version in tools_needing_node:
+        try:
+            node_version_output = run_command(["node", "--version"]).stdout.strip()
+            version_str = node_version_output.lstrip("v")
+            version_parts = version_str.replace("-", ".").split(".")
+            if not version_parts or not version_parts[0].isdigit():
+                raise ValueError(f"Invalid version format: {node_version_output}")
+            node_major_version = int(version_parts[0])
+            if node_major_version < min_version:
+                if install_prereqs:
+                    warning(
+                        f"Node.js version {node_version_output} is below v{min_version} "
+                        f"required for {TOOLS[tool_name]['name']}"
+                    )
+                    warning(
+                        "You may need to upgrade Node.js manually or use a Node "
+                        "version manager"
+                    )
+                    warning("See: https://nodejs.org/ or https://github.com/nvm-sh/nvm")
+                else:
+                    error(
+                        f"{TOOLS[tool_name]['name']} requires Node.js version "
+                        f"{min_version} or higher."
+                    )
+                    error(f"Current version: {node_version_output}")
+                    error("Please upgrade Node.js: https://nodejs.org/")
+                    sys.exit(1)
+        except (subprocess.CalledProcessError, ValueError, IndexError) as exc:
+            error(f"Failed to check Node.js version: {exc}")
+            sys.exit(1)
+
+
+def is_tool_installed(tool_name: str) -> bool:
+    """Check if a tool is installed."""
+    tool_config = TOOLS.get(tool_name)
+    if not tool_config:
+        return False
+    return command_exists(tool_config["command"])
+
+
+def check_path_directories() -> None:
+    """Check if common binary installation directories are in PATH and warn if not."""
+    current_path = os.environ.get("PATH", "")
+    path_entries = current_path.split(":")
+
+    common_dirs = [
+        os.path.expanduser("~/.local/bin"),
+        os.path.expanduser("~/.npm-packages/bin"),
+        os.path.expanduser("~/.amp/bin"),
+    ]
+
+    missing_dirs = []
+    for dir_path in common_dirs:
+        if dir_path not in path_entries and os.path.isdir(dir_path):
+            missing_dirs.append(dir_path)
+
+    if missing_dirs:
+        warning("The following directories exist but are not in your PATH:")
+        for dir_path in missing_dirs:
+            print(f"  {dir_path}")
+        print()
+        print("To use installed tools, add to ~/.bashrc or ~/.zshrc:")
+        for dir_path in missing_dirs:
+            print(f'    export PATH="{dir_path}:$PATH"')
+        print()

code_aide/status.py

@@ -0,0 +1,86 @@
+"""Status helpers for installed tools and version reporting."""
+
+import subprocess
+from typing import Any, Dict, Optional
+
+from code_aide.constants import Colors
+from code_aide.prereqs import is_tool_installed
+from code_aide.versions import (
+    extract_version_from_string,
+    normalize_version,
+    status_version_matches_latest,
+    version_is_newer,
+)
+
+
+def print_system_version_status(
+    cli_version: str,
+    latest_version: Optional[str],
+    pkg_info: Dict[str, Optional[str]],
+) -> None:
+    """Print version status for a system-package-managed tool."""
+    installed_ver = extract_version_from_string(cli_version)
+    avail_ver = pkg_info.get("available_version")
+    avail_date = pkg_info.get("available_date")
+
+    pkg_up_to_date = True
+    if installed_ver and avail_ver:
+        pkg_up_to_date = installed_ver == normalize_version(
+            avail_ver
+        ) or version_is_newer(installed_ver, normalize_version(avail_ver))
+
+    if pkg_up_to_date:
+        print(f"  Version:      {cli_version} {Colors.GREEN}(up to date){Colors.NC}")
+    else:
+        print(
+            f"  Version:      {cli_version} {Colors.YELLOW}(package has {avail_ver})"
+            f"{Colors.NC}"
+        )
+
+    if avail_ver:
+        date_suffix = f", {avail_date}" if avail_date else ""
+        pkg_name = pkg_info.get("package") or "system"
+        if latest_version and not status_version_matches_latest(
+            avail_ver, latest_version
+        ):
+            print(
+                f"  Packaged:     {avail_ver} ({pkg_name}{date_suffix}) "
+                f"{Colors.YELLOW}(upstream: {latest_version}){Colors.NC}"
+            )
+        else:
+            print(f"  Packaged:     {avail_ver} ({pkg_name}{date_suffix})")
+
+
+def get_tool_status(tool_name: str, tool_config: Dict[str, Any]) -> Dict[str, Any]:
+    """Get status information for a specific tool."""
+    status_info = {
+        "installed": is_tool_installed(tool_name),
+        "version": None,
+        "user": None,
+        "usage": None,
+        "errors": [],
+    }
+
+    if not status_info["installed"]:
+        return status_info
+
+    command = tool_config["command"]
+    version_args = tool_config.get("version_args", ["--version"])
+    cmd = [command] + version_args
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=10,
+            check=False,
+            stdin=subprocess.DEVNULL,
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            status_info["version"] = result.stdout.strip().split("\n")[0]
+    except subprocess.TimeoutExpired:
+        status_info["errors"].append("Version check timed out after 10s")
+    except Exception:
+        pass
+
+    return status_info

code_aide/versions.py

@@ -0,0 +1,356 @@
+"""Version parsing and upstream update-check helpers."""
+
+import email.utils
+import hashlib
+import json
+import re
+import urllib.request
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+from code_aide import __version__
+from code_aide.constants import Colors
+
+
+def fetch_url(url: str, timeout: int = 30) -> tuple:
+    """Fetch content from a URL. Returns (bytes, last_modified_str)."""
+    req = urllib.request.Request(
+        url, headers={"User-Agent": f"code-aide/{__version__}"}
+    )
+    with urllib.request.urlopen(req, timeout=timeout) as response:
+        content = response.read()
+        last_modified = response.headers.get("Last-Modified")
+        return content, last_modified
+
+
+def parse_http_date(date_str: Optional[str]) -> Optional[str]:
+    """Parse an HTTP date header into YYYY-MM-DD format."""
+    if not date_str:
+        return None
+    try:
+        parsed = email.utils.parsedate_to_datetime(date_str)
+        return parsed.strftime("%Y-%m-%d")
+    except Exception:
+        return None
+
+
+def parse_iso_date(date_str: Optional[str]) -> Optional[str]:
+    """Parse an ISO 8601 date string into YYYY-MM-DD format."""
+    if not date_str:
+        return None
+    try:
+        dt = datetime.fromisoformat(date_str.replace("Z", "+00:00"))
+        return dt.strftime("%Y-%m-%d")
+    except Exception:
+        return None
+
+
+def normalize_version(version: str) -> str:
+    """Normalize a version string for storage and comparison."""
+    return version.lstrip("v")
+
+
+def status_version_matches_latest(status_version: str, latest_version: str) -> bool:
+    """Return True when a tool-reported version string matches latest_version."""
+    if not status_version or not latest_version:
+        return False
+
+    latest_norm = normalize_version(latest_version.strip())
+    status_text = status_version.strip()
+
+    if normalize_version(status_text) == latest_norm:
+        return True
+
+    patterns = [
+        r"\d{4}\.\d{2}\.\d{2}-[0-9a-f]+",
+        r"[vV]?\d+(?:\.\d+)+(?:[-+][0-9A-Za-z._-]+)?",
+    ]
+    for pattern in patterns:
+        for match in re.finditer(pattern, status_text):
+            if normalize_version(match.group(0)) == latest_norm:
+                return True
+
+    return False
+
+
+def extract_version_from_string(version_string: str) -> Optional[str]:
+    """Extract a normalized version number from a tool version output string."""
+    if not version_string:
+        return None
+
+    text = version_string.strip()
+
+    normalized = normalize_version(text)
+    if re.match(r"^\d+(?:\.\d+)+$", normalized):
+        return normalized
+
+    patterns = [
+        r"\d{4}\.\d{2}\.\d{2}-[0-9a-f]+",
+        r"[vV]?\d+(?:\.\d+)+(?:[-+][0-9A-Za-z._-]+)?",
+    ]
+    for pattern in patterns:
+        match = re.search(pattern, text)
+        if match:
+            return normalize_version(match.group(0))
+
+    return None
+
+
+def version_is_newer(version_a: str, version_b: str) -> bool:
+    """Return True if version_a is strictly newer than version_b."""
+
+    def parse_components(version: str) -> list:
+        parts = re.split(r"[.\-]", version)
+        result = []
+        for part in parts:
+            try:
+                result.append((0, int(part)))
+            except ValueError:
+                result.append((1, part))
+        return result
+
+    a_parts = parse_components(version_a)
+    b_parts = parse_components(version_b)
+
+    return a_parts > b_parts
+
+
+def check_npm_tool(
+    tool_name: str, tool_config: Dict[str, Any], verbose: bool = False
+) -> Dict[str, Any]:
+    """Check an npm tool for the latest version and publish date."""
+    package = tool_config["npm_package"]
+    result: Dict[str, Any] = {
+        "tool": tool_name,
+        "type": "npm",
+        "version": "-",
+        "date": "-",
+        "status": "unknown",
+        "update": None,
+    }
+
+    try:
+        url = f"https://registry.npmjs.org/{package}"
+        raw, _ = fetch_url(url)
+        data = json.loads(raw)
+
+        latest_version = data.get("dist-tags", {}).get("latest", "?")
+        result["version"] = latest_version
+
+        time_info = data.get("time", {})
+        publish_date = time_info.get(latest_version)
+        if publish_date:
+            result["date"] = parse_iso_date(publish_date) or "-"
+
+        result["status"] = "ok"
+    except Exception as exc:
+        result["status"] = "error"
+        if verbose:
+            result["version"] = f"error: {exc}"
+
+    return result
+
+
+def extract_script_date(
+    version_info: Optional[str], last_modified: Optional[str]
+) -> Optional[str]:
+    """Extract a date from a script tool's version string or HTTP header."""
+    if version_info:
+        epoch_match = re.search(r"\.(\d{10,})", version_info)
+        if epoch_match:
+            try:
+                dt = datetime.fromtimestamp(int(epoch_match.group(1)), tz=timezone.utc)
+                return dt.strftime("%Y-%m-%d")
+            except (ValueError, OSError):
+                pass
+        match = re.match(r"(\d{4})\.(\d{2})\.(\d{2})", version_info)
+        if match:
+            return f"{match.group(1)}-{match.group(2)}-{match.group(3)}"
+    return parse_http_date(last_modified)
+
+
+def extract_script_version(
+    tool_name: str,
+    tool_config: Dict[str, Any],
+    script_content: bytes,
+) -> Optional[str]:
+    """Try to extract a version string from script content or version URL."""
+    version_url = tool_config.get("version_url")
+    if version_url:
+        try:
+            version_data, _ = fetch_url(version_url)
+            version_str = version_data.decode("utf-8").strip()
+            if "<" not in version_str and len(version_str) < 50:
+                if not version_str.startswith("v"):
+                    version_str = f"v{version_str}"
+                return version_str
+        except Exception:
+            pass
+
+    text = script_content.decode("utf-8", errors="replace")
+
+    if tool_name == "cursor":
+        match = re.search(r"(\d{4}\.\d{2}\.\d{2}-[0-9a-f]+)", text)
+        if match:
+            return match.group(1)
+
+    for pattern in [
+        r'VERSION="([^"]+)"',
+        r"VERSION='([^']+)'",
+        r"VERSION=(\S+)",
+    ]:
+        match = re.search(pattern, text)
+        if match:
+            return match.group(1)
+
+    return None
+
+
+def check_script_tool(
+    tool_name: str, tool_config: Dict[str, Any], verbose: bool = False
+) -> Dict[str, Any]:
+    """Check a script/direct_download tool for SHA256 changes, version, and date."""
+    install_url = tool_config["install_url"]
+    current_sha256 = tool_config.get("install_sha256", "")
+
+    result: Dict[str, Any] = {
+        "tool": tool_name,
+        "type": tool_config.get("install_type", "script"),
+        "version": "-",
+        "date": "-",
+        "sha256_current": current_sha256[:12] + "..." if current_sha256 else "none",
+        "sha256_latest": "-",
+        "status": "unknown",
+        "update": None,
+    }
+
+    try:
+        script_content, last_modified = fetch_url(install_url)
+        actual_sha256 = hashlib.sha256(script_content).hexdigest()
+
+        if verbose:
+            result["sha256_current"] = current_sha256 or "none"
+            result["sha256_latest"] = actual_sha256
+        else:
+            result["sha256_latest"] = actual_sha256[:12] + "..."
+
+        version_info = extract_script_version(tool_name, tool_config, script_content)
+        if version_info:
+            result["version"] = version_info
+
+        date_str = extract_script_date(version_info, last_modified)
+        if date_str:
+            result["date"] = date_str
+
+        if actual_sha256 == current_sha256:
+            result["status"] = "ok"
+        else:
+            result["status"] = "changed"
+            result["update"] = {"install_sha256": actual_sha256}
+
+    except Exception as exc:
+        result["status"] = "error"
+        if verbose:
+            result["version"] = f"error: {exc}"
+
+    return result
+
+
+def format_check_status(status: str) -> str:
+    """Format an update-check status string with color."""
+    if status == "ok":
+        return f"{Colors.GREEN}ok{Colors.NC}"
+    if status == "changed":
+        return f"{Colors.YELLOW}changed{Colors.NC}"
+    if status == "error":
+        return f"{Colors.RED}error{Colors.NC}"
+    return status
+
+
+def format_check_backend(check_type: str) -> str:
+    """Format update-check backend labels for display."""
+    if check_type == "npm":
+        return "npm-registry"
+    if check_type in ("script", "direct_download"):
+        return "script-url"
+    if check_type == "self_managed":
+        return "npm-registry"
+    return check_type
+
+
+def print_check_results_table(
+    results: List[Dict[str, Any]], verbose: bool = False
+) -> None:
+    """Print update-check results as a formatted table."""
+    if verbose:
+        headers = [
+            "Tool",
+            "Check",
+            "Version",
+            "Date",
+            "Current SHA256",
+            "Latest SHA256",
+            "Status",
+        ]
+    else:
+        headers = ["Tool", "Check", "Version", "Date", "Status"]
+
+    rows = []
+    for result in results:
+        if verbose:
+            rows.append(
+                [
+                    result["tool"],
+                    format_check_backend(result["type"]),
+                    result.get("version", "-"),
+                    result.get("date", "-"),
+                    result.get("sha256_current", "-"),
+                    result.get("sha256_latest", "-"),
+                    result["status"],
+                ]
+            )
+        else:
+            rows.append(
+                [
+                    result["tool"],
+                    format_check_backend(result["type"]),
+                    result.get("version", "-"),
+                    result.get("date", "-"),
+                    result["status"],
+                ]
+            )
+
+    widths = [len(header) for header in headers]
+    for row in rows:
+        for i, cell in enumerate(row):
+            plain = re.sub(r"\033\[[^m]*m", "", str(cell))
+            widths[i] = max(widths[i], len(plain))
+
+    header_line = "  ".join(header.ljust(widths[i]) for i, header in enumerate(headers))
+    print(f"\n{Colors.BOLD}{header_line}{Colors.NC}")
+    print("  ".join("-" * width for width in widths))
+
+    for row in rows:
+        cells = []
+        for i, cell in enumerate(row):
+            if i == len(row) - 1:
+                cells.append(format_check_status(cell))
+            else:
+                cells.append(str(cell).ljust(widths[i]))
+        print("  ".join(cells))
+
+    print()
+
+
+def apply_sha256_updates(
+    config: Dict[str, Any], results: List[Dict[str, Any]]
+) -> List[str]:
+    """Apply pending SHA256 updates to the config dict."""
+    updated = []
+    for result in results:
+        if result["update"]:
+            tool_name = result["tool"]
+            for key, value in result["update"].items():
+                config["tools"][tool_name][key] = value
+            updated.append(tool_name)
+    return updated