code-aide 1.17.0__tar.gz → 1.18.1__tar.gz

code_aide-1.18.1/CLAUDE.md

@@ -0,0 +1 @@
+@AGENTS.md

{code_aide-1.17.0 → code_aide-1.18.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-aide
-Version: 1.17.0
+Version: 1.18.1
 Summary: Manage AI coding CLI tools (Claude, Antigravity, Copilot, Cursor, Gemini, Amp, Codex)
 Project-URL: Homepage, https://github.com/dajobe/code-aide
 Project-URL: Repository, https://github.com/dajobe/code-aide
@@ -49,6 +49,9 @@ pipx install code-aide
 ## Usage
 
 ```bash
+# Show compact one-line-per-tool status (default when no command is given)
+code-aide
+
 # List available tools and their status
 code-aide list
 
@@ -67,6 +70,9 @@ code-aide install
 # Install with automatic prerequisite installation (Node.js, npm)
 code-aide install -p
 
+# Verify checksums and show what would be installed, without installing
+code-aide install -n
+
 # Upgrade installed tools (no args = only out-of-date tools)
 code-aide upgrade [NAMES]
 
@@ -79,6 +85,9 @@ code-aide remove -n
 # Remove all managed tools without prompting
 code-aide remove -y
 
+# Remove stale version directories of direct-download tools
+code-aide clean [NAMES]
+
 # Check upstream for latest versions (dry-run)
 code-aide update-versions -n
 
@@ -163,6 +172,15 @@ consulted when the relevant install method or platform applies.
 - PATH configuration validation and warnings
 - Supports Linux and macOS
 
+## Configuration
+
+- Tool definitions are bundled at `src/code_aide/data/tools.json`.
+- The version cache lives at `~/.config/code-aide/versions.json` by default; set
+  `XDG_CONFIG_HOME` to relocate the `code-aide` config directory.
+- Color output honors `NO_COLOR`, `FORCE_COLOR`, `CLICOLOR_FORCE`, `CLICOLOR=0`,
+  and `TERM=dumb`, in that priority order; color is disabled when stdout is not
+  a terminal.
+
 ## Requirements
 
 - Python 3.11+

{code_aide-1.17.0 → code_aide-1.18.1}/README.md

@@ -22,6 +22,9 @@ pipx install code-aide
 ## Usage
 
 ```bash
+# Show compact one-line-per-tool status (default when no command is given)
+code-aide
+
 # List available tools and their status
 code-aide list
 
@@ -40,6 +43,9 @@ code-aide install
 # Install with automatic prerequisite installation (Node.js, npm)
 code-aide install -p
 
+# Verify checksums and show what would be installed, without installing
+code-aide install -n
+
 # Upgrade installed tools (no args = only out-of-date tools)
 code-aide upgrade [NAMES]
 
@@ -52,6 +58,9 @@ code-aide remove -n
 # Remove all managed tools without prompting
 code-aide remove -y
 
+# Remove stale version directories of direct-download tools
+code-aide clean [NAMES]
+
 # Check upstream for latest versions (dry-run)
 code-aide update-versions -n
 
@@ -136,6 +145,15 @@ consulted when the relevant install method or platform applies.
 - PATH configuration validation and warnings
 - Supports Linux and macOS
 
+## Configuration
+
+- Tool definitions are bundled at `src/code_aide/data/tools.json`.
+- The version cache lives at `~/.config/code-aide/versions.json` by default; set
+  `XDG_CONFIG_HOME` to relocate the `code-aide` config directory.
+- Color output honors `NO_COLOR`, `FORCE_COLOR`, `CLICOLOR_FORCE`, `CLICOLOR=0`,
+  and `TERM=dumb`, in that priority order; color is disabled when stdout is not
+  a terminal.
+
 ## Requirements
 
 - Python 3.11+

code_aide-1.18.1/TODO.md

@@ -0,0 +1,30 @@
+# TODO
+
+Keep the project focused on managing AI coding CLI tools (install, upgrade,
+remove, status, and version metadata).
+
+All items below are deferred; none are scheduled.
+
+| # | Item                           | Risk | Effort | Notes                                                  |
+|:---|:-------------------------------|:-----|:-------|:-------------------------------------------------------|
+| 1 | `doctor` command               | Low  | Med    | Health checks exist but are scattered                  |
+| 2 | Cross-distro package detection | Med  | High   | Only Gentoo supported; other Linux distros get nothing |
+| 3 | Split large modules            | Low  | High   | Refactoring only; no behavior change                   |
+| 4 | Tests for edge cases           | Med  | Med    | PATH oddities, more version parsing corners            |
+
+## CLI and Automation UX
+
+- [ ] Add a focused `doctor` command for environment checks (PATH,
+  prerequisites, command health).
+
+## Platform and Package Detection
+
+- [ ] Broaden system package metadata detection beyond Gentoo-specific tooling
+  where practical; note that non-Gentoo system installs currently report "up to
+  date" because no available version is detectable.
+
+## Maintainability and Tests
+
+- [ ] Split larger modules into smaller focused files where practical
+  (`install.py`, `commands_actions.py`, `versions.py`).
+- [ ] Add tests for more prerequisite edge cases and PATH oddities.

{code_aide-1.17.0 → code_aide-1.18.1}/script-archive/amp-install.sh

@@ -347,6 +347,8 @@ install_amp_binary() {
 	fi
 
 	local binary_path="$BIN_DIR/$binary_name"
+	local staged_binary_path
+	staged_binary_path=$(mktemp "$BIN_DIR/tmp.XXXXXX")
 	local checksum_path="$AMP_HOME/amp-install-checksum.txt"
 
 	# Download checksum first
@@ -356,21 +358,22 @@ install_amp_binary() {
 
 	if has_gzip_support; then
 		# Download compressed binary and verify the decompressed bytes against checksum
-		download_gzipped_file "${binary_url}.gz" "$binary_path" 'Amp binary'
+		download_gzipped_file "${binary_url}.gz" "$staged_binary_path" 'Amp binary'
 	else
 		warn "gzip not found; downloading uncompressed binary"
-		download_file "$binary_url" "$binary_path" 'Amp binary'
+		download_file "$binary_url" "$staged_binary_path" 'Amp binary'
 	fi
 
 	# Verify checksum
-	verify_checksum "$binary_path" "$expected_checksum"
+	verify_checksum "$staged_binary_path" "$expected_checksum"
 
 	# Verify signature (optional, only if minisign is installed)
 	# Disabled until release signing is enabled
-	# verify_signature "$binary_path" "$minisign_signature_url"
+	# verify_signature "$staged_binary_path" "$minisign_signature_url"
 
-	# Make executable
-	chmod +x "$binary_path"
+	# Make executable before atomically replacing the installed binary
+	chmod 0755 "$staged_binary_path"
+	mv "$staged_binary_path" "$binary_path"
 
 	# Clean up checksum file
 	rm -f "$checksum_path"

{code_aide-1.17.0 → code_aide-1.18.1}/src/code_aide/__init__.py

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

{code_aide-1.17.0 → code_aide-1.18.1}/src/code_aide/commands_actions.py

@@ -16,6 +16,7 @@ from code_aide.install_types import (
 from code_aide.console import error, info, success, warning
 from code_aide.operations import (
     UpgradeResult,
+    clean_tool_versions,
     remove_tool,
     upgrade_tool,
     validate_tools,
@@ -46,6 +47,7 @@ from code_aide.config import (
 def cmd_install(args: argparse.Namespace) -> None:
     """Handle install command."""
     dryrun = getattr(args, "dryrun", False)
+    force = getattr(args, "force", False)
 
     if args.tools:
         tools_to_install = args.tools
@@ -86,7 +88,7 @@ def cmd_install(args: argparse.Namespace) -> None:
         else:
             info(f"=== Installing {tool} ===")
 
-        outcome = install_tool(tool, dryrun=dryrun)
+        outcome = install_tool(tool, dryrun=dryrun, force=force)
         if outcome:
             installed.append(tool)
             installed_bin_dirs.extend(outcome.bin_dirs)
@@ -294,6 +296,56 @@ def cmd_remove(args: argparse.Namespace) -> None:
         info("No tools were removed (all were not installed)")
 
 
+def cmd_clean(args: argparse.Namespace) -> None:
+    """Handle clean command: remove stale direct-download version dirs."""
+    dryrun = getattr(args, "dryrun", False)
+
+    if args.tools:
+        tools_to_clean = resolve_tool_names(args.tools, TOOLS)
+    else:
+        tools_to_clean = [
+            name
+            for name, config in TOOLS.items()
+            if parse_install_type(config.get("install_type"))
+            == InstallType.DIRECT_DOWNLOAD
+        ]
+        if not tools_to_clean:
+            info("No direct-download tools with cleanable versions")
+            return
+        info(
+            "No tools specified, cleaning direct-download tools: "
+            f"{', '.join(tools_to_clean)}"
+        )
+
+    validate_tools(tools_to_clean)
+
+    cleaned: Dict[str, List[str]] = {}
+    skipped = []
+    for tool in tools_to_clean:
+        print()
+        info(f"=== {'Checking' if dryrun else 'Cleaning'} {tool} ===")
+        removed = clean_tool_versions(tool, dryrun=dryrun)
+        if removed is None:
+            skipped.append(tool)
+        elif removed:
+            cleaned[tool] = removed
+
+    print()
+    print("=" * 42)
+    info("Cleanup Summary" + (" (dry run)" if dryrun else ""))
+    print("=" * 42)
+
+    if cleaned:
+        total = sum(len(paths) for paths in cleaned.values())
+        details = ", ".join(f"{tool} ({len(paths)})" for tool, paths in cleaned.items())
+        noun = "Would remove" if dryrun else "Removed"
+        success(f"{noun} {total} stale version directories: {details}")
+    if skipped:
+        info(f"Not cleanable (no versioned install layout): {', '.join(skipped)}")
+    if not cleaned:
+        success("Nothing to clean!")
+
+
 def cmd_update_versions(args: argparse.Namespace) -> None:
     """Handle update-versions command: check upstream for latest tool versions."""
     bundled = load_bundled_tools()

{code_aide-1.17.0 → code_aide-1.18.1}/src/code_aide/data/tools.json

@@ -89,7 +89,7 @@
       "command": "amp",
       "install_type": "script",
       "install_url": "https://ampcode.com/install.sh",
-      "install_sha256": "832d67ed6b6b4414a1578ec8064c258532703a7c4ff675bab7408a17d847c291",
+      "install_sha256": "07bea1669144a5191c873a61a3244266ca046557bff7123f0be41d0723592297",
       "install_script_path_prepend": [
         "~/.local/bin"
       ],

{code_aide-1.17.0 → code_aide-1.18.1}/src/code_aide/entry.py

@@ -5,6 +5,7 @@ import logging
 
 from code_aide import __version__
 from code_aide.commands_actions import (
+    cmd_clean,
     cmd_install,
     cmd_remove,
     cmd_update_versions,
@@ -83,6 +84,12 @@ def main() -> None:
         action="store_true",
         help="Verify SHA256 checksums without installing (dry run mode)",
     )
+    install_parser.add_argument(
+        "-f",
+        "--force",
+        action="store_true",
+        help="Reinstall even if the command already exists in PATH",
+    )
     install_parser.set_defaults(func=cmd_install)
 
     upgrade_parser = subparsers.add_parser("upgrade", help="Upgrade tools")
@@ -111,6 +118,23 @@ def main() -> None:
         action="store_true",
         help="Do not prompt for confirmation",
     )
+    clean_parser = subparsers.add_parser(
+        "clean",
+        help="Remove stale direct-download version directories",
+    )
+    clean_parser.add_argument(
+        "tools",
+        nargs="*",
+        help="Tools to clean (default: direct-download tools)",
+    )
+    clean_parser.add_argument(
+        "-n",
+        "--dryrun",
+        action="store_true",
+        help="Show what would be removed without removing",
+    )
+    clean_parser.set_defaults(func=cmd_clean)
+
     remove_parser.set_defaults(func=cmd_remove)
 
     update_versions_parser = subparsers.add_parser(

{code_aide-1.17.0 → code_aide-1.18.1}/src/code_aide/operations.py

@@ -1,10 +1,12 @@
 """Upgrade and remove operations for managed tools."""
 
+import fnmatch
 import os
+import shutil
 import subprocess
 import sys
 from enum import Enum
-from typing import Dict, List, TypedDict
+from typing import Dict, List, Optional, TypedDict
 
 from code_aide.constants import TOOLS
 from code_aide.detection import (
@@ -270,6 +272,68 @@ def remove_tool(tool_name: str) -> bool:
         return False
 
 
+def clean_tool_versions(tool_name: str, dryrun: bool = False) -> Optional[List[str]]:
+    """Remove stale version directories for a direct-download tool.
+
+    Keeps the directory the tool's symlinks currently point at. Returns
+    the list of removed (or, with dryrun, removable) directory paths,
+    or None when the tool has no versioned install layout.
+    """
+    tool_config = TOOLS[tool_name]
+    install_dir_template = tool_config.get("install_dir", "")
+    if not install_dir_template or "{version}" not in install_dir_template:
+        return None
+
+    expanded = os.path.expanduser(install_dir_template)
+    parent = os.path.dirname(expanded)
+    if not parent or not os.path.isdir(parent):
+        info(f"No install directory for {tool_config['name']}; nothing to clean")
+        return []
+
+    # Only consider directories matching the versioned template shape.
+    pattern = os.path.basename(expanded).replace("{version}", "*")
+
+    # Never remove the version the symlinks currently point at.
+    current_dirs = set()
+    bin_dir = os.path.expanduser(tool_config.get("bin_dir", ""))
+    for link_name in tool_config.get("symlinks", {}):
+        link_path = os.path.join(bin_dir, link_name)
+        if os.path.islink(link_path):
+            current_dirs.add(os.path.dirname(os.path.realpath(link_path)))
+
+    if not current_dirs:
+        warning(
+            f"Could not determine the current version directory of "
+            f"{tool_config['name']}; not removing anything"
+        )
+        return []
+
+    stale = []
+    for entry in sorted(os.listdir(parent)):
+        full = os.path.join(parent, entry)
+        if not os.path.isdir(full) or os.path.islink(full):
+            continue
+        if not fnmatch.fnmatch(entry, pattern):
+            continue
+        if full in current_dirs or os.path.realpath(full) in current_dirs:
+            continue
+        stale.append(full)
+
+    if not stale:
+        info(f"No stale version directories for {tool_config['name']}")
+        return []
+
+    if dryrun:
+        for path in stale:
+            info(f"[DRYRUN] Would remove stale version directory: {path}")
+        return stale
+
+    for path in stale:
+        shutil.rmtree(path)
+        info(f"Removed stale version directory: {path}")
+    return stale
+
+
 def validate_tools(tools: List[str]) -> None:
     """Validate that all tool names are valid."""
     invalid_tools = [tool for tool in tools if tool not in TOOLS]

{code_aide-1.17.0 → code_aide-1.18.1}/src/code_aide/status.py

@@ -360,8 +360,11 @@ def get_tool_status(tool_name: str, tool_config: Dict[str, Any]) -> ToolStatus:
             check=False,
             stdin=subprocess.DEVNULL,
         )
-        if result.returncode == 0 and result.stdout.strip():
-            status_info["version"] = result.stdout.strip().split("\n")[0]
+        if result.returncode == 0:
+            # Some tools print their version to stderr; prefer stdout.
+            output = result.stdout.strip() or result.stderr.strip()
+            if output:
+                status_info["version"] = output.split("\n")[0]
     except subprocess.TimeoutExpired:
         status_info["errors"].append("Version check timed out after 10s")
     except Exception:

{code_aide-1.17.0 → code_aide-1.18.1}/tests/test_commands_actions.py

@@ -48,9 +48,74 @@ class TestCmdInstall(unittest.TestCase):
             with contextlib.redirect_stdout(buf):
                 commands_actions.cmd_install(args)
 
-        mock_install_tool.assert_called_once_with("default_tool", dryrun=True)
+        mock_install_tool.assert_called_once_with(
+            "default_tool", dryrun=True, force=False
+        )
         mock_prereqs.assert_not_called()
 
+    def test_passes_force_flag_to_install_tool(self):
+        tools = {
+            "test": {
+                "name": "Test Tool",
+                "command": "test",
+                "install_type": "npm",
+                "next_steps": "run test",
+            }
+        }
+        args = type(
+            "Args",
+            (),
+            {
+                "tools": ["test"],
+                "dryrun": False,
+                "install_prerequisites": False,
+                "force": True,
+            },
+        )()
+
+        with (
+            mock.patch.dict(constants._TOOLS_DATA, tools, clear=True),
+            mock.patch.object(
+                commands_actions,
+                "install_tool",
+                return_value=InstallOutcome(True),
+            ) as mock_install,
+        ):
+            commands_actions.cmd_install(args)
+
+        mock_install.assert_called_once_with("test", dryrun=False, force=True)
+
+    def test_defaults_to_force_disabled(self):
+        tools = {
+            "test": {
+                "name": "Test Tool",
+                "command": "test",
+                "install_type": "npm",
+                "next_steps": "run test",
+            }
+        }
+        args = type(
+            "Args",
+            (),
+            {
+                "tools": ["test"],
+                "dryrun": False,
+                "install_prerequisites": False,
+            },
+        )()
+
+        with (
+            mock.patch.dict(constants._TOOLS_DATA, tools, clear=True),
+            mock.patch.object(
+                commands_actions,
+                "install_tool",
+                return_value=InstallOutcome(True),
+            ) as mock_install,
+        ):
+            commands_actions.cmd_install(args)
+
+        mock_install.assert_called_once_with("test", dryrun=False, force=False)
+
     def test_checks_bin_directories_reported_by_installers(self):
         tools = {
             "test": {
@@ -111,7 +176,7 @@ class TestCmdInstall(unittest.TestCase):
         ):
             commands_actions.cmd_install(args)
 
-        mock_install.assert_called_once_with("antigravity", dryrun=False)
+        mock_install.assert_called_once_with("antigravity", dryrun=False, force=False)
 
 
 class TestCmdUpdateVersions(unittest.TestCase):
@@ -580,3 +645,88 @@ class TestCmdRemove(unittest.TestCase):
 
         mock_input.assert_not_called()
         mock_remove.assert_called_once_with("a")
+
+
+class TestCmdClean(unittest.TestCase):
+    """Tests for cmd_clean selection and dry-run behavior."""
+
+    def _tools(self):
+        return {
+            "dl": {
+                "name": "DL Tool",
+                "command": "dl",
+                "install_type": "direct_download",
+                "install_dir": "~/.local/share/dl/versions/{version}",
+            },
+            "npmtool": {
+                "name": "NPM Tool",
+                "command": "npmtool",
+                "install_type": "npm",
+                "npm_package": "npmtool",
+            },
+        }
+
+    def test_default_clean_targets_only_direct_download_tools(self):
+        args = type("Args", (), {"tools": [], "dryrun": True})()
+        with (
+            mock.patch.dict(constants._TOOLS_DATA, self._tools(), clear=True),
+            mock.patch.object(
+                commands_actions, "clean_tool_versions", return_value=[]
+            ) as mock_clean,
+            contextlib.redirect_stdout(io.StringIO()) as buf,
+        ):
+            commands_actions.cmd_clean(args)
+
+        mock_clean.assert_called_once_with("dl", dryrun=True)
+        self.assertIn("cleaning direct-download tools: dl", buf.getvalue())
+
+    def test_named_non_cleanable_tool_is_reported(self):
+        args = type("Args", (), {"tools": ["npmtool"], "dryrun": False})()
+        with (
+            mock.patch.dict(constants._TOOLS_DATA, self._tools(), clear=True),
+            mock.patch.object(
+                commands_actions, "clean_tool_versions", return_value=None
+            ) as mock_clean,
+            contextlib.redirect_stdout(io.StringIO()) as buf,
+        ):
+            commands_actions.cmd_clean(args)
+
+        mock_clean.assert_called_once_with("npmtool", dryrun=False)
+        self.assertIn(
+            "Not cleanable (no versioned install layout): npmtool", buf.getvalue()
+        )
+        self.assertIn("Nothing to clean!", buf.getvalue())
+
+    def test_dryrun_summary_is_labeled(self):
+        args = type("Args", (), {"tools": ["dl"], "dryrun": True})()
+        with (
+            mock.patch.dict(constants._TOOLS_DATA, self._tools(), clear=True),
+            mock.patch.object(
+                commands_actions,
+                "clean_tool_versions",
+                return_value=["/tmp/stale"],
+            ),
+            contextlib.redirect_stdout(io.StringIO()) as buf,
+        ):
+            commands_actions.cmd_clean(args)
+
+        self.assertIn("Cleanup Summary (dry run)", buf.getvalue())
+        self.assertIn(
+            "Would remove 1 stale version directories: dl (1)", buf.getvalue()
+        )
+
+    def test_removal_summary_is_not_labeled_dry_run(self):
+        args = type("Args", (), {"tools": ["dl"], "dryrun": False})()
+        with (
+            mock.patch.dict(constants._TOOLS_DATA, self._tools(), clear=True),
+            mock.patch.object(
+                commands_actions,
+                "clean_tool_versions",
+                return_value=["/tmp/stale"],
+            ),
+            contextlib.redirect_stdout(io.StringIO()) as buf,
+        ):
+            commands_actions.cmd_clean(args)
+
+        self.assertIn("[INFO] Cleanup Summary", buf.getvalue())
+        self.assertNotIn("(dry run)", buf.getvalue())

{code_aide-1.17.0 → code_aide-1.18.1}/tests/test_operations.py

@@ -512,3 +512,76 @@ class TestCmdUpgradeDefaultSelection(unittest.TestCase):
             cli_commands_actions.cmd_upgrade(args)
 
         mock_upgrade.assert_called_once_with("current")
+
+
+class TestCleanToolVersions(unittest.TestCase):
+    """Tests for clean_tool_versions."""
+
+    def _setup(self, td, template_name="versions/{version}"):
+        parent = os.path.join(td, os.path.dirname(template_name))
+        os.makedirs(parent, exist_ok=True)
+        version_dirs = []
+        for v in ("1.0.0", "2.0.0"):
+            version_dir = os.path.join(
+                parent, template_name.replace("{version}", v).split("/")[-1]
+            )
+            os.makedirs(version_dir)
+            with open(os.path.join(version_dir, "tool-bin"), "w") as f:
+                f.write("#!/bin/sh\n")
+            version_dirs.append(version_dir)
+        bin_dir = os.path.join(td, "bin")
+        os.makedirs(bin_dir)
+        os.symlink(
+            os.path.join(version_dirs[1], "tool-bin"),
+            os.path.join(bin_dir, "tool"),
+        )
+        return {
+            "name": "Test Tool",
+            "command": "tool",
+            "install_type": "direct_download",
+            "install_dir": os.path.join(td, template_name),
+            "bin_dir": bin_dir,
+            "symlinks": {"tool": "tool-bin"},
+        }
+
+    def _clean(self, cfg, dryrun=False):
+        with mock.patch.dict(constants._TOOLS_DATA, {"test": cfg}, clear=True):
+            return cli_operations.clean_tool_versions("test", dryrun=dryrun)
+
+    def test_dryrun_lists_stale_without_removing(self):
+        with tempfile.TemporaryDirectory() as td:
+            cfg = self._setup(td)
+            stale = self._clean(cfg, dryrun=True)
+            self.assertEqual(stale, [os.path.join(td, "versions", "1.0.0")])
+            self.assertTrue(os.path.isdir(os.path.join(td, "versions", "1.0.0")))
+
+    def test_removes_stale_and_keeps_current(self):
+        with tempfile.TemporaryDirectory() as td:
+            cfg = self._setup(td)
+            stale = self._clean(cfg)
+            self.assertEqual(stale, [os.path.join(td, "versions", "1.0.0")])
+            self.assertFalse(os.path.exists(os.path.join(td, "versions", "1.0.0")))
+            self.assertTrue(os.path.isdir(os.path.join(td, "versions", "2.0.0")))
+
+    def test_prefix_pattern_leaves_unrelated_dirs(self):
+        with tempfile.TemporaryDirectory() as td:
+            cfg = self._setup(td, template_name="store/pkg-{version}")
+            os.makedirs(os.path.join(td, "store", "data"))
+            stale = self._clean(cfg)
+            self.assertEqual(stale, [os.path.join(td, "store", "pkg-1.0.0")])
+            self.assertTrue(os.path.isdir(os.path.join(td, "store", "data")))
+
+    def test_no_current_version_removes_nothing(self):
+        with tempfile.TemporaryDirectory() as td:
+            cfg = self._setup(td)
+            os.remove(os.path.join(td, "bin", "tool"))
+            stale = self._clean(cfg)
+            self.assertEqual(stale, [])
+            self.assertTrue(os.path.isdir(os.path.join(td, "versions", "1.0.0")))
+            self.assertTrue(os.path.isdir(os.path.join(td, "versions", "2.0.0")))
+
+    def test_tool_without_versioned_layout_returns_none(self):
+        with tempfile.TemporaryDirectory() as td:
+            cfg = self._setup(td)
+            cfg["install_dir"] = os.path.join(td, "flat")
+            self.assertIsNone(self._clean(cfg))

code_aide-1.18.1/tests/test_package_info.py

@@ -0,0 +1,57 @@
+"""Unit tests for package version info lookups."""
+
+import subprocess
+import unittest
+from unittest import mock
+
+from code_aide import package_info as cli_package_info
+
+
+class TestGetSystemPackageInfo(unittest.TestCase):
+    """Tests for get_system_package_info."""
+
+    def test_returns_empty_info_when_qfile_missing(self):
+        with mock.patch.object(cli_package_info, "command_exists", return_value=False):
+            info = cli_package_info.get_system_package_info("/usr/bin/tool")
+        self.assertEqual(
+            info,
+            {
+                "package": None,
+                "installed_version": None,
+                "available_version": None,
+                "available_date": None,
+            },
+        )
+
+    def test_returns_empty_info_when_qfile_finds_nothing(self):
+        no_match = subprocess.CompletedProcess(["qfile"], 1, stdout="", stderr="")
+        with (
+            mock.patch.object(cli_package_info, "command_exists", return_value=True),
+            mock.patch.object(
+                cli_package_info.subprocess, "run", return_value=no_match
+            ),
+        ):
+            info = cli_package_info.get_system_package_info("/usr/bin/tool")
+        self.assertIsNone(info["package"])
+        self.assertIsNone(info["installed_version"])
+
+    def test_resolves_installed_version_through_qlist_and_qatom(self):
+        responses = [
+            subprocess.CompletedProcess(
+                ["qfile"], 0, stdout="dev-util/tool\n", stderr=""
+            ),
+            subprocess.CompletedProcess(
+                ["qlist"], 0, stdout="dev-util/tool-1.4.2\n", stderr=""
+            ),
+            subprocess.CompletedProcess(["qatom"], 0, stdout="1.4.2\n", stderr=""),
+        ]
+        with (
+            mock.patch.object(cli_package_info, "command_exists", return_value=True),
+            mock.patch.object(
+                cli_package_info.subprocess, "run", side_effect=responses
+            ),
+            mock.patch.object(cli_package_info.globmod, "glob", return_value=[]),
+        ):
+            info = cli_package_info.get_system_package_info("/usr/bin/tool")
+        self.assertEqual(info["package"], "dev-util/tool")
+        self.assertEqual(info["installed_version"], "1.4.2")

{code_aide-1.17.0 → code_aide-1.18.1}/tests/test_status.py

@@ -1,5 +1,6 @@
 """Unit tests for status-rendering helpers."""
 
+import subprocess
 import unittest
 from unittest import mock
 
@@ -371,3 +372,48 @@ class TestToolUpgradeEvaluatorDiscovery(unittest.TestCase):
             assessment.decision, cli_status.UpgradeDecision.PACKAGE_MANAGED
         )
         mock_pkg.assert_called_once_with("/usr/bin/sys-tool")
+
+
+class TestGetToolStatus(unittest.TestCase):
+    """Tests for get_tool_status version capture."""
+
+    _TOOL_CONFIG = {"name": "Test Tool", "command": "test-tool"}
+
+    @staticmethod
+    def _completed(returncode=0, stdout="", stderr=""):
+        return subprocess.CompletedProcess(
+            ["test-tool", "--version"], returncode, stdout=stdout, stderr=stderr
+        )
+
+    def _run(self, **kwargs):
+        with (
+            mock.patch.object(cli_status, "is_tool_installed", return_value=True),
+            mock.patch.object(
+                cli_status.subprocess, "run", return_value=self._completed(**kwargs)
+            ),
+        ):
+            return cli_status.get_tool_status("test", self._TOOL_CONFIG)
+
+    def test_captures_version_from_stdout(self):
+        status = self._run(stdout="1.2.3\n")
+        self.assertEqual(status["version"], "1.2.3")
+
+    def test_captures_version_from_stderr_when_stdout_empty(self):
+        status = self._run(stdout="", stderr="2.0.0\n")
+        self.assertEqual(status["version"], "2.0.0")
+
+    def test_stdout_wins_over_stderr(self):
+        status = self._run(stdout="1.2.3\n", stderr="noise\n")
+        self.assertEqual(status["version"], "1.2.3")
+
+    def test_nonzero_exit_leaves_version_missing(self):
+        status = self._run(returncode=1, stdout="1.2.3\n")
+        self.assertIsNone(status["version"])
+
+    def test_not_installed_short_circuits(self):
+        with mock.patch.object(
+            cli_status, "is_tool_installed", return_value=False
+        ) as mock_installed:
+            status = cli_status.get_tool_status("test", self._TOOL_CONFIG)
+        mock_installed.assert_called_once_with("test")
+        self.assertIsNone(status["version"])

{code_aide-1.17.0 → code_aide-1.18.1}/tests/test_versions.py

@@ -420,3 +420,54 @@ class TestExtractScriptVersion(unittest.TestCase):
         )
 
         self.assertEqual(result, "1.0.0")
+
+
+class TestFetchUrl(unittest.TestCase):
+    """Tests for fetch_url network fetch behavior."""
+
+    @staticmethod
+    def _response(content=b"payload", last_modified="Tue, 25 Aug 2026 10:00:00 GMT"):
+        response = mock.Mock()
+        response.read.return_value = content
+        response.headers = {"Last-Modified": last_modified}
+        response.__enter__ = mock.Mock(return_value=response)
+        response.__exit__ = mock.Mock(return_value=False)
+        return response
+
+    def test_returns_content_and_last_modified(self):
+        with mock.patch.object(
+            cli_versions.urllib.request,
+            "urlopen",
+            return_value=self._response(content=b"abc"),
+        ) as mock_urlopen:
+            content, last_modified = cli_versions.fetch_url("https://example.com/x")
+        self.assertEqual(content, b"abc")
+        self.assertEqual(last_modified, "Tue, 25 Aug 2026 10:00:00 GMT")
+        request = mock_urlopen.call_args[0][0]
+        self.assertEqual(request.full_url, "https://example.com/x")
+        self.assertEqual(mock_urlopen.call_args[1]["timeout"], 30)
+
+    def test_sends_code_aide_user_agent(self):
+        with mock.patch.object(
+            cli_versions.urllib.request, "urlopen", return_value=self._response()
+        ) as mock_urlopen:
+            cli_versions.fetch_url("https://example.com/x")
+        request = mock_urlopen.call_args[0][0]
+        self.assertIn("code-aide/", request.headers.get("User-agent", ""))
+
+    def test_last_modified_is_none_when_header_absent(self):
+        with mock.patch.object(
+            cli_versions.urllib.request,
+            "urlopen",
+            return_value=self._response(last_modified=None),
+        ):
+            content, last_modified = cli_versions.fetch_url("https://example.com/x")
+        self.assertEqual(content, b"payload")
+        self.assertIsNone(last_modified)
+
+    def test_custom_timeout_is_passed(self):
+        with mock.patch.object(
+            cli_versions.urllib.request, "urlopen", return_value=self._response()
+        ) as mock_urlopen:
+            cli_versions.fetch_url("https://example.com/x", timeout=5)
+        self.assertEqual(mock_urlopen.call_args[1]["timeout"], 5)

code_aide-1.17.0/CLAUDE.md

@@ -1 +0,0 @@
-See AGENTS.md for project instructions.

code_aide-1.17.0/TODO.md

@@ -1,77 +0,0 @@
-# TODO
-
-Keep the project focused on managing AI coding CLI tools (install, upgrade,
-remove, status, and version metadata).
-
-## Summary
-
-| #  | Item                                        | Risk     | Effort  | Notes                                                              |
-|:---|:--------------------------------------------|:---------|:--------|:-------------------------------------------------------------------|
-| 1  | ~~Handle missing `node` cleanly~~ (done)    | -        | -       | Fixed in `prereqs.py` `check_prerequisites()`                      |
-| 2  | Read version from stdout+stderr             | Med      | Low     | Some tools write version to stderr; shown as not installed         |
-| 3  | ~~Atomic version cache writes~~ (done)      | -        | -       | Fixed in `config.py` `save_versions_cache()`                       |
-| 4  | ~~Warn on invalid cache JSON~~ (done)       | -        | -       | `config.py` `load_versions_cache()` logs a warning                 |
-| 5  | ~~Use `os.pathsep` not `":"`~~ (done)       | -        | -       | Fixed in `prereqs.py` `check_path_directories()`                   |
-| 6  | ~~Verify direct-download tarballs~~ (done)  | -        | -       | `download_sha256` recorded by update-versions, verified on install |
-| 7  | ~~Tarball checksum metadata fields~~ (done) | -        | -       | `download_sha256` field in tools schema and versions cache         |
-| 8  | `--json` output mode                        | Low      | Med     | Needed for CI/automation consumers                                 |
-| 9  | `doctor` command                            | Low      | Med     | Health checks exist but are scattered                              |
-| 10 | `install --force`                           | Low      | Trivial | Internal `force` param exists; not exposed in CLI                  |
-| 11 | Cleanup stale direct-download versions      | Low      | Med     | Old version dirs accumulate on disk                                |
-| 12 | Document default subcommand                 | Very Low | Trivial | One line in README                                                 |
-| 13 | Document `install --dryrun`                 | Very Low | Trivial | One line in README                                                 |
-| 14 | Document env vars and config paths          | Low      | Low     | `XDG_CONFIG_HOME` undocumented                                     |
-| 15 | Cross-distro package detection              | Med      | High    | Only Gentoo supported; other Linux distros get nothing             |
-| 16 | Split large modules                         | Low      | High    | Refactoring only; no behavior change                               |
-| 17 | Tests for untested functions                | Med      | High    | `fetch_url`, `get_system_package_info`                             |
-| 18 | Tests for edge cases                        | Med      | Med     | PATH oddities, more version parsing corners                        |
-
-## Reliability and Correctness
-
-- [x] Handle missing `node` cleanly during prerequisite checks (`OSError` path
-  in Node version probing).
-- [ ] Read tool version output from both stdout and stderr so status does not
-  miss installed versions.
-- [x] Make version cache writes atomic (temp file + rename) to avoid
-  partial/corrupted `versions.json`.
-- [x] Warn when `versions.json` cache contains invalid JSON instead of silently
-  returning empty data.
-- [x] Use `os.pathsep` instead of hardcoded `":"` in `prereqs.py`
-  `check_path_directories()`.
-
-## Security and Integrity
-
-- [x] Verify direct-download tarballs against a checksum recorded by
-  `update-versions` (warn when no checksum has been recorded yet).
-- [x] Extend tool metadata with a `download_sha256` field for tarball checksums.
-- [ ] Consider signature verification (beyond SHA256) for downloads where
-  upstream publishes signatures.
-
-## CLI and Automation UX
-
-- [ ] Add `--json` output mode for `list`, `status`, and `update-versions`.
-- [ ] 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.
-
-## Documentation
-
-- [ ] 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.
-
-## Maintainability and Tests
-
-- [ ] Split larger modules into smaller focused files where practical
-  (`commands_actions.py`, `versions.py`, `install.py`).
-- [ ] Add tests for remaining untested functions:
-  - `fetch_url()` (network; needs mocking)
-  - `get_system_package_info()` (Gentoo tooling)
-- [ ] Add tests for more prerequisite edge cases and PATH oddities.