agent-cli 0.67.2__tar.gz → 0.68.1__tar.gz

{agent_cli-0.67.2 → agent_cli-0.68.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-cli
-Version: 0.67.2
+Version: 0.68.1
 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>
@@ -459,7 +459,14 @@ All necessary scripts are bundled with the package, so you can run these command
 
 #### Installing Optional Extras
 
-Some features require additional Python dependencies. Use `install-extras` to install them with pinned versions:
+Some features require additional Python dependencies. By default, **agent-cli will auto-install missing extras** when you run a command that needs them. To disable this, set `AGENT_CLI_NO_AUTO_INSTALL=1` or add to your config file:
+
+```toml
+[settings]
+auto_install_extras = false
+```
+
+You can also manually install extras with `install-extras`:
 
 ```bash
 # List available extras

{agent_cli-0.67.2 → agent_cli-0.68.1}/README.md

@@ -377,7 +377,14 @@ All necessary scripts are bundled with the package, so you can run these command
 
 #### Installing Optional Extras
 
-Some features require additional Python dependencies. Use `install-extras` to install them with pinned versions:
+Some features require additional Python dependencies. By default, **agent-cli will auto-install missing extras** when you run a command that needs them. To disable this, set `AGENT_CLI_NO_AUTO_INSTALL=1` or add to your config file:
+
+```toml
+[settings]
+auto_install_extras = false
+```
+
+You can also manually install extras with `install-extras`:
 
 ```bash
 # List available extras

{agent_cli-0.67.2 → agent_cli-0.68.1}/agent_cli/core/deps.py

@@ -4,19 +4,29 @@ from __future__ import annotations
 
 import functools
 import json
+import os
 from importlib.util import find_spec
 from pathlib import Path
 from typing import TYPE_CHECKING, TypeVar
 
 import typer
 
-from agent_cli.core.utils import print_error_message
+from agent_cli.config import load_config
+from agent_cli.core.utils import console, print_error_message
 
 if TYPE_CHECKING:
     from collections.abc import Callable
 
 F = TypeVar("F", bound="Callable[..., object]")
 
+
+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)
+
+
 # Load extras from JSON file
 _EXTRAS_FILE = Path(__file__).parent.parent / "_extras.json"
 EXTRAS: dict[str, tuple[str, list[str]]] = {
@@ -44,7 +54,7 @@ def check_extra_installed(extra: str) -> bool:
         return any(check_extra_installed(e) for e in extra.split("|"))
 
     if extra not in EXTRAS:
-        return True  # Unknown extra, assume OK
+        return False  # Unknown extra, trigger install attempt to surface error
     _, packages = EXTRAS[extra]
 
     # All packages must be installed
@@ -116,44 +126,65 @@ def get_combined_install_hint(extras: list[str]) -> str:
     return "\n".join(lines)
 
 
-def requires_extras(*extras: str) -> Callable[[F], F]:
-    """Decorator to declare required extras for a command.
-
-    When a required extra is missing, the decorator prints a helpful error
-    message and exits with code 1.
-
-    The decorator stores the required extras on the function for test validation.
+def _try_auto_install(missing: list[str]) -> bool:
+    """Attempt to auto-install missing extras. Returns True if successful."""
+    from agent_cli.install.extras import install_extras_programmatic  # noqa: PLC0415
+
+    # Flatten alternatives (e.g., "piper|kokoro" -> just pick the first one)
+    extras_to_install = []
+    for extra in missing:
+        if "|" in extra:
+            # For alternatives, install the first option
+            extras_to_install.append(extra.split("|")[0])
+        else:
+            extras_to_install.append(extra)
+
+    console.print(
+        f"[yellow]Auto-installing missing extras: {', '.join(extras_to_install)}[/]",
+    )
+    return install_extras_programmatic(extras_to_install)
+
+
+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)]
+    if not missing:
+        return []
+
+    if not _get_auto_install_setting():
+        print_error_message(get_combined_install_hint(missing))
+        return missing
+
+    if not _try_auto_install(missing):
+        print_error_message("Auto-install failed.\n" + get_combined_install_hint(missing))
+        return missing
+
+    console.print("[green]Installation complete![/]")
+    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"
+            + get_combined_install_hint(still_missing),
+        )
+    return still_missing
 
-    Process management flags (--stop, --status, --toggle) skip the dependency
-    check since they just manage running processes without using the actual
-    dependencies.
 
-    Example:
-        @app.command("rag-proxy")
-        @requires_extras("rag")
-        def rag_proxy(...):
-            ...
+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:
-        # Store extras on function for test introspection
         func._required_extras = extras  # type: ignore[attr-defined]
 
         @functools.wraps(func)
         def wrapper(*args: object, **kwargs: object) -> object:
-            # Skip dependency check for process management and info operations
-            # These don't need the actual dependencies, just manage processes or list info
-            if any(kwargs.get(flag) for flag in ("stop", "status", "toggle", "list_devices")):
-                return func(*args, **kwargs)
-
-            missing = [e for e in extras if not check_extra_installed(e)]
-            if missing:
-                print_error_message(get_combined_install_hint(missing))
+            if _check_and_install_extras(extras):
                 raise typer.Exit(1)
             return func(*args, **kwargs)
 
-        # Preserve the extras on wrapper too
         wrapper._required_extras = extras  # type: ignore[attr-defined]
         return wrapper  # type: ignore[return-value]
 

{agent_cli-0.67.2 → agent_cli-0.68.1}/agent_cli/install/extras.py

@@ -86,6 +86,38 @@ def _install_cmd() -> list[str]:
     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)
+
+    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:
+        console.print(f"[yellow]Unknown extras (skipped): {', '.join(invalid)}[/]")
+    return bool(valid) and _install_extras_impl(valid, quiet=quiet)
+
+
 @app.command("install-extras", rich_help_panel="Installation")
 def install_extras(
     extras: Annotated[list[str] | None, typer.Argument(help="Extras to install")] = None,
@@ -128,25 +160,11 @@ def install_extras(
         print_error_message(f"Unknown extras: {invalid}. Use --list to see available.")
         raise typer.Exit(1)
 
-    # If running from uv tool install, reinstall with extras to persist them
+    if not _install_extras_impl(extras):
+        print_error_message("Failed to install extras")
+        raise typer.Exit(1)
+
     if _is_uv_tool_install():
-        current_extras = _get_current_uv_tool_extras()
-        new_extras = sorted(set(current_extras) | set(extras))
-        if not _install_via_uv_tool(new_extras):
-            print_error_message("Failed to reinstall via uv tool")
-            raise typer.Exit(1)
         console.print("[green]Done! Extras will persist across uv tool upgrade.[/]")
-        return
-
-    # Standard pip/uv pip install for non-tool environments
-    cmd = _install_cmd()
-
-    for extra in extras:
-        req_file = _requirements_path(extra)
-        console.print(f"Installing [cyan]{extra}[/]...")
-        result = subprocess.run([*cmd, "-r", str(req_file)], check=False)
-        if result.returncode != 0:
-            print_error_message(f"Failed to install '{extra}'")
-            raise typer.Exit(1)
-
-    console.print("[green]Done![/]")
+    else:
+        console.print("[green]Done![/]")

{agent_cli-0.67.2 → agent_cli-0.68.1}/agent_cli/server/cli.py

@@ -20,13 +20,13 @@ console = Console()
 err_console = Console(stderr=True)
 logger = logging.getLogger(__name__)
 
-# Check for optional dependencies
-HAS_UVICORN = find_spec("uvicorn") is not None
-HAS_FASTAPI = find_spec("fastapi") is not None
-HAS_FASTER_WHISPER = find_spec("faster_whisper") is not None
-HAS_MLX_WHISPER = find_spec("mlx_whisper") is not None
-HAS_PIPER = find_spec("piper") is not None
-HAS_KOKORO = find_spec("kokoro") is not None
+# Check for optional dependencies at call time (not module load time)
+# This is important because auto-install may install packages after the module is loaded
+
+
+def _has(package: str) -> bool:
+    return find_spec(package) is not None
+
 
 app = typer.Typer(
     name="server",
@@ -48,7 +48,7 @@ def server_callback(ctx: typer.Context) -> None:
 
 def _check_server_deps() -> None:
     """Check that server dependencies are available."""
-    if not HAS_UVICORN or not HAS_FASTAPI:
+    if not _has("uvicorn") or not _has("fastapi"):
         err_console.print(
             "[bold red]Error:[/bold red] Server dependencies not installed. "
             "Run: [cyan]pip install agent-cli\\[server][/cyan] "
@@ -62,7 +62,7 @@ def _check_tts_deps(backend: str = "auto") -> None:
     _check_server_deps()
 
     if backend == "kokoro":
-        if not HAS_KOKORO:
+        if not _has("kokoro"):
             err_console.print(
                 "[bold red]Error:[/bold red] Kokoro backend requires kokoro. "
                 "Run: [cyan]pip install agent-cli\\[tts-kokoro][/cyan] "
@@ -72,7 +72,7 @@ def _check_tts_deps(backend: str = "auto") -> None:
         return
 
     if backend == "piper":
-        if not HAS_PIPER:
+        if not _has("piper"):
             err_console.print(
                 "[bold red]Error:[/bold red] Piper backend requires piper-tts. "
                 "Run: [cyan]pip install agent-cli\\[tts][/cyan] "
@@ -82,7 +82,7 @@ def _check_tts_deps(backend: str = "auto") -> None:
         return
 
     # For auto, check if either is available
-    if not HAS_PIPER and not HAS_KOKORO:
+    if not _has("piper") and not _has("kokoro"):
         err_console.print(
             "[bold red]Error:[/bold red] No TTS backend available. "
             "Run: [cyan]pip install agent-cli\\[tts][/cyan] for Piper "
@@ -136,7 +136,7 @@ def _check_whisper_deps(backend: str, *, download_only: bool = False) -> None:
     """Check that Whisper dependencies are available."""
     _check_server_deps()
     if download_only:
-        if not HAS_FASTER_WHISPER:
+        if not _has("faster_whisper"):
             err_console.print(
                 "[bold red]Error:[/bold red] faster-whisper is required for --download-only. "
                 "Run: [cyan]pip install agent-cli\\[whisper][/cyan] "
@@ -146,7 +146,7 @@ def _check_whisper_deps(backend: str, *, download_only: bool = False) -> None:
         return
 
     if backend == "mlx":
-        if not HAS_MLX_WHISPER:
+        if not _has("mlx_whisper"):
             err_console.print(
                 "[bold red]Error:[/bold red] MLX Whisper backend requires mlx-whisper. "
                 "Run: [cyan]pip install mlx-whisper[/cyan]",
@@ -154,7 +154,7 @@ def _check_whisper_deps(backend: str, *, download_only: bool = False) -> None:
             raise typer.Exit(1)
         return
 
-    if not HAS_FASTER_WHISPER:
+    if not _has("faster_whisper"):
         err_console.print(
             "[bold red]Error:[/bold red] Whisper dependencies not installed. "
             "Run: [cyan]pip install agent-cli\\[whisper][/cyan] "

{agent_cli-0.67.2 → agent_cli-0.68.1}/docs/architecture/index.md

@@ -141,22 +141,39 @@ Usage: [rag-proxy command](../commands/rag-proxy.md).
 
 ## Dependencies
 
+Agent CLI uses a modular dependency structure. The base package is lightweight, with features installed as optional extras.
+
 ### Core Dependencies
 
+Always installed:
+
 - **typer** - CLI framework
-- **pydantic-ai-slim** - AI agent framework with tool support
-- **sounddevice** - Audio I/O
-- **pyperclip** - Clipboard access
+- **pydantic** - Data validation
 - **rich** - Terminal formatting
-- **wyoming** - Protocol for local AI services
-- **openai** - OpenAI-compatible API client
-- **google-genai** - Google Gemini API client
+- **pyperclip** - Clipboard access
+- **httpx** - HTTP client
+
+### Provider Extras
+
+Install with `agent-cli install-extras <name>` or `pip install agent-cli[name]`:
+
+| Extra | Purpose | Key Packages |
+|-------|---------|--------------|
+| `audio` | Voice features | sounddevice, wyoming, numpy |
+| `llm` | AI processing | pydantic-ai-slim (OpenAI, Gemini) |
+
+### Feature Extras
 
-### Optional Dependencies
+| Extra | Purpose | Key Packages |
+|-------|---------|--------------|
+| `vad` | Voice activity detection | silero-vad |
+| `rag` | Document chat | chromadb, markitdown |
+| `memory` | Long-term memory | chromadb |
+| `server` | Local ASR/TTS servers | fastapi |
+| `faster-whisper` | Whisper (CUDA/CPU) | faster-whisper |
+| `mlx-whisper` | Whisper (Apple Silicon) | mlx-whisper |
 
-- **silero-vad** - Voice activity detection (for `transcribe-daemon`)
-- **chromadb** - Vector database (for RAG and memory)
-- **markitdown** - Document parsing (for RAG)
+See [`install-extras`](../commands/install-extras.md) for the full list and installation instructions.
 
 ## Platform Support
 

agent_cli-0.68.1/tests/test_requires_extras.py

@@ -0,0 +1,285 @@
+"""Tests for @requires_extras decorator functionality."""
+
+from __future__ import annotations
+
+import os
+from unittest.mock import patch
+
+import pytest
+import typer
+
+from agent_cli.core.deps import (
+    EXTRAS,
+    _check_and_install_extras,
+    _get_auto_install_setting,
+    _try_auto_install,
+    get_install_hint,
+    requires_extras,
+)
+
+
+class TestRequiresExtrasDecorator:
+    """Test the requires_extras decorator functionality."""
+
+    def test_decorator_stores_extras_on_function(self) -> None:
+        """The decorator should store required extras on the function."""
+
+        @requires_extras("audio", "llm")
+        def sample_command() -> str:
+            return "success"
+
+        assert hasattr(sample_command, "_required_extras")
+        assert sample_command._required_extras == ("audio", "llm")
+
+    def test_get_install_hint_with_pipe_syntax(self) -> None:
+        """Pipe syntax shows all alternatives in the hint."""
+        hint = get_install_hint("piper|kokoro")
+        assert "requires one of:" in hint
+        assert "'piper'" in hint
+        assert "'kokoro'" in hint
+        # Brackets are escaped for rich markup (\\[)
+        assert "agent-cli\\[piper]" in hint
+        assert "agent-cli\\[kokoro]" in hint
+
+
+class TestExtrasMetadata:
+    """Test the _extras.json metadata is properly structured."""
+
+    def test_extras_dict_structure(self) -> None:
+        """EXTRAS dict should have proper structure."""
+        assert isinstance(EXTRAS, dict)
+        for name, value in EXTRAS.items():
+            assert isinstance(name, str)
+            assert isinstance(value, tuple)
+            assert len(value) == 2
+            desc, packages = value
+            assert isinstance(desc, str)
+            assert isinstance(packages, list)
+            assert all(isinstance(pkg, str) for pkg in packages)
+
+    def test_essential_extras_present(self) -> None:
+        """Essential extras should be defined."""
+        essential = ["audio", "llm", "rag", "memory", "vad"]
+        for extra in essential:
+            assert extra in EXTRAS, f"Missing essential extra: {extra}"
+
+
+class TestAutoInstallSetting:
+    """Test the auto-install extras configuration."""
+
+    def test_default_is_enabled(self) -> None:
+        """Auto-install should be enabled by default."""
+        env = dict(os.environ)
+        env.pop("AGENT_CLI_NO_AUTO_INSTALL", None)
+        with (
+            patch.dict(os.environ, env, clear=True),
+            patch("agent_cli.core.deps.load_config", return_value={}),
+        ):
+            assert _get_auto_install_setting() is True
+
+    def test_env_var_disables(self) -> None:
+        """AGENT_CLI_NO_AUTO_INSTALL=1 should disable auto-install."""
+        with patch.dict(os.environ, {"AGENT_CLI_NO_AUTO_INSTALL": "1"}):
+            assert _get_auto_install_setting() is False
+
+    def test_env_var_true_disables(self) -> None:
+        """AGENT_CLI_NO_AUTO_INSTALL=true should disable auto-install."""
+        with patch.dict(os.environ, {"AGENT_CLI_NO_AUTO_INSTALL": "true"}):
+            assert _get_auto_install_setting() is False
+
+    def test_env_var_yes_disables(self) -> None:
+        """AGENT_CLI_NO_AUTO_INSTALL=yes should disable auto-install."""
+        with patch.dict(os.environ, {"AGENT_CLI_NO_AUTO_INSTALL": "yes"}):
+            assert _get_auto_install_setting() is False
+
+    def test_config_file_disables(self) -> None:
+        """Config [settings] section with auto_install_extras = false should disable."""
+        env = dict(os.environ)
+        env.pop("AGENT_CLI_NO_AUTO_INSTALL", None)
+        with (
+            patch.dict(os.environ, env, clear=True),
+            patch(
+                "agent_cli.core.deps.load_config",
+                return_value={"settings": {"auto_install_extras": False}},
+            ),
+        ):
+            assert _get_auto_install_setting() is False
+
+    def test_config_file_enables(self) -> None:
+        """Config [settings] section with auto_install_extras = true should enable."""
+        env = dict(os.environ)
+        env.pop("AGENT_CLI_NO_AUTO_INSTALL", None)
+        with (
+            patch.dict(os.environ, env, clear=True),
+            patch(
+                "agent_cli.core.deps.load_config",
+                return_value={"settings": {"auto_install_extras": True}},
+            ),
+        ):
+            assert _get_auto_install_setting() is True
+
+    def test_env_var_takes_precedence(self) -> None:
+        """Environment variable should take precedence over config file."""
+        with (
+            patch.dict(os.environ, {"AGENT_CLI_NO_AUTO_INSTALL": "1"}),
+            patch(
+                "agent_cli.core.deps.load_config",
+                return_value={"settings": {"auto_install_extras": True}},
+            ),
+        ):
+            assert _get_auto_install_setting() is False
+
+
+class TestTryAutoInstall:
+    """Test the _try_auto_install function."""
+
+    def test_flattens_alternatives(self) -> None:
+        """Alternatives like 'piper|kokoro' should pick the first option."""
+        with patch(
+            "agent_cli.install.extras.install_extras_programmatic",
+            return_value=True,
+        ) as mock_install:
+            result = _try_auto_install(["audio", "piper|kokoro"])
+            assert result is True
+            mock_install.assert_called_once_with(["audio", "piper"])
+
+    def test_returns_install_result(self) -> None:
+        """Should return the result from install_extras_programmatic."""
+        with patch(
+            "agent_cli.install.extras.install_extras_programmatic",
+            return_value=False,
+        ):
+            assert _try_auto_install(["audio"]) is False
+
+        with patch(
+            "agent_cli.install.extras.install_extras_programmatic",
+            return_value=True,
+        ):
+            assert _try_auto_install(["audio"]) is True
+
+
+class TestCheckAndInstallExtras:
+    """Test the _check_and_install_extras function."""
+
+    def test_returns_empty_when_all_installed(self) -> None:
+        """Should return empty list when all extras are already installed."""
+        with patch("agent_cli.core.deps.check_extra_installed", return_value=True):
+            result = _check_and_install_extras(("audio", "llm"))
+            assert result == []
+
+    def test_returns_missing_when_auto_install_disabled(self) -> None:
+        """Should return missing list without installing when disabled."""
+        with (
+            patch("agent_cli.core.deps.check_extra_installed", return_value=False),
+            patch("agent_cli.core.deps._get_auto_install_setting", return_value=False),
+            patch("agent_cli.core.deps.print_error_message") as mock_error,
+        ):
+            result = _check_and_install_extras(("fake-extra",))
+            assert result == ["fake-extra"]
+            mock_error.assert_called_once()
+
+    def test_returns_missing_when_install_fails(self) -> None:
+        """Should return missing list when auto-install fails."""
+        with (
+            patch("agent_cli.core.deps.check_extra_installed", return_value=False),
+            patch("agent_cli.core.deps._get_auto_install_setting", return_value=True),
+            patch("agent_cli.core.deps._try_auto_install", return_value=False),
+            patch("agent_cli.core.deps.print_error_message") as mock_error,
+        ):
+            result = _check_and_install_extras(("fake-extra",))
+            assert result == ["fake-extra"]
+            mock_error.assert_called_once()
+            assert "Auto-install failed" in mock_error.call_args[0][0]
+
+    def test_returns_empty_when_install_succeeds(self) -> None:
+        """Should return empty list when auto-install succeeds."""
+        check_results = iter([False, True])  # First call: missing, second: installed
+        with (
+            patch(
+                "agent_cli.core.deps.check_extra_installed",
+                side_effect=lambda _: next(check_results),
+            ),
+            patch("agent_cli.core.deps._get_auto_install_setting", return_value=True),
+            patch("agent_cli.core.deps._try_auto_install", return_value=True),
+        ):
+            result = _check_and_install_extras(("fake-extra",))
+            assert result == []
+
+    def test_returns_still_missing_after_partial_install(self) -> None:
+        """Should return still-missing extras after install completes."""
+        # First check: missing, install succeeds, second check: still missing
+        with (
+            patch("agent_cli.core.deps.check_extra_installed", return_value=False),
+            patch("agent_cli.core.deps._get_auto_install_setting", return_value=True),
+            patch("agent_cli.core.deps._try_auto_install", return_value=True),
+            patch("agent_cli.core.deps.print_error_message") as mock_error,
+        ):
+            result = _check_and_install_extras(("fake-extra",))
+            assert result == ["fake-extra"]
+            mock_error.assert_called_once()
+            assert "still missing" in mock_error.call_args[0][0]
+
+
+class TestDecoratorIntegration:
+    """Test the requires_extras decorator end-to-end behavior."""
+
+    def test_calls_function_when_extras_installed(self) -> None:
+        """Decorated function should run when extras are installed."""
+        with patch("agent_cli.core.deps.check_extra_installed", return_value=True):
+
+            @requires_extras("audio")
+            def my_command() -> str:
+                return "success"
+
+            assert my_command() == "success"
+
+    def test_exits_when_extras_missing_and_auto_install_disabled(self) -> None:
+        """Should exit when extras missing and auto-install is disabled."""
+        with (
+            patch("agent_cli.core.deps.check_extra_installed", return_value=False),
+            patch("agent_cli.core.deps._get_auto_install_setting", return_value=False),
+            patch("agent_cli.core.deps.print_error_message"),
+        ):
+
+            @requires_extras("fake-extra")
+            def my_command() -> str:
+                return "success"
+
+            with pytest.raises(typer.Exit) as exc_info:
+                my_command()
+            assert exc_info.value.exit_code == 1
+
+    def test_auto_installs_and_runs_on_success(self) -> None:
+        """Should auto-install, then run the function on success."""
+        check_results = iter([False, True])  # Missing first, then installed
+        with (
+            patch(
+                "agent_cli.core.deps.check_extra_installed",
+                side_effect=lambda _: next(check_results),
+            ),
+            patch("agent_cli.core.deps._get_auto_install_setting", return_value=True),
+            patch("agent_cli.core.deps._try_auto_install", return_value=True),
+        ):
+
+            @requires_extras("fake-extra")
+            def my_command() -> str:
+                return "success"
+
+            assert my_command() == "success"
+
+    def test_exits_when_auto_install_fails(self) -> None:
+        """Should exit when auto-install fails."""
+        with (
+            patch("agent_cli.core.deps.check_extra_installed", return_value=False),
+            patch("agent_cli.core.deps._get_auto_install_setting", return_value=True),
+            patch("agent_cli.core.deps._try_auto_install", return_value=False),
+            patch("agent_cli.core.deps.print_error_message"),
+        ):
+
+            @requires_extras("fake-extra")
+            def my_command() -> str:
+                return "success"
+
+            with pytest.raises(typer.Exit) as exc_info:
+                my_command()
+            assert exc_info.value.exit_code == 1

{agent_cli-0.67.2 → agent_cli-0.68.1}/zensical.toml

@@ -49,6 +49,7 @@ nav = [
     ] },
     { "Setup" = [
       { "config" = "commands/config.md" },
+      { "install-extras" = "commands/install-extras.md" },
       { "install-services" = "commands/install-services.md" },
       { "install-hotkeys" = "commands/install-hotkeys.md" },
       { "start-services" = "commands/start-services.md" },