agent-cli 0.76.4__tar.gz → 0.76.5__tar.gz

{agent_cli-0.76.4 → agent_cli-0.76.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-cli
-Version: 0.76.4
+Version: 0.76.5
 Summary: A suite of AI-powered command-line tools for text correction, audio transcription, and voice assistance.
 Project-URL: Homepage, https://github.com/basnijholt/agent-cli
 Author-email: Bas Nijholt <bas@nijho.lt>
@@ -514,19 +514,19 @@ agent-cli install-extras rag memory vad
 
  Available extras:
 
-  • rag - RAG proxy server (ChromaDB, embeddings)
-  • memory - Long-term memory proxy (ChromaDB)
-  • vad - Voice Activity Detection (Silero VAD via ONNX)
-  • audio - Local audio recording/playback
-  • piper - Local Piper TTS engine
-  • kokoro - Kokoro neural TTS engine
-  • faster-whisper - Whisper ASR for CUDA/CPU
+  • audio - Audio recording/playback
+  • faster-whisper - Whisper ASR via CTranslate2
+  • kokoro - Kokoro neural TTS (GPU)
+  • llm - LLM framework (pydantic-ai)
+  • memory - Long-term memory proxy
   • mlx-whisper - Whisper ASR for Apple Silicon
-  • whisper-transformers - Whisper ASR via HuggingFace transformers (safetensors)
-  • wyoming - Wyoming protocol for ASR/TTS servers
+  • piper - Piper TTS (CPU)
+  • rag - RAG proxy (ChromaDB, embeddings)
   • server - FastAPI server components
-  • speed - Audio speed adjustment
-  • llm - LLM framework (pydantic-ai)
+  • speed - Audio speed adjustment (audiostretchy)
+  • vad - Voice Activity Detection (Silero VAD via ONNX)
+  • whisper-transformers - Whisper ASR via HuggingFace transformers
+  • wyoming - Wyoming protocol support
 
  Examples:
 
@@ -538,9 +538,9 @@ agent-cli install-extras rag memory vad
 
 
 ╭─ Arguments ────────────────────────────────────────────────────────────────────────────╮
-│   extras      [EXTRAS]...  Extras to install: rag, memory, vad, audio, piper, kokoro,  │
-│                            faster-whisper, mlx-whisper, whisper-transformers, wyoming, │
-│                            server, speed, llm                                          │
+│   extras      [EXTRAS]...  Extras to install: audio, faster-whisper, kokoro, llm,      │
+│                            memory, mlx-whisper, piper, rag, server, speed, vad,        │
+│                            whisper-transformers, wyoming                               │
 ╰────────────────────────────────────────────────────────────────────────────────────────╯
 ╭─ Options ──────────────────────────────────────────────────────────────────────────────╮
 │ --list  -l        Show available extras with descriptions (what each one enables)      │

{agent_cli-0.76.4 → agent_cli-0.76.5}/README.md

@@ -420,19 +420,19 @@ agent-cli install-extras rag memory vad
 
  Available extras:
 
-  • rag - RAG proxy server (ChromaDB, embeddings)
-  • memory - Long-term memory proxy (ChromaDB)
-  • vad - Voice Activity Detection (Silero VAD via ONNX)
-  • audio - Local audio recording/playback
-  • piper - Local Piper TTS engine
-  • kokoro - Kokoro neural TTS engine
-  • faster-whisper - Whisper ASR for CUDA/CPU
+  • audio - Audio recording/playback
+  • faster-whisper - Whisper ASR via CTranslate2
+  • kokoro - Kokoro neural TTS (GPU)
+  • llm - LLM framework (pydantic-ai)
+  • memory - Long-term memory proxy
   • mlx-whisper - Whisper ASR for Apple Silicon
-  • whisper-transformers - Whisper ASR via HuggingFace transformers (safetensors)
-  • wyoming - Wyoming protocol for ASR/TTS servers
+  • piper - Piper TTS (CPU)
+  • rag - RAG proxy (ChromaDB, embeddings)
   • server - FastAPI server components
-  • speed - Audio speed adjustment
-  • llm - LLM framework (pydantic-ai)
+  • speed - Audio speed adjustment (audiostretchy)
+  • vad - Voice Activity Detection (Silero VAD via ONNX)
+  • whisper-transformers - Whisper ASR via HuggingFace transformers
+  • wyoming - Wyoming protocol support
 
  Examples:
 
@@ -444,9 +444,9 @@ agent-cli install-extras rag memory vad
 
 
 ╭─ Arguments ────────────────────────────────────────────────────────────────────────────╮
-│   extras      [EXTRAS]...  Extras to install: rag, memory, vad, audio, piper, kokoro,  │
-│                            faster-whisper, mlx-whisper, whisper-transformers, wyoming, │
-│                            server, speed, llm                                          │
+│   extras      [EXTRAS]...  Extras to install: audio, faster-whisper, kokoro, llm,      │
+│                            memory, mlx-whisper, piper, rag, server, speed, vad,        │
+│                            whisper-transformers, wyoming                               │
 ╰────────────────────────────────────────────────────────────────────────────────────────╯
 ╭─ Options ──────────────────────────────────────────────────────────────────────────────╮
 │ --list  -l        Show available extras with descriptions (what each one enables)      │

{agent_cli-0.76.4 → agent_cli-0.76.5}/agent_cli/core/deps.py

@@ -7,7 +7,9 @@ import importlib
 import json
 import os
 import shutil
+import subprocess
 import sys
+import tomllib
 from importlib.util import find_spec
 from pathlib import Path
 from typing import TYPE_CHECKING, TypeVar
@@ -15,7 +17,7 @@ from typing import TYPE_CHECKING, TypeVar
 import typer
 
 from agent_cli.config import load_config
-from agent_cli.core.utils import err_console, print_error_message
+from agent_cli.core.utils import console, err_console, print_error_message
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -26,6 +28,9 @@ F = TypeVar("F", bound="Callable[..., object]")
 _REEXEC_MARKER = "_AGENT_CLI_REEXEC"
 
 
+# -- Settings --
+
+
 def _get_auto_install_setting() -> bool:
     """Check if auto-install is enabled (default: True)."""
     if os.environ.get("AGENT_CLI_NO_AUTO_INSTALL", "").lower() in ("1", "true", "yes"):
@@ -33,6 +38,9 @@ def _get_auto_install_setting() -> bool:
     return load_config().get("settings", {}).get("auto_install_extras", True)
 
 
+# -- Environment Detection --
+
+
 def _is_uvx_cache() -> bool:
     """Check if running from uvx cache (ephemeral) vs uv tool (persistent)."""
     # uvx uses ~/.cache/uv/archive-v0/... (or AppData\Local\uv\cache on Windows)
@@ -42,35 +50,7 @@ def _is_uvx_cache() -> bool:
     return "/cache/uv/" in prefix_str or "/archive-v" in prefix_str
 
 
-def _reexec(cmd: list[str], message: str) -> None:
-    """Re-execute with a new command, preventing infinite loops."""
-    if os.environ.get(_REEXEC_MARKER):
-        return
-    err_console.print(f"[yellow]{message}[/]")
-    new_env = os.environ.copy()
-    new_env[_REEXEC_MARKER] = "1"
-    os.execvpe(cmd[0], cmd, new_env)  # noqa: S606
-
-
-def _reexec_with_uvx_extras(extras: list[str]) -> bool:
-    """Re-execute with uvx running agent-cli[extras] directly."""
-    if os.environ.get(_REEXEC_MARKER) or not _is_uvx_cache():
-        return False
-    uvx_path = shutil.which("uvx")
-    if not uvx_path:
-        return False
-    extras_str = ",".join(extras)
-    # Run agent-cli[extras] directly with Python 3.13 (some deps lack 3.14 wheels)
-    cmd = [uvx_path, "--python", "3.13", f"agent-cli[{extras_str}]", *sys.argv[1:]]
-    _reexec(cmd, f"Re-running with extras: {extras_str}")
-    return True  # Never reached
-
-
-def _reexec_self() -> None:
-    """Re-execute after auto-install so new packages are visible."""
-    executable = shutil.which("agent-cli") or sys.executable
-    _reexec([executable, *sys.argv[1:]], "Re-running with installed extras...")
-
+# -- Package Checking --
 
 # Load extras from JSON file
 _EXTRAS_FILE = Path(__file__).parent.parent / "_extras.json"
@@ -88,7 +68,7 @@ def _check_package_installed(pkg: str) -> bool:
         return False
 
 
-def check_extra_installed(extra: str) -> bool:
+def _check_extra_installed(extra: str) -> bool:
     """Check if packages for an extra are installed using find_spec (no actual import).
 
     Supports `|` syntax for alternatives: "piper|kokoro" means ANY of these extras.
@@ -96,7 +76,7 @@ def check_extra_installed(extra: str) -> bool:
     """
     # Handle "extra1|extra2" syntax - any of these extras is sufficient
     if "|" in extra:
-        return any(check_extra_installed(e) for e in extra.split("|"))
+        return any(_check_extra_installed(e) for e in extra.split("|"))
 
     if extra not in EXTRAS:
         return False  # Unknown extra, trigger install attempt to surface error
@@ -106,6 +86,9 @@ def check_extra_installed(extra: str) -> bool:
     return all(_check_package_installed(pkg) for pkg in packages)
 
 
+# -- Formatting (for error messages) --
+
+
 def _format_extra_item(extra: str) -> str:
     """Format a single extra as a list item with description."""
     desc, _ = EXTRAS.get(extra, ("", []))
@@ -126,7 +109,7 @@ def _format_install_commands(extras: list[str]) -> list[str]:
     ]
 
 
-def get_install_hint(extra: str) -> str:
+def _get_install_hint(extra: str) -> str:
     """Get install command hint for a single extra.
 
     Supports `|` syntax for alternatives: "piper|kokoro" shows both options.
@@ -162,7 +145,7 @@ def get_install_hint(extra: str) -> str:
 def get_combined_install_hint(extras: list[str]) -> str:
     """Get a combined install hint for multiple missing extras."""
     if len(extras) == 1:
-        return get_install_hint(extras[0])
+        return _get_install_hint(extras[0])
 
     lines = ["This command requires the following extras:"]
     lines.extend(_format_extra_item(extra) for extra in extras)
@@ -171,91 +154,214 @@ def get_combined_install_hint(extras: list[str]) -> str:
     return "\n".join(lines)
 
 
-def _resolve_alternative(extra: str) -> str | None:
-    """For an alternative extra like 'a|b|c', return the installed one or first option."""
-    if "|" not in extra:
-        return extra
-    alternatives = extra.split("|")
-    # Check if any alternative is already installed - use that one
-    for alt in alternatives:
-        if check_extra_installed(alt):
-            return alt
-    # None installed, return first option for installation
-    return alternatives[0]
-
-
-def _try_auto_install(
-    missing: list[str],
-    all_required: tuple[str, ...] | None = None,
-) -> bool:
-    """Attempt to auto-install missing extras. Returns True if successful.
-
-    If all_required is provided, ensures all those extras are installed
-    (not just the missing ones) to handle uv tool reinstall properly.
-    With --force, uv replaces the entire install, so we must include
-    ALL required extras to avoid losing ones that were already installed.
+# -- Installation --
+
+_REQUIREMENTS_DIR = Path(__file__).parent.parent / "_requirements"
+
+
+def available_extras() -> list[str]:
+    """List available extras based on requirements files."""
+    if not _REQUIREMENTS_DIR.exists():
+        return []
+    return sorted(p.stem for p in _REQUIREMENTS_DIR.glob("*.txt"))
+
+
+def _requirements_path(extra: str) -> Path:
+    """Get the requirements file path for an extra."""
+    return _REQUIREMENTS_DIR / f"{extra}.txt"
+
+
+def _in_virtualenv() -> bool:
+    """Check if running inside a virtual environment."""
+    return sys.prefix != sys.base_prefix
+
+
+def is_uv_tool_install() -> bool:
+    """Check if running from a uv tool environment."""
+    receipt = Path(sys.prefix) / "uv-receipt.toml"
+    return receipt.exists()
+
+
+def _get_current_uv_tool_extras() -> list[str]:
+    """Get extras currently configured in uv-receipt.toml."""
+    receipt = Path(sys.prefix) / "uv-receipt.toml"
+    if not receipt.exists():
+        return []
+    data = tomllib.loads(receipt.read_text())
+    requirements = data.get("tool", {}).get("requirements", [])
+    for req in requirements:
+        if req.get("name") == "agent-cli":
+            return req.get("extras", [])
+    return []
+
+
+def _install_via_uv_tool(extras: list[str], *, quiet: bool = False) -> bool:
+    """Reinstall agent-cli via uv tool with the specified extras."""
+    extras_str = ",".join(extras)
+    package_spec = f"agent-cli[{extras_str}]"
+    # Cap at Python 3.13 for compatibility - onnxruntime doesn't support 3.14 yet
+    major, minor = sys.version_info[:2]
+    python_version = f"{major}.{min(minor, 13)}"
+    cmd = ["uv", "tool", "install", package_spec, "--force", "--python", python_version]
+    if quiet:
+        cmd.append("-q")
+    # Use stderr for status messages so they don't pollute stdout
+    cmd_str = " ".join(cmd).replace("[", r"\[")
+    err_console.print(f"Running: [cyan]{cmd_str}[/]")
+    result = subprocess.run(cmd, check=False)
+    return result.returncode == 0
+
+
+def _install_cmd() -> list[str]:
+    """Build the install command with appropriate flags."""
+    in_venv = _in_virtualenv()
+    if shutil.which("uv"):
+        cmd = ["uv", "pip", "install", "--python", sys.executable]
+        if not in_venv:
+            cmd.append("--system")
+        return cmd
+    cmd = [sys.executable, "-m", "pip", "install"]
+    if not in_venv:
+        cmd.append("--user")
+    return cmd
+
+
+def install_extras_impl(extras: list[str], *, quiet: bool = False) -> bool:
+    """Install extras. Returns True on success, False on failure."""
+    if is_uv_tool_install():
+        current_extras = _get_current_uv_tool_extras()
+        new_extras = sorted(set(current_extras) | set(extras))
+        return _install_via_uv_tool(new_extras, quiet=quiet)
+
+    cmd = _install_cmd()
+    for extra in extras:
+        req_file = _requirements_path(extra)
+        if not quiet:
+            console.print(f"Installing [cyan]{extra}[/]...")
+        result = subprocess.run(
+            [*cmd, "-r", str(req_file)],
+            check=False,
+            capture_output=quiet,
+        )
+        if result.returncode != 0:
+            return False
+    return True
+
+
+def _install_extras_programmatic(extras: list[str], *, quiet: bool = False) -> bool:
+    """Install extras programmatically (for auto-install feature)."""
+    available = available_extras()
+    valid = [e for e in extras if e in available]
+    invalid = [e for e in extras if e not in available]
+    if invalid:
+        err_console.print(f"[yellow]Unknown extras (skipped): {', '.join(invalid)}[/]")
+    return bool(valid) and install_extras_impl(valid, quiet=quiet)
+
+
+def _resolve_extras_for_install(extras: tuple[str, ...]) -> list[str]:
+    """Normalize extras: resolve 'a|b' alternatives to concrete extras.
+
+    For alternatives, uses the installed one if present, otherwise first option.
     """
-    from agent_cli.install.extras import install_extras_programmatic  # noqa: PLC0415
+    result = []
+    for extra in extras:
+        if "|" in extra:
+            alternatives = extra.split("|")
+            installed = next((a for a in alternatives if _check_extra_installed(a)), None)
+            result.append(installed or alternatives[0])
+        else:
+            result.append(extra)
+    return result
+
+
+def _maybe_exec_with_marker(cmd: list[str], message: str) -> None:
+    """Re-execute with a new command, preventing infinite loops."""
+    if os.environ.get(_REEXEC_MARKER):
+        return
+    err_console.print(f"[yellow]{message}[/]")
+    new_env = os.environ.copy()
+    new_env[_REEXEC_MARKER] = "1"
+    os.execvpe(cmd[0], cmd, new_env)  # noqa: S606
 
-    # Use all required extras if provided, otherwise just missing
-    extras_source = all_required if all_required is not None else missing
 
-    # Resolve alternatives: use installed one if present, otherwise first option
-    extras_to_install = []
-    for extra in extras_source:
-        resolved = _resolve_alternative(extra)
-        if resolved:
-            extras_to_install.append(resolved)
+def _maybe_reexec_with_uvx(extras: list[str]) -> None:
+    """Try to re-execute with uvx running agent-cli[extras] directly.
 
-    # Show only the missing ones in the message (resolved)
-    missing_display = [_resolve_alternative(e) or e.split("|")[0] for e in missing]
+    If successful, replaces the current process (never returns).
+    If not in uvx cache or uvx unavailable, returns normally.
+    """
+    if os.environ.get(_REEXEC_MARKER) or not _is_uvx_cache():
+        return
+    uvx_path = shutil.which("uvx")
+    if not uvx_path:
+        return
+    extras_str = ",".join(extras)
+    # Run agent-cli[extras] directly with Python 3.13 (some deps lack 3.14 wheels)
+    cmd = [uvx_path, "--python", "3.13", f"agent-cli[{extras_str}]", *sys.argv[1:]]
+    _maybe_exec_with_marker(cmd, f"Re-running with extras: {extras_str}")
+
+
+def _try_auto_install(missing_display: list[str], extras_to_install: list[str]) -> bool:
+    """Attempt to auto-install extras. Returns True if successful."""
     err_console.print(
         f"[yellow]Auto-installing missing extras: {', '.join(missing_display)}[/]",
     )
-    return install_extras_programmatic(extras_to_install, quiet=True)
+    return _install_extras_programmatic(extras_to_install, quiet=True)
+
+
+def _maybe_reexec_after_install() -> None:
+    """Re-execute after auto-install so new packages are visible."""
+    executable = shutil.which("agent-cli") or sys.executable
+    _maybe_exec_with_marker([executable, *sys.argv[1:]], "Re-running with installed extras...")
+
+
+# -- Main Orchestration --
 
 
 def _check_and_install_extras(extras: tuple[str, ...]) -> list[str]:
     """Check for missing extras and attempt auto-install. Returns list of still-missing."""
-    missing = [e for e in extras if not check_extra_installed(e)]
+    # 1. Check what's missing
+    missing = [e for e in extras if not _check_extra_installed(e)]
     if not missing:
         return []
 
+    # 2. Auto-install disabled? Show error and return missing
     if not _get_auto_install_setting():
         print_error_message(get_combined_install_hint(missing))
         return missing
 
-    # Resolve alternatives: use installed one if present, otherwise first option
-    extras_to_install = [_resolve_alternative(e) or e.split("|")[0] for e in extras]
+    # 3. Resolve alternatives for installation (normalize once)
+    extras_to_install = _resolve_extras_for_install(extras)
+    missing_display = _resolve_extras_for_install(tuple(missing))
 
-    # For uvx cache environments, re-exec with --with flag
-    # This replaces the current process if successful (never returns)
-    _reexec_with_uvx_extras(extras_to_install)
+    # 4. Try uvx re-exec (replaces process if successful)
+    if _is_uvx_cache():
+        _maybe_reexec_with_uvx(extras_to_install)  # may not return
 
-    # Not in uvx (or re-exec failed), try normal auto-install
-    if not _try_auto_install(missing, all_required=extras):
+    # 5. Try normal auto-install
+    if not _try_auto_install(missing_display, extras_to_install):
         print_error_message("Auto-install failed.\n" + get_combined_install_hint(missing))
         return missing
 
     err_console.print("[green]Installation complete![/]")
 
-    # Re-exec ourselves so the new packages are visible
-    # The newly installed version will run with all extras available
-    # If re-exec succeeds, this never returns
-    _reexec_self()
+    # 6. Re-exec to pick up new packages (may not return)
+    _maybe_reexec_after_install()
 
-    # If we get here, re-exec was skipped (loop prevention) or failed
-    # Check if extras are now available in this process
+    # 7. If we're here, re-exec was skipped - check if packages are now visible
     importlib.invalidate_caches()
-    still_missing = [e for e in extras if not check_extra_installed(e)]
+    still_missing = [e for e in extras if not _check_extra_installed(e)]
     if still_missing:
         print_error_message(
-            "Auto-install completed but some dependencies are still missing.\n"
+            "Extras installed but not visible (restart may be needed).\n"
             + get_combined_install_hint(still_missing),
         )
     return still_missing
 
 
+# -- Decorator --
+
+
 def requires_extras(*extras: str) -> Callable[[F], F]:
     """Decorator to declare required extras for a command.
 

agent_cli-0.76.5/agent_cli/install/extras.py

@@ -0,0 +1,104 @@
+"""Install optional extras at runtime with pinned versions."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from agent_cli.cli import app
+from agent_cli.core.deps import (
+    EXTRAS as _EXTRAS_META,
+)
+from agent_cli.core.deps import (
+    available_extras,
+    install_extras_impl,
+    is_uv_tool_install,
+)
+from agent_cli.core.utils import console, print_error_message
+
+# Extract descriptions from the centralized EXTRAS metadata
+EXTRAS: dict[str, str] = {name: desc for name, (desc, _) in _EXTRAS_META.items()}
+
+
+@app.command("install-extras", rich_help_panel="Installation", no_args_is_help=True)
+def install_extras(
+    extras: Annotated[
+        list[str] | None,
+        typer.Argument(
+            help="Extras to install: `audio`, `faster-whisper`, `kokoro`, `llm`, `memory`, "
+            "`mlx-whisper`, `piper`, `rag`, `server`, `speed`, `vad`, `whisper-transformers`, "
+            "`wyoming`",
+        ),
+    ] = None,
+    list_extras: Annotated[
+        bool,
+        typer.Option(
+            "--list",
+            "-l",
+            help="Show available extras with descriptions (what each one enables)",
+        ),
+    ] = False,
+    all_extras: Annotated[
+        bool,
+        typer.Option("--all", "-a", help="Install all available extras at once"),
+    ] = False,
+) -> None:
+    """Install optional dependencies with pinned, compatible versions.
+
+    Many agent-cli features require optional dependencies. This command installs
+    them with version pinning to ensure compatibility. Dependencies persist
+    across `uv tool upgrade` when installed via `uv tool`.
+
+    **Available extras:**
+    - `audio` - Audio recording/playback
+    - `faster-whisper` - Whisper ASR via CTranslate2
+    - `kokoro` - Kokoro neural TTS (GPU)
+    - `llm` - LLM framework (pydantic-ai)
+    - `memory` - Long-term memory proxy
+    - `mlx-whisper` - Whisper ASR for Apple Silicon
+    - `piper` - Piper TTS (CPU)
+    - `rag` - RAG proxy (ChromaDB, embeddings)
+    - `server` - FastAPI server components
+    - `speed` - Audio speed adjustment (audiostretchy)
+    - `vad` - Voice Activity Detection (Silero VAD via ONNX)
+    - `whisper-transformers` - Whisper ASR via HuggingFace transformers
+    - `wyoming` - Wyoming protocol support
+
+    **Examples:**
+
+        agent-cli install-extras rag           # Install RAG dependencies
+        agent-cli install-extras memory vad    # Install multiple extras
+        agent-cli install-extras --list        # Show available extras
+        agent-cli install-extras --all         # Install all extras
+
+    """
+    available = available_extras()
+
+    if list_extras:
+        console.print("[bold]Available extras:[/]")
+        for name in available:
+            desc = EXTRAS.get(name, "")
+            console.print(f"  [cyan]{name}[/]: {desc}")
+        return
+
+    if all_extras:
+        extras = available
+
+    if not extras:
+        print_error_message("No extras specified. Use --list to see available, or --all.")
+        raise typer.Exit(1)
+
+    invalid = [e for e in extras if e not in available]
+    if invalid:
+        print_error_message(f"Unknown extras: {invalid}. Use --list to see available.")
+        raise typer.Exit(1)
+
+    if not install_extras_impl(extras):
+        print_error_message("Failed to install extras")
+        raise typer.Exit(1)
+
+    if is_uv_tool_install():
+        console.print("[green]Done! Extras will persist across uv tool upgrade.[/]")
+    else:
+        console.print("[green]Done![/]")

{agent_cli-0.76.4 → agent_cli-0.76.5}/tests/conftest.py

@@ -15,7 +15,7 @@ from rich.console import Console
 from agent_cli.core import deps
 
 
-def _mock_check_extra_installed(extra: str) -> bool:  # noqa: ARG001
+def _mock__check_extra_installed(extra: str) -> bool:  # noqa: ARG001
     """Always return True for tests - all extras assumed available."""
     return True
 
@@ -27,7 +27,7 @@ def pytest_configure() -> None:
     import sounddevice during test collection, which triggers Pa_Initialize()
     and hangs on Windows CI without audio hardware.
 
-    Also mocks check_extra_installed to always return True so tests that
+    Also mocks _check_extra_installed to always return True so tests that
     exercise command logic don't fail on missing optional dependencies.
     """
     if "sounddevice" not in sys.modules:
@@ -37,9 +37,9 @@ def pytest_configure() -> None:
         mock_sd.OutputStream = MagicMock()
         sys.modules["sounddevice"] = mock_sd
 
-    # Mock check_extra_installed to always return True for tests
+    # Mock _check_extra_installed to always return True for tests
     # This allows tests to exercise command logic without needing all extras
-    deps.check_extra_installed = _mock_check_extra_installed
+    deps._check_extra_installed = _mock__check_extra_installed
 
 
 def pytest_collection_modifyitems(items: list[pytest.Item]) -> None:

{agent_cli-0.76.4 → agent_cli-0.76.5}/tests/install/test_extras.py

@@ -5,7 +5,8 @@ from __future__ import annotations
 import typing
 
 from agent_cli.core.deps import EXTRAS as EXTRAS_META
-from agent_cli.install.extras import EXTRAS, _available_extras, install_extras
+from agent_cli.core.deps import available_extras
+from agent_cli.install.extras import EXTRAS, install_extras
 
 
 def test_extras_dict_matches_requirements_files() -> None:
@@ -14,7 +15,7 @@ def test_extras_dict_matches_requirements_files() -> None:
     Extras defined in _extras.json may or may not have requirements files.
     Those with requirements files (in _requirements/) should have descriptions.
     """
-    available = set(_available_extras())
+    available = set(available_extras())
     documented = set(EXTRAS.keys())
 
     # Only check that extras with requirements files have documentation
@@ -51,7 +52,7 @@ def test_install_extras_help_lists_all_extras() -> None:
     in install_extras() must be updated to include them. This test catches
     missing extras in the help text.
     """
-    available = set(_available_extras())
+    available = set(available_extras())
     docstring = install_extras.__doc__ or ""
 
     # Get the argument help text from Annotated metadata