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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-cli
-Version: 0.76.3
+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.3 → 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.5/agent_cli/core/deps.py

@@ -0,0 +1,384 @@
+"""Helpers for optional dependency checks."""
+
+from __future__ import annotations
+
+import functools
+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
+
+import typer
+
+from agent_cli.config import load_config
+from agent_cli.core.utils import console, err_console, print_error_message
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+F = TypeVar("F", bound="Callable[..., object]")
+
+# Marker to prevent infinite re-exec loops
+_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"):
+        return False
+    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)
+    # uv tool uses ~/.local/share/uv/tools/... (or AppData\Local\uv\tools on Windows)
+    # Use as_posix() for cross-platform forward-slash paths
+    prefix_str = Path(sys.prefix).resolve().as_posix()
+    return "/cache/uv/" in prefix_str or "/archive-v" in prefix_str
+
+
+# -- Package Checking --
+
+# Load extras from JSON file
+_EXTRAS_FILE = Path(__file__).parent.parent / "_extras.json"
+EXTRAS: dict[str, tuple[str, list[str]]] = {
+    k: (v[0], v[1]) for k, v in json.loads(_EXTRAS_FILE.read_text()).items()
+}
+
+
+def _check_package_installed(pkg: str) -> bool:
+    """Check if a single package is installed."""
+    top_module = pkg.split(".")[0]
+    try:
+        return find_spec(top_module) is not None
+    except (ValueError, ModuleNotFoundError):
+        return False
+
+
+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.
+    For regular extras, ALL packages must be installed.
+    """
+    # Handle "extra1|extra2" syntax - any of these extras is sufficient
+    if "|" in extra:
+        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
+    _, packages = EXTRAS[extra]
+
+    # All packages must be installed
+    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, ("", []))
+    if desc:
+        return f"  - '{extra}' ({desc})"
+    return f"  - '{extra}'"
+
+
+def _format_install_commands(extras: list[str]) -> list[str]:
+    """Format install commands for one or more extras."""
+    combined = ",".join(extras)
+    extras_args = " ".join(extras)
+    return [
+        "Install with:",
+        f'  [bold cyan]uv tool install -p 3.13 "agent-cli\\[{combined}]"[/bold cyan]',
+        "  # or",
+        f"  [bold cyan]agent-cli install-extras {extras_args}[/bold cyan]",
+    ]
+
+
+def _get_install_hint(extra: str) -> str:
+    """Get install command hint for a single extra.
+
+    Supports `|` syntax for alternatives: "piper|kokoro" shows both options.
+    """
+    # Handle "extra1|extra2" syntax - show all options
+    if "|" in extra:
+        alternatives = extra.split("|")
+        lines = ["This command requires one of:"]
+        lines.extend(_format_extra_item(alt) for alt in alternatives)
+        lines.append("")
+        lines.append("Install one with:")
+        lines.extend(
+            f'  [bold cyan]uv tool install -p 3.13 "agent-cli\\[{alt}]"[/bold cyan]'
+            for alt in alternatives
+        )
+        lines.append("  # or")
+        lines.extend(
+            f"  [bold cyan]agent-cli install-extras {alt}[/bold cyan]" for alt in alternatives
+        )
+        return "\n".join(lines)
+
+    desc, _ = EXTRAS.get(extra, ("", []))
+    header = f"This command requires the '{extra}' extra"
+    if desc:
+        header += f" ({desc})"
+    header += "."
+
+    lines = [header, ""]
+    lines.extend(_format_install_commands([extra]))
+    return "\n".join(lines)
+
+
+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])
+
+    lines = ["This command requires the following extras:"]
+    lines.extend(_format_extra_item(extra) for extra in extras)
+    lines.append("")
+    lines.extend(_format_install_commands(extras))
+    return "\n".join(lines)
+
+
+# -- 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.
+    """
+    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
+
+
+def _maybe_reexec_with_uvx(extras: list[str]) -> None:
+    """Try to re-execute with uvx running agent-cli[extras] directly.
+
+    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)
+
+
+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."""
+    # 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
+
+    # 3. Resolve alternatives for installation (normalize once)
+    extras_to_install = _resolve_extras_for_install(extras)
+    missing_display = _resolve_extras_for_install(tuple(missing))
+
+    # 4. Try uvx re-exec (replaces process if successful)
+    if _is_uvx_cache():
+        _maybe_reexec_with_uvx(extras_to_install)  # may not return
+
+    # 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![/]")
+
+    # 6. Re-exec to pick up new packages (may not return)
+    _maybe_reexec_after_install()
+
+    # 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)]
+    if still_missing:
+        print_error_message(
+            "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.
+
+    Auto-installs missing extras by default. Disable via AGENT_CLI_NO_AUTO_INSTALL=1
+    or config [settings] auto_install_extras = false.
+    """
+
+    def decorator(func: F) -> F:
+        func._required_extras = extras  # type: ignore[attr-defined]
+
+        @functools.wraps(func)
+        def wrapper(*args: object, **kwargs: object) -> object:
+            if _check_and_install_extras(extras):
+                raise typer.Exit(1)
+            return func(*args, **kwargs)
+
+        wrapper._required_extras = extras  # type: ignore[attr-defined]
+        return wrapper  # type: ignore[return-value]
+
+    return decorator

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.3 → 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.3 → 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