code-aide 1.10.1__tar.gz → 1.11.1__tar.gz

{code_aide-1.10.1 → code_aide-1.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-aide
-Version: 1.10.1
+Version: 1.11.1
 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
@@ -14,6 +14,7 @@ Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: BSD :: FreeBSD
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11

{code_aide-1.10.1 → code_aide-1.11.1}/pyproject.toml

@@ -16,6 +16,7 @@ classifiers = [
     "License :: OSI Approved :: Apache Software License",
     "Operating System :: MacOS",
     "Operating System :: POSIX :: Linux",
+    "Operating System :: POSIX :: BSD :: FreeBSD",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",

{code_aide-1.10.1 → code_aide-1.11.1}/src/code_aide/__init__.py

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

{code_aide-1.10.1 → code_aide-1.11.1}/src/code_aide/commands_tools.py

@@ -20,8 +20,10 @@ from code_aide.install_types import (
     parse_install_type,
 )
 from code_aide.prereqs import detect_package_manager, is_tool_installed
+from code_aide.detection import is_freebsd
 from code_aide.status import (
     print_brew_version_status,
+    print_pkg_version_status,
     print_system_version_status,
     ToolUpgradeEvaluator,
     UpgradeDecision,
@@ -68,6 +70,9 @@ def cmd_list(args: argparse.Namespace) -> None:
         if tool_config.get("min_node_version"):
             print(f"  Requires:     Node.js v{tool_config['min_node_version']}+")
 
+        if is_freebsd() and not tool_config.get("freebsd_port"):
+            print("  Note:         Not available on FreeBSD")
+
         if not tool_config.get("default_install", True):
             print(
                 "  Note:         Opt-in only "
@@ -116,6 +121,7 @@ def _short_install_method(method: str | None) -> str:
         InstallMethod.NPM: "npm",
         InstallMethod.BREW_NPM: "brew-npm",
         InstallMethod.SYSTEM: "system",
+        InstallMethod.PKG: "pkg",
         InstallMethod.SCRIPT: "script",
         InstallMethod.DIRECT_DOWNLOAD: "download",
     }
@@ -243,6 +249,30 @@ def cmd_status(args: argparse.Namespace) -> None:
                         assessment.latest_version,
                         assessment.package_info,
                     )
+                elif assessment.install_method == InstallMethod.PKG:
+                    if assessment.package_info and assessment.package_info.get(
+                        "available_version"
+                    ):
+                        print_pkg_version_status(
+                            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:
+                            print(
+                                f"  Version:      {status['version']} "
+                                f"{Colors.GREEN}(up to date){Colors.NC}"
+                            )
+                        else:
+                            print(
+                                _generic_version_annotation(
+                                    status["version"], assessment.latest_version
+                                )
+                            )
+                    else:
+                        print(f"  Version:      {status['version']}")
                 elif assessment.install_method in (
                     InstallMethod.BREW_FORMULA,
                     InstallMethod.BREW_CASK,

{code_aide-1.10.1 → code_aide-1.11.1}/src/code_aide/constants.py

@@ -57,6 +57,13 @@ PACKAGE_MANAGERS: Dict[str, Dict[str, Any]] = {
         "install_command": ["sudo", "emerge", "--quiet-build"],
         "description": "Gentoo",
     },
+    "pkg": {
+        "detect_command": "pkg",
+        "packages": ["node22", "npm-node22"],
+        "pre_install": [],
+        "install_command": ["sudo", "pkg", "install", "-y"],
+        "description": "FreeBSD",
+    },
 }
 
 

{code_aide-1.10.1 → code_aide-1.11.1}/src/code_aide/data/tools.json

@@ -36,7 +36,9 @@
         "--version"
       ],
       "docs_url": "https://code.claude.com/docs/en/setup",
-      "default_install": true
+      "default_install": true,
+      "freebsd_port": "claude-code",
+      "freebsd_pkg_repo": "FreeBSD-latest"
     },
     "gemini": {
       "name": "Gemini CLI",
@@ -52,7 +54,9 @@
         "--version"
       ],
       "docs_url": "https://github.com/google-gemini/gemini-cli",
-      "default_install": true
+      "default_install": true,
+      "freebsd_port": "gemini-cli",
+      "freebsd_pkg_repo": "FreeBSD-latest"
     },
     "amp": {
       "name": "Amp (Sourcegraph)",
@@ -84,7 +88,9 @@
         "--version"
       ],
       "docs_url": "https://github.com/openai/codex",
-      "default_install": false
+      "default_install": false,
+      "freebsd_port": "codex",
+      "freebsd_pkg_repo": "FreeBSD-latest"
     },
     "copilot": {
       "name": "Copilot CLI",
@@ -100,7 +106,9 @@
         "--version"
       ],
       "docs_url": "https://github.com/github/copilot-cli",
-      "default_install": false
+      "default_install": false,
+      "freebsd_port": "github-copilot-cli",
+      "freebsd_pkg_repo": "FreeBSD-latest"
     },
     "opencode": {
       "name": "OpenCode",

{code_aide-1.10.1 → code_aide-1.11.1}/src/code_aide/detection.py

@@ -3,6 +3,7 @@
 import glob as globmod
 import json
 import os
+import platform
 import re
 import shutil
 import subprocess
@@ -40,6 +41,29 @@ class PackageVersionInfo(TypedDict, total=False):
     outdated: bool | None
 
 
+def is_freebsd() -> bool:
+    """Return True when running on FreeBSD."""
+    return platform.system() == "FreeBSD"
+
+
+def _pkg_owns_file(path: str) -> bool:
+    """Return True when FreeBSD pkg owns the given file path."""
+    if not command_exists("pkg"):
+        return False
+    try:
+        proc = subprocess.run(
+            ["pkg", "which", "-q", path],
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=False,
+            stdin=subprocess.DEVNULL,
+        )
+        return proc.returncode == 0 and bool(proc.stdout.strip())
+    except Exception:
+        return False
+
+
 def _empty_install_info() -> DetectedInstallInfo:
     """Return the default empty install-info shape."""
     return {"method": None, "detail": None}
@@ -78,6 +102,9 @@ def detect_install_method(tool_name: str) -> DetectedInstallInfo:
 
     system_prefixes = ("/opt/", "/usr/bin/", "/usr/sbin/", "/usr/local/bin/")
     if any(real_path.startswith(prefix) for prefix in system_prefixes):
+        freebsd_port = tool_config.get("freebsd_port")
+        if is_freebsd() and freebsd_port and _pkg_owns_file(real_path):
+            return {"method": InstallMethod.PKG, "detail": freebsd_port}
         return {"method": InstallMethod.SYSTEM, "detail": real_path}
 
     return {
@@ -263,6 +290,59 @@ def get_brew_package_info(
     return result
 
 
+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,
+        "installed_version": None,
+        "available_version": None,
+        "available_date": None,
+        "outdated": None,
+    }
+
+    if not command_exists("pkg"):
+        return result
+
+    try:
+        proc = subprocess.run(
+            ["pkg", "query", "%v", package_name],
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=False,
+            stdin=subprocess.DEVNULL,
+        )
+        if proc.returncode == 0 and proc.stdout.strip():
+            result["installed_version"] = proc.stdout.strip().split("\n")[0]
+    except Exception:
+        pass
+
+    try:
+        rquery_cmd = ["pkg", "rquery"]
+        if repo:
+            rquery_cmd.extend(["-r", repo])
+        rquery_cmd.extend(["%v", package_name])
+        proc = subprocess.run(
+            rquery_cmd,
+            capture_output=True,
+            text=True,
+            timeout=10,
+            check=False,
+            stdin=subprocess.DEVNULL,
+        )
+        if proc.returncode == 0 and proc.stdout.strip():
+            result["available_version"] = proc.stdout.strip().split("\n")[0]
+    except Exception:
+        pass
+
+    if result["installed_version"] and result["available_version"]:
+        result["outdated"] = result["installed_version"] != result["available_version"]
+
+    return result
+
+
 def format_install_method(method: InstallMethodInput, detail: Optional[str]) -> str:
     """Format detected local install method for display."""
     install_method = parse_install_method(method)
@@ -279,6 +359,8 @@ def format_install_method(method: InstallMethodInput, detail: Optional[str]) ->
             if detail
             else "Homebrew prefix npm-global"
         )
+    if install_method == InstallMethod.PKG:
+        return f"FreeBSD pkg ({detail})" if detail else "FreeBSD pkg"
     if install_method == InstallMethod.SYSTEM:
         return f"system package ({detail})" if detail else "system package"
     if install_method == InstallMethod.SCRIPT or install_type == InstallType.SCRIPT:
@@ -299,6 +381,7 @@ _USER_MANAGED_METHODS = frozenset(
         InstallMethod.BREW_FORMULA,
         InstallMethod.BREW_CASK,
         InstallMethod.SYSTEM,
+        InstallMethod.PKG,
     }
 )
 

{code_aide-1.10.1 → code_aide-1.11.1}/src/code_aide/install.py

@@ -88,7 +88,7 @@ ARCH_MAP = {
 def detect_os_arch() -> tuple:
     """Detect OS and architecture for direct download URLs."""
     os_name = platform.system().lower()
-    if os_name not in ("linux", "darwin"):
+    if os_name not in ("linux", "darwin", "freebsd"):
         raise RuntimeError(f"Unsupported OS: {os_name}")
 
     machine = platform.machine()
@@ -255,6 +255,37 @@ def install_tool(tool_name: str, dryrun: bool = False, force: bool = False) -> b
                 f"{tool_path}"
             )
 
+    if platform.system() == "FreeBSD":
+        freebsd_port = tool_config.get("freebsd_port")
+        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:
+            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:
+            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:
+                info(f"Documentation: {tool_config['docs_url']}")
+            return True
+        except subprocess.CalledProcessError as exc:
+            error(f"Failed to install {tool_config['name']}: {exc.stderr}")
+            return False
+        except Exception as exc:
+            error(f"Failed to install {tool_config['name']}: {exc}")
+            return False
+
     try:
         install_type = get_tool_install_type(tool_config)
 

{code_aide-1.10.1 → code_aide-1.11.1}/src/code_aide/install_types.py

@@ -17,6 +17,7 @@ class InstallType(_ValueEnum):
     NPM = "npm"
     SCRIPT = "script"
     DIRECT_DOWNLOAD = "direct_download"
+    PKG = "pkg"
 
 
 class InstallMethod(_ValueEnum):
@@ -29,6 +30,7 @@ class InstallMethod(_ValueEnum):
     SYSTEM = "system"
     SCRIPT = "script"
     DIRECT_DOWNLOAD = "direct_download"
+    PKG = "pkg"
 
 
 InstallTypeInput: TypeAlias = InstallType | str
@@ -40,6 +42,7 @@ _INSTALL_METHOD_BY_TYPE = {
     InstallType.NPM: InstallMethod.NPM,
     InstallType.SCRIPT: InstallMethod.SCRIPT,
     InstallType.DIRECT_DOWNLOAD: InstallMethod.DIRECT_DOWNLOAD,
+    InstallType.PKG: InstallMethod.PKG,
 }
 
 

{code_aide-1.10.1 → code_aide-1.11.1}/src/code_aide/operations.py

@@ -190,6 +190,18 @@ def upgrade_tool(tool_name: str) -> UpgradeResult:
             if not install_direct_download(tool_name, tool_config):
                 return UpgradeResult.FAILED
 
+        elif method == InstallMethod.PKG:
+            pkg_name = detail or tool_config.get("freebsd_port")
+            if not pkg_name:
+                error(f"No FreeBSD port configured for {tool_config['name']}")
+                return UpgradeResult.FAILED
+            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(
                 f"{tool_config['name']} is managed by the system package manager. "
@@ -327,6 +339,19 @@ def remove_tool(tool_name: str) -> bool:
 
             success(f"{tool_config['name']} removed successfully")
 
+        elif method == InstallMethod.PKG:
+            pkg_name = detail or tool_config.get("freebsd_port")
+            if not pkg_name:
+                error(f"No FreeBSD port configured for {tool_config['name']}")
+                return 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:
             error(
                 f"{tool_config['name']} is managed by the system package manager. "

{code_aide-1.10.1 → code_aide-1.11.1}/src/code_aide/prereqs.py

@@ -19,7 +19,7 @@ from code_aide.console import (
 
 def detect_package_manager() -> Optional[str]:
     """Detect the Linux distribution and return package manager name."""
-    if platform.system() != "Linux":
+    if platform.system() not in ("Linux", "FreeBSD"):
         return None
 
     for pkg_mgr_name, config in PACKAGE_MANAGERS.items():
@@ -78,11 +78,17 @@ def check_prerequisites(
     needed_prereqs = set()
     tools_needing_node = []
 
+    on_freebsd = platform.system() == "FreeBSD"
+
     for tool_name in tools_to_install:
         tool_config = TOOLS.get(tool_name)
         if not tool_config:
             continue
 
+        # FreeBSD pkg handles all dependencies for ported tools
+        if on_freebsd and tool_config.get("freebsd_port"):
+            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"]))

{code_aide-1.10.1 → code_aide-1.11.1}/src/code_aide/status.py

@@ -12,6 +12,7 @@ from code_aide.detection import (
     PackageVersionInfo,
     detect_install_method,
     get_brew_package_info,
+    get_pkg_package_info,
     get_system_package_info,
     is_install_method_deprecated,
 )
@@ -125,6 +126,9 @@ class ToolUpgradeEvaluator:
         if method in (InstallMethod.BREW_FORMULA, InstallMethod.BREW_CASK):
             return self._evaluate_brew(status, install_info, package_info)
 
+        if method == InstallMethod.PKG:
+            return self._evaluate_brew(status, install_info, package_info)
+
         if method == InstallMethod.SYSTEM:
             return self._result(
                 decision=UpgradeDecision.PACKAGE_MANAGED,
@@ -243,6 +247,14 @@ class ToolUpgradeEvaluator:
             self._package_info = get_brew_package_info(
                 method, install_info.get("detail")
             )
+        elif method == InstallMethod.PKG:
+            pkg_name = install_info.get("detail") or self.tool_config.get(
+                "freebsd_port"
+            )
+            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 = (
@@ -383,6 +395,43 @@ def print_brew_version_status(
             print(f"  Packaged:     {avail_ver} ({pkg_name})")
 
 
+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")
+    outdated = pkg_info.get("outdated")
+
+    if outdated:
+        print(
+            f"  Version:      {cli_version} {Colors.YELLOW}(pkg has {avail_ver})"
+            f"{Colors.NC}"
+        )
+    else:
+        print(f"  Version:      {cli_version} {Colors.GREEN}(up to date){Colors.NC}")
+
+    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)
+            and version_is_newer(
+                normalize_version(latest_version), normalize_version(avail_ver)
+            )
+        )
+        if show_upstream:
+            print(
+                f"  Packaged:     {avail_ver} ({pkg_name}{repo_suffix}) "
+                f"{Colors.YELLOW}(upstream: {latest_version}){Colors.NC}"
+            )
+        else:
+            print(f"  Packaged:     {avail_ver} ({pkg_name}{repo_suffix})")
+
+
 def get_tool_status(tool_name: str, tool_config: Dict[str, Any]) -> ToolStatus:
     """Get status information for a specific tool."""
     status_info = {

{code_aide-1.10.1 → code_aide-1.11.1}/tests/test_detection.py

@@ -92,6 +92,156 @@ class TestDetectInstallMethod(unittest.TestCase):
             {"method": "system", "detail": "/usr/bin/claude"},
         )
 
+    @mock.patch.object(cli_detection, "is_freebsd", return_value=True)
+    @mock.patch.object(cli_detection, "_pkg_owns_file", return_value=True)
+    @mock.patch.object(cli_detection.os.path, "realpath")
+    @mock.patch.object(cli_detection.shutil, "which")
+    def test_detects_freebsd_pkg(self, mock_which, mock_realpath, mock_pkg, mock_fbsd):
+        mock_which.return_value = "/usr/local/bin/claude"
+        mock_realpath.return_value = "/usr/local/bin/claude"
+
+        self.assertEqual(
+            cli_detection.detect_install_method("claude"),
+            {"method": "pkg", "detail": "claude-code"},
+        )
+
+    @mock.patch.object(cli_detection, "is_freebsd", return_value=True)
+    @mock.patch.object(cli_detection, "_pkg_owns_file", return_value=False)
+    @mock.patch.object(cli_detection.os.path, "realpath")
+    @mock.patch.object(cli_detection.shutil, "which")
+    def test_freebsd_not_pkg_owned_falls_back_to_system(
+        self, mock_which, mock_realpath, mock_pkg, mock_fbsd
+    ):
+        mock_which.return_value = "/usr/local/bin/claude"
+        mock_realpath.return_value = "/usr/local/bin/claude"
+
+        self.assertEqual(
+            cli_detection.detect_install_method("claude"),
+            {"method": "system", "detail": "/usr/local/bin/claude"},
+        )
+
+    @mock.patch.object(cli_detection, "is_freebsd", return_value=False)
+    @mock.patch.object(cli_detection.os.path, "realpath")
+    @mock.patch.object(cli_detection.shutil, "which")
+    def test_not_freebsd_ignores_port(self, mock_which, mock_realpath, mock_fbsd):
+        mock_which.return_value = "/usr/local/bin/claude"
+        mock_realpath.return_value = "/usr/local/bin/claude"
+
+        self.assertEqual(
+            cli_detection.detect_install_method("claude"),
+            {"method": "system", "detail": "/usr/local/bin/claude"},
+        )
+
+
+class TestFormatInstallMethodPkg(unittest.TestCase):
+    """Tests for format_install_method with pkg method."""
+
+    def test_pkg_with_detail(self):
+        self.assertEqual(
+            cli_detection.format_install_method("pkg", "claude-code"),
+            "FreeBSD pkg (claude-code)",
+        )
+
+    def test_pkg_without_detail(self):
+        self.assertEqual(
+            cli_detection.format_install_method("pkg", None),
+            "FreeBSD pkg",
+        )
+
+
+class TestPkgNeverDeprecated(unittest.TestCase):
+    """Tests that pkg install method is never deprecated."""
+
+    def test_pkg_never_deprecated(self):
+        tool_config = {
+            "name": "Test Tool",
+            "command": "test-tool",
+            "install_type": "script",
+        }
+        with (
+            mock.patch.dict(cli_detection.TOOLS, {"test": tool_config}, clear=True),
+            mock.patch.object(
+                cli_detection,
+                "detect_install_method",
+                return_value={"method": "pkg", "detail": "test-tool"},
+            ),
+        ):
+            self.assertFalse(cli_detection.is_deprecated_install("test"))
+
+
+class TestGetPkgPackageInfo(unittest.TestCase):
+    """Tests for get_pkg_package_info."""
+
+    @mock.patch.object(cli_detection, "command_exists", return_value=False)
+    def test_no_pkg_command(self, mock_cmd):
+        result = cli_detection.get_pkg_package_info("claude-code")
+        self.assertEqual(result["package"], "claude-code")
+        self.assertIsNone(result["installed_version"])
+        self.assertIsNone(result["available_version"])
+
+    @mock.patch.object(cli_detection, "command_exists", return_value=True)
+    @mock.patch.object(cli_detection.subprocess, "run")
+    def test_parses_pkg_output(self, mock_run, mock_cmd):
+        def side_effect(cmd, **kwargs):
+            result = mock.Mock()
+            if cmd[1] == "query":
+                result.returncode = 0
+                result.stdout = "2.1.62\n"
+            elif cmd[1] == "rquery":
+                result.returncode = 0
+                result.stdout = "2.1.63\n"
+            else:
+                result.returncode = 1
+                result.stdout = ""
+            return result
+
+        mock_run.side_effect = side_effect
+
+        result = cli_detection.get_pkg_package_info("claude-code")
+        self.assertEqual(result["installed_version"], "2.1.62")
+        self.assertEqual(result["available_version"], "2.1.63")
+        self.assertTrue(result["outdated"])
+
+    @mock.patch.object(cli_detection, "command_exists", return_value=True)
+    @mock.patch.object(cli_detection.subprocess, "run")
+    def test_up_to_date(self, mock_run, mock_cmd):
+        def side_effect(cmd, **kwargs):
+            result = mock.Mock()
+            result.returncode = 0
+            result.stdout = "2.1.63\n"
+            return result
+
+        mock_run.side_effect = side_effect
+
+        result = cli_detection.get_pkg_package_info("claude-code")
+        self.assertEqual(result["installed_version"], "2.1.63")
+        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.10.1 → code_aide-1.11.1}/tests/test_install.py

@@ -45,6 +45,76 @@ class TestDetectOsArch(unittest.TestCase):
         with self.assertRaises(RuntimeError):
             cli_install.detect_os_arch()
 
+    @mock.patch.object(cli_install.platform, "machine", return_value="amd64")
+    @mock.patch.object(cli_install.platform, "system", return_value="FreeBSD")
+    def test_freebsd_amd64(self, mock_sys, mock_mach):
+        self.assertEqual(cli_install.detect_os_arch(), ("freebsd", "x64"))
+
+    @mock.patch.object(cli_install.platform, "machine", return_value="arm64")
+    @mock.patch.object(cli_install.platform, "system", return_value="FreeBSD")
+    def test_freebsd_arm64(self, mock_sys, mock_mach):
+        self.assertEqual(cli_install.detect_os_arch(), ("freebsd", "arm64"))
+
+
+class TestInstallToolFreeBSD(unittest.TestCase):
+    """Tests for install_tool on FreeBSD."""
+
+    def _make_tool_config(self, **overrides):
+        base = {
+            "name": "Test Tool",
+            "command": "test-tool",
+            "install_type": "npm",
+            "npm_package": "test-tool",
+            "next_steps": "Run test-tool",
+            "docs_url": "https://example.com",
+        }
+        base.update(overrides)
+        return base
+
+    @mock.patch.object(cli_install.platform, "system", return_value="FreeBSD")
+    @mock.patch.object(cli_install, "command_exists", return_value=False)
+    def test_freebsd_no_port_returns_false(self, mock_cmd, mock_sys):
+        tool_config = self._make_tool_config()
+        with mock.patch.dict(cli_install.TOOLS, {"test": tool_config}, clear=True):
+            result = cli_install.install_tool("test")
+        self.assertFalse(result)
+
+    @mock.patch.object(cli_install.platform, "system", return_value="FreeBSD")
+    @mock.patch.object(cli_install, "command_exists", return_value=False)
+    def test_freebsd_with_port_dryrun(self, mock_cmd, mock_sys):
+        tool_config = self._make_tool_config(freebsd_port="test-tool-port")
+        with mock.patch.dict(cli_install.TOOLS, {"test": tool_config}, clear=True):
+            result = cli_install.install_tool("test", dryrun=True)
+        self.assertTrue(result)
+
+    @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_port_installs_via_pkg(self, mock_run, mock_cmd, mock_sys):
+        tool_config = self._make_tool_config(freebsd_port="test-tool-port")
+        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", "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."""

{code_aide-1.10.1 → code_aide-1.11.1}/tests/test_install_types.py

@@ -44,6 +44,15 @@ class TestInstallMethodParsing(unittest.TestCase):
     def test_install_method_from_type_returns_matching_method(self):
         self.assertEqual(install_method_from_type(InstallType.NPM), InstallMethod.NPM)
 
+    def test_parse_pkg_install_type(self):
+        self.assertEqual(parse_install_type("pkg"), InstallType.PKG)
+
+    def test_parse_pkg_install_method(self):
+        self.assertEqual(parse_install_method("pkg"), InstallMethod.PKG)
+
+    def test_install_method_from_pkg_type(self):
+        self.assertEqual(install_method_from_type(InstallType.PKG), InstallMethod.PKG)
+
 
 class TestDetectionTypedMethods(unittest.TestCase):
     """Tests for enum-returning detect_install_method behavior."""