code-aide 1.11.0__tar.gz → 1.11.2__tar.gz

{code_aide-1.11.0 → code_aide-1.11.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-aide
-Version: 1.11.0
+Version: 1.11.2
 Summary: Manage AI coding CLI tools (Claude, Copilot, Cursor, Gemini, Amp, Codex)
 Project-URL: Homepage, https://github.com/dajobe/code-aide
 Project-URL: Repository, https://github.com/dajobe/code-aide

{code_aide-1.11.0 → code_aide-1.11.2}/src/code_aide/__init__.py

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

{code_aide-1.11.0 → code_aide-1.11.2}/src/code_aide/commands_tools.py

@@ -257,6 +257,7 @@ def cmd_status(args: argparse.Namespace) -> None:
                             status["version"],
                             assessment.latest_version,
                             assessment.package_info,
+                            repo=tool_config.get("freebsd_pkg_repo"),
                         )
                     elif assessment.latest_version:
                         if assessment.version_state == VersionDisplayState.UP_TO_DATE:

{code_aide-1.11.0 → code_aide-1.11.2}/src/code_aide/config.py

@@ -66,20 +66,35 @@ 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."""
+    """Merge cached dynamic fields into tool definitions in-place.
+
+    For install_sha256, the bundled value takes precedence when it differs
+    from the cache, since a new release with an updated hash means the
+    cache is stale.
+    """
     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]:
-                    if (
-                        field == "install_sha256"
-                        and parse_install_type(tool_data.get("install_type"))
-                        == InstallType.DIRECT_DOWNLOAD
-                    ):
-                        # Script checksum does not apply to tarball installs; ignore
-                        # stale cache from older releases or mistaken updates.
-                        continue
+                    if field == "install_sha256":
+                        install_type = parse_install_type(
+                            tool_data.get("install_type")
+                        )
+                        if install_type == InstallType.DIRECT_DOWNLOAD:
+                            # Script checksum does not apply to tarball installs;
+                            # ignore stale cache from older releases.
+                            continue
+                        bundled_sha = tool_data.get("install_sha256")
+                        cached_sha = cached_tools[tool_key][field]
+                        if (
+                            bundled_sha
+                            and cached_sha
+                            and bundled_sha != cached_sha
+                        ):
+                            # Bundled hash was updated in a newer release;
+                            # discard stale cached hash.
+                            continue
                     tool_data[field] = cached_tools[tool_key][field]
 
 

{code_aide-1.11.0 → code_aide-1.11.2}/src/code_aide/data/tools.json

@@ -37,7 +37,8 @@
       ],
       "docs_url": "https://code.claude.com/docs/en/setup",
       "default_install": true,
-      "freebsd_port": "claude-code"
+      "freebsd_port": "claude-code",
+      "freebsd_pkg_repo": "FreeBSD-latest"
     },
     "gemini": {
       "name": "Gemini CLI",
@@ -54,7 +55,8 @@
       ],
       "docs_url": "https://github.com/google-gemini/gemini-cli",
       "default_install": true,
-      "freebsd_port": "gemini-cli"
+      "freebsd_port": "gemini-cli",
+      "freebsd_pkg_repo": "FreeBSD-latest"
     },
     "amp": {
       "name": "Amp (Sourcegraph)",
@@ -87,7 +89,8 @@
       ],
       "docs_url": "https://github.com/openai/codex",
       "default_install": false,
-      "freebsd_port": "codex"
+      "freebsd_port": "codex",
+      "freebsd_pkg_repo": "FreeBSD-latest"
     },
     "copilot": {
       "name": "Copilot CLI",
@@ -104,7 +107,8 @@
       ],
       "docs_url": "https://github.com/github/copilot-cli",
       "default_install": false,
-      "freebsd_port": "github-copilot-cli"
+      "freebsd_port": "github-copilot-cli",
+      "freebsd_pkg_repo": "FreeBSD-latest"
     },
     "opencode": {
       "name": "OpenCode",

{code_aide-1.11.0 → code_aide-1.11.2}/src/code_aide/detection.py

@@ -290,7 +290,9 @@ def get_brew_package_info(
     return result
 
 
-def get_pkg_package_info(package_name: str) -> PackageVersionInfo:
+def get_pkg_package_info(
+    package_name: str, repo: Optional[str] = None
+) -> PackageVersionInfo:
     """Get package version info for a FreeBSD pkg-installed tool."""
     result: PackageVersionInfo = {
         "package": package_name,
@@ -318,8 +320,12 @@ def get_pkg_package_info(package_name: str) -> PackageVersionInfo:
         pass
 
     try:
+        rquery_cmd = ["pkg", "rquery"]
+        if repo:
+            rquery_cmd.extend(["-r", repo])
+        rquery_cmd.extend(["%v", package_name])
         proc = subprocess.run(
-            ["pkg", "rquery", "%v", package_name],
+            rquery_cmd,
             capture_output=True,
             text=True,
             timeout=10,

{code_aide-1.11.0 → code_aide-1.11.2}/src/code_aide/install.py

@@ -260,11 +260,20 @@ def install_tool(tool_name: str, dryrun: bool = False, force: bool = False) -> b
         if not freebsd_port:
             error(f"{tool_config['name']} is not available on FreeBSD (no port exists)")
             return False
+        pkg_repo = tool_config.get("freebsd_pkg_repo")
         if dryrun:
-            info(f"[DRYRUN] Would install FreeBSD port: pkg install {freebsd_port}")
+            repo_flag = f" -r {pkg_repo}" if pkg_repo else ""
+            info(
+                f"[DRYRUN] Would install FreeBSD port: "
+                f"pkg install{repo_flag} {freebsd_port}"
+            )
             return True
         try:
-            run_command(["sudo", "pkg", "install", "-y", freebsd_port], check=True)
+            cmd = ["sudo", "pkg", "install", "-y"]
+            if pkg_repo:
+                cmd.extend(["-r", pkg_repo])
+            cmd.append(freebsd_port)
+            run_command(cmd, check=True)
             success(f"{tool_config['name']} installed successfully via FreeBSD pkg")
             info(tool_config["next_steps"])
             if "docs_url" in tool_config:

{code_aide-1.11.0 → code_aide-1.11.2}/src/code_aide/operations.py

@@ -195,11 +195,12 @@ def upgrade_tool(tool_name: str) -> UpgradeResult:
             if not pkg_name:
                 error(f"No FreeBSD port configured for {tool_config['name']}")
                 return UpgradeResult.FAILED
-            run_command(
-                ["sudo", "pkg", "upgrade", "-y", pkg_name],
-                check=True,
-                capture=False,
-            )
+            cmd = ["sudo", "pkg", "upgrade", "-y"]
+            pkg_repo = tool_config.get("freebsd_pkg_repo")
+            if pkg_repo:
+                cmd.extend(["-r", pkg_repo])
+            cmd.append(pkg_name)
+            run_command(cmd, check=True, capture=False)
 
         elif method == InstallMethod.SYSTEM:
             error(
@@ -343,11 +344,12 @@ def remove_tool(tool_name: str) -> bool:
             if not pkg_name:
                 error(f"No FreeBSD port configured for {tool_config['name']}")
                 return False
-            run_command(
-                ["sudo", "pkg", "delete", "-y", pkg_name],
-                check=True,
-                capture=False,
-            )
+            cmd = ["sudo", "pkg", "delete", "-y"]
+            pkg_repo = tool_config.get("freebsd_pkg_repo")
+            if pkg_repo:
+                cmd.extend(["-r", pkg_repo])
+            cmd.append(pkg_name)
+            run_command(cmd, check=True, capture=False)
             success(f"{tool_config['name']} removed successfully")
 
         elif method == InstallMethod.SYSTEM:

{code_aide-1.11.0 → code_aide-1.11.2}/src/code_aide/status.py

@@ -251,7 +251,10 @@ class ToolUpgradeEvaluator:
             pkg_name = install_info.get("detail") or self.tool_config.get(
                 "freebsd_port"
             )
-            self._package_info = get_pkg_package_info(pkg_name) if pkg_name else None
+            pkg_repo = self.tool_config.get("freebsd_pkg_repo")
+            self._package_info = (
+                get_pkg_package_info(pkg_name, repo=pkg_repo) if pkg_name else None
+            )
         elif method == InstallMethod.SYSTEM:
             tool_path = self._tool_path or shutil.which(self.tool_config["command"])
             self._package_info = (
@@ -396,6 +399,7 @@ def print_pkg_version_status(
     cli_version: str,
     latest_version: Optional[str],
     pkg_info: PackageInfo,
+    repo: Optional[str] = None,
 ) -> None:
     """Print version status for a FreeBSD pkg-managed tool."""
     avail_ver = pkg_info.get("available_version")
@@ -411,6 +415,7 @@ def print_pkg_version_status(
 
     if avail_ver:
         pkg_name = pkg_info.get("package") or "FreeBSD pkg"
+        repo_suffix = f", {repo}" if repo else ""
         show_upstream = (
             latest_version
             and not status_version_matches_latest(avail_ver, latest_version)
@@ -420,11 +425,11 @@ def print_pkg_version_status(
         )
         if show_upstream:
             print(
-                f"  Packaged:     {avail_ver} ({pkg_name}) "
+                f"  Packaged:     {avail_ver} ({pkg_name}{repo_suffix}) "
                 f"{Colors.YELLOW}(upstream: {latest_version}){Colors.NC}"
             )
         else:
-            print(f"  Packaged:     {avail_ver} ({pkg_name})")
+            print(f"  Packaged:     {avail_ver} ({pkg_name}{repo_suffix})")
 
 
 def get_tool_status(tool_name: str, tool_config: Dict[str, Any]) -> ToolStatus:

{code_aide-1.11.0 → code_aide-1.11.2}/tests/test_config.py

@@ -146,5 +146,67 @@ class TestMergeInstallSha256DirectDownload(unittest.TestCase):
         self.assertNotIn("install_sha256", entry)
 
 
+class TestMergeInstallSha256StaleCacheIgnored(unittest.TestCase):
+    """Stale cached install_sha256 must not override updated bundled hash."""
+
+    def test_bundled_sha256_wins_over_stale_cache(self):
+        tools = {
+            "amp": {
+                "install_type": "script",
+                "name": "Amp",
+                "command": "amp",
+                "install_sha256": "new_bundled_hash_from_release",
+            }
+        }
+        cache = {
+            "tools": {
+                "amp": {
+                    "install_sha256": "old_cached_hash",
+                }
+            }
+        }
+        code_aide_config.merge_cached_versions(tools, cache)
+        self.assertEqual(
+            tools["amp"]["install_sha256"], "new_bundled_hash_from_release"
+        )
+
+    def test_cache_applies_when_bundled_sha256_absent(self):
+        tools = {
+            "amp": {
+                "install_type": "script",
+                "name": "Amp",
+                "command": "amp",
+            }
+        }
+        cache = {
+            "tools": {
+                "amp": {
+                    "install_sha256": "cached_hash",
+                }
+            }
+        }
+        code_aide_config.merge_cached_versions(tools, cache)
+        self.assertEqual(tools["amp"]["install_sha256"], "cached_hash")
+
+    def test_cache_applies_when_sha256_matches_bundled(self):
+        tools = {
+            "amp": {
+                "install_type": "script",
+                "name": "Amp",
+                "command": "amp",
+                "install_sha256": "same_hash",
+            }
+        }
+        cache = {
+            "tools": {
+                "amp": {
+                    "install_sha256": "same_hash",
+                }
+            }
+        }
+        code_aide_config.merge_cached_versions(tools, cache)
+        self.assertEqual(tools["amp"]["install_sha256"], "same_hash")
+
+
 if __name__ == "__main__":
     unittest.main()

{code_aide-1.11.0 → code_aide-1.11.2}/tests/test_detection.py

@@ -218,6 +218,30 @@ class TestGetPkgPackageInfo(unittest.TestCase):
         self.assertEqual(result["available_version"], "2.1.63")
         self.assertFalse(result["outdated"])
 
+    @mock.patch.object(cli_detection, "command_exists", return_value=True)
+    @mock.patch.object(cli_detection.subprocess, "run")
+    def test_repo_passes_r_flag_to_rquery(self, mock_run, mock_cmd):
+        calls = []
+
+        def side_effect(cmd, **kwargs):
+            calls.append(list(cmd))
+            result = mock.Mock()
+            result.returncode = 0
+            result.stdout = "2.1.63\n"
+            return result
+
+        mock_run.side_effect = side_effect
+
+        cli_detection.get_pkg_package_info("claude-code", repo="FreeBSD-latest")
+
+        # pkg query (local) should NOT have -r
+        self.assertEqual(calls[0], ["pkg", "query", "%v", "claude-code"])
+        # pkg rquery (remote) should have -r
+        self.assertEqual(
+            calls[1],
+            ["pkg", "rquery", "-r", "FreeBSD-latest", "%v", "claude-code"],
+        )
+
 
 class TestFormatInstallMethodSystem(unittest.TestCase):
     """Tests for format_install_method with system method."""

{code_aide-1.11.0 → code_aide-1.11.2}/tests/test_install.py

@@ -99,6 +99,22 @@ class TestInstallToolFreeBSD(unittest.TestCase):
             ["sudo", "pkg", "install", "-y", "test-tool-port"], check=True
         )
 
+    @mock.patch.object(cli_install.platform, "system", return_value="FreeBSD")
+    @mock.patch.object(cli_install, "command_exists", return_value=False)
+    @mock.patch.object(cli_install, "run_command")
+    def test_freebsd_with_repo_passes_r_flag(self, mock_run, mock_cmd, mock_sys):
+        tool_config = self._make_tool_config(
+            freebsd_port="test-tool-port",
+            freebsd_pkg_repo="FreeBSD-latest",
+        )
+        with mock.patch.dict(cli_install.TOOLS, {"test": tool_config}, clear=True):
+            result = cli_install.install_tool("test")
+        self.assertTrue(result)
+        mock_run.assert_called_once_with(
+            ["sudo", "pkg", "install", "-y", "-r", "FreeBSD-latest", "test-tool-port"],
+            check=True,
+        )
+
 
 class TestExtractTarMember(unittest.TestCase):
     """Tests for extract_tar_member."""