agent-cli 0.61.2__py3-none-any.whl → 0.70.2__py3-none-any.whl

agent_cli/scripts/check_plugin_skill_sync.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""Check that plugin skill files are in sync with source files."""
+
+import sys
+from pathlib import Path
+
+SYNC_PAIRS = [
+    # Plugin marketplace distribution
+    ("agent_cli/dev/skill/SKILL.md", ".claude-plugin/skills/agent-cli-dev/SKILL.md"),
+    ("agent_cli/dev/skill/examples.md", ".claude-plugin/skills/agent-cli-dev/examples.md"),
+    # Project-local skill (for Claude Code working on this repo)
+    ("agent_cli/dev/skill/SKILL.md", ".claude/skills/agent-cli-dev/SKILL.md"),
+    ("agent_cli/dev/skill/examples.md", ".claude/skills/agent-cli-dev/examples.md"),
+]
+
+
+def main() -> int:
+    """Check that plugin skill files match source files."""
+    root = Path(__file__).parent.parent
+    out_of_sync = []
+
+    for source, target in SYNC_PAIRS:
+        source_path = root / source
+        target_path = root / target
+
+        if not source_path.exists():
+            print(f"Source not found: {source}")
+            continue
+
+        if not target_path.exists():
+            out_of_sync.append((source, target, "target missing"))
+            continue
+
+        if source_path.read_text() != target_path.read_text():
+            out_of_sync.append((source, target, "content differs"))
+
+    if out_of_sync:
+        print("Plugin skill files are out of sync:")
+        for source, target, reason in out_of_sync:
+            print(f"  {source} -> {target} ({reason})")
+        print("\nRun:")
+        print("  cp agent_cli/dev/skill/*.md .claude-plugin/skills/agent-cli-dev/")
+        print("  cp agent_cli/dev/skill/*.md .claude/skills/agent-cli-dev/")
+        return 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

agent_cli/scripts/sync_extras.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+"""Generate _extras.json from pyproject.toml.
+
+This script parses the optional-dependencies in pyproject.toml and generates
+the agent_cli/_extras.json file with package-to-import mappings.
+
+Usage:
+    python scripts/sync_extras.py
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import sys
+import tomllib
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).parent.parent
+PYPROJECT = REPO_ROOT / "pyproject.toml"
+EXTRAS_FILE = REPO_ROOT / "agent_cli" / "_extras.json"
+
+# Extras to skip (dev/test dependencies, not runtime installable)
+SKIP_EXTRAS = {"dev", "test"}
+
+# Manual mapping of extra name -> (description, list of import names)
+# Import names should be the Python module name (how you import it)
+# Bundle extras (voice, cloud, full) have empty import lists since they just install other extras
+EXTRA_METADATA: dict[str, tuple[str, list[str]]] = {
+    # Provider extras (base dependencies now optional)
+    "audio": ("Audio recording/playback", ["sounddevice"]),
+    "wyoming": ("Wyoming protocol support", ["wyoming"]),
+    "openai": ("OpenAI API provider", ["openai"]),
+    "gemini": ("Google Gemini provider", ["google.genai"]),
+    "llm": ("LLM framework (pydantic-ai)", ["pydantic_ai"]),
+    # Feature extras
+    "rag": ("RAG proxy (ChromaDB, embeddings)", ["chromadb"]),
+    "memory": ("Long-term memory proxy", ["chromadb", "yaml"]),
+    "vad": ("Voice Activity Detection (silero-vad)", ["silero_vad"]),
+    "whisper": ("Local Whisper ASR (faster-whisper)", ["faster_whisper"]),
+    "whisper-mlx": ("MLX Whisper for Apple Silicon", ["mlx_whisper"]),
+    "tts": ("Local Piper TTS", ["piper"]),
+    "tts-kokoro": ("Kokoro neural TTS", ["kokoro"]),
+    "server": ("FastAPI server components", ["fastapi"]),
+    "speed": ("Audio speed adjustment (audiostretchy)", ["audiostretchy"]),
+}
+
+
+def get_extras_from_pyproject() -> set[str]:
+    """Parse optional-dependencies from pyproject.toml."""
+    with PYPROJECT.open("rb") as f:
+        data = tomllib.load(f)
+    all_extras = set(data.get("project", {}).get("optional-dependencies", {}).keys())
+    return all_extras - SKIP_EXTRAS
+
+
+def extract_package_name(dep: str) -> str:
+    """Extract the package name from a dependency specification.
+
+    Examples:
+        "chromadb>=0.4.22" -> "chromadb"
+        "pydantic-ai-slim[openai,duckduckgo]" -> "pydantic-ai-slim"
+        'mlx-whisper>=0.4.0; sys_platform == "darwin"' -> "mlx-whisper"
+
+    """
+    # Remove markers (;...) and extras ([...])
+    dep = re.split(r"[;\[]", dep)[0]
+    # Remove version specifiers
+    dep = re.split(r"[<>=!~]", dep)[0]
+    return dep.strip()
+
+
+def package_to_import_name(package: str) -> str:
+    """Convert a package name to its Python import name.
+
+    Examples:
+        "google-genai" -> "google.genai"
+        "pydantic-ai-slim" -> "pydantic_ai"
+        "silero-vad" -> "silero_vad"
+        "faster-whisper" -> "faster_whisper"
+
+    """
+    # Special cases where the import name differs significantly
+    special_cases = {
+        "google-genai": "google.genai",
+        "pydantic-ai-slim": "pydantic_ai",
+        "silero-vad": "silero_vad",
+        "faster-whisper": "faster_whisper",
+        "mlx-whisper": "mlx_whisper",
+        "piper-tts": "piper",
+        "huggingface-hub": "huggingface_hub",
+        "fastapi": "fastapi",
+        "audiostretchy": "audiostretchy",
+    }
+    if package in special_cases:
+        return special_cases[package]
+    # Default: replace hyphens with underscores
+    return package.replace("-", "_")
+
+
+def generate_extras_json(extras: set[str]) -> dict[str, list]:
+    """Generate the content for _extras.json."""
+    result = {}
+    for extra in sorted(extras):
+        if extra in EXTRA_METADATA:
+            desc, imports = EXTRA_METADATA[extra]
+            result[extra] = [desc, imports]
+        else:
+            # Unknown extra - add a placeholder
+            result[extra] = ["TODO: add description", []]
+    return result
+
+
+def check_missing_metadata(extras: set[str]) -> list[str]:
+    """Check for extras that don't have metadata defined."""
+    return [e for e in extras if e not in EXTRA_METADATA]
+
+
+def main() -> int:
+    """Generate _extras.json from pyproject.toml."""
+    extras = get_extras_from_pyproject()
+
+    # Check for missing metadata
+    missing = check_missing_metadata(extras)
+    if missing:
+        print(f"Warning: The following extras need metadata in EXTRA_METADATA: {missing}")
+        print("Please update EXTRA_METADATA in scripts/sync_extras.py")
+
+    # Generate the file
+    content = generate_extras_json(extras)
+    EXTRAS_FILE.write_text(json.dumps(content, indent=2) + "\n")
+    print(f"Generated {EXTRAS_FILE}")
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

agent_cli/server/cli.py

@@ -9,23 +9,22 @@ from pathlib import Path  # noqa: TC003 - Typer needs this at runtime
 from typing import Annotated
 
 import typer
-from rich.console import Console
 
 from agent_cli.cli import app as main_app
+from agent_cli.core.deps import requires_extras
 from agent_cli.core.process import set_process_title
+from agent_cli.core.utils import console, err_console
 from agent_cli.server.common import setup_rich_logging
 
-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",
@@ -34,7 +33,7 @@ app = typer.Typer(
     rich_markup_mode="markdown",
     no_args_is_help=True,
 )
-main_app.add_typer(app, name="server")
+main_app.add_typer(app, name="server", rich_help_panel="Servers")
 
 
 @app.callback()
@@ -47,7 +46,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] "
@@ -61,7 +60,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] "
@@ -71,7 +70,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] "
@@ -81,7 +80,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 "
@@ -135,7 +134,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] "
@@ -145,7 +144,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]",
@@ -153,7 +152,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] "
@@ -163,6 +162,7 @@ def _check_whisper_deps(backend: str, *, download_only: bool = False) -> None:
 
 
 @app.command("whisper")
+@requires_extras("server", "faster-whisper|mlx-whisper")
 def whisper_cmd(  # noqa: PLR0912, PLR0915
     model: Annotated[
         list[str] | None,
@@ -293,7 +293,7 @@ def whisper_cmd(  # noqa: PLR0912, PLR0915
 
     """
     # Setup Rich logging for consistent output
-    setup_rich_logging(log_level, console=console)
+    setup_rich_logging(log_level)
 
     valid_backends = ("auto", "faster-whisper", "mlx")
     if backend not in valid_backends:
@@ -421,8 +421,9 @@ def whisper_cmd(  # noqa: PLR0912, PLR0915
     )
 
 
-@app.command("transcription-proxy")
-def transcription_proxy_cmd(
+@app.command("transcribe-proxy")
+@requires_extras("server", "audio", "llm")
+def transcribe_proxy_cmd(
     host: Annotated[
         str,
         typer.Option("--host", help="Host to bind the server to"),
@@ -449,10 +450,10 @@ def transcription_proxy_cmd(
 
     Examples:
         # Run on default port
-        agent-cli server transcription-proxy
+        agent-cli server transcribe-proxy
 
         # Run on custom port
-        agent-cli server transcription-proxy --port 8080
+        agent-cli server transcribe-proxy --port 8080
 
     """
     _check_server_deps()
@@ -475,6 +476,7 @@ def transcription_proxy_cmd(
 
 
 @app.command("tts")
+@requires_extras("server", "piper|kokoro")
 def tts_cmd(  # noqa: PLR0915
     model: Annotated[
         list[str] | None,
@@ -610,7 +612,7 @@ def tts_cmd(  # noqa: PLR0915
 
     """
     # Setup Rich logging for consistent output
-    setup_rich_logging(log_level, console=console)
+    setup_rich_logging(log_level)
 
     valid_backends = ("auto", "piper", "kokoro")
     if backend not in valid_backends:

agent_cli/server/common.py

@@ -9,10 +9,10 @@ import logging
 from contextlib import asynccontextmanager
 from typing import TYPE_CHECKING, Any, Protocol
 
-from rich.console import Console
 from rich.logging import RichHandler
 
 from agent_cli import constants
+from agent_cli.core.utils import console
 
 if TYPE_CHECKING:
     import wave
@@ -128,7 +128,7 @@ def configure_app(app: FastAPI) -> None:
         return await log_requests_middleware(request, call_next)
 
 
-def setup_rich_logging(log_level: str = "info", *, console: Console | None = None) -> None:
+def setup_rich_logging(log_level: str = "info") -> None:
     """Configure logging to use Rich for consistent, pretty output.
 
     This configures:
@@ -141,11 +141,10 @@ def setup_rich_logging(log_level: str = "info", *, console: Console | None = Non
 
     """
     level = getattr(logging, log_level.upper(), logging.INFO)
-    rich_console = console or Console()
 
     # Create Rich handler with clean format
     handler = RichHandler(
-        console=rich_console,
+        console=console,
         show_time=True,
         show_level=True,
         show_path=False,  # Don't show file:line - too verbose

agent_cli/server/tts/api.py

@@ -109,7 +109,7 @@ class SpeechRequest(BaseModel):
     input: str
     model: str = "tts-1"
     voice: str = "alloy"
-    response_format: Literal["wav", "pcm", "mp3"] = "pcm"
+    response_format: Literal["mp3", "wav", "pcm"] = "mp3"
     speed: float = 1.0
     stream_format: Literal["audio"] | None = None
 

agent_cli/server/whisper/backends/faster_whisper.py

@@ -6,6 +6,7 @@ import asyncio
 import logging
 import tempfile
 from concurrent.futures import ProcessPoolExecutor
+from dataclasses import dataclass
 from multiprocessing import get_context
 from pathlib import Path
 from typing import Any, Literal
@@ -19,6 +20,24 @@ from agent_cli.server.whisper.backends.base import (
 logger = logging.getLogger(__name__)
 
 
+# --- Subprocess state (only used within subprocess worker) ---
+# This state persists across function calls within the subprocess because:
+# 1. Model loading is expensive and must be reused across transcription calls
+# 2. CTranslate2 models cannot be pickled/passed through IPC queues
+# 3. The subprocess is long-lived (ProcessPoolExecutor reuses workers)
+
+
+@dataclass
+class _SubprocessState:
+    """Container for subprocess-local state. Not shared with main process."""
+
+    model: Any = None
+    device: str | None = None
+
+
+_state = _SubprocessState()
+
+
 # --- Subprocess worker functions (run in isolated process) ---
 
 
@@ -40,28 +59,22 @@ def _load_model_in_subprocess(
         cpu_threads=cpu_threads,
         download_root=download_root,
     )
-    return str(model.model.device)
+
+    # Store in subprocess state for reuse across transcription calls
+    _state.model = model
+    _state.device = str(model.model.device)
+
+    return _state.device
 
 
 def _transcribe_in_subprocess(
-    model_name: str,
-    device: str,
-    compute_type: str,
-    cpu_threads: int,
-    download_root: str | None,
     audio_bytes: bytes,
     kwargs: dict[str, Any],
 ) -> dict[str, Any]:
-    """Run transcription in subprocess. Model is loaded fresh each call."""
-    from faster_whisper import WhisperModel  # noqa: PLC0415
-
-    model = WhisperModel(
-        model_name,
-        device=device,
-        compute_type=compute_type,
-        cpu_threads=cpu_threads,
-        download_root=download_root,
-    )
+    """Run transcription in subprocess. Reuses model from _state."""
+    if _state.model is None:
+        msg = "Model not loaded in subprocess. Call _load_model_in_subprocess first."
+        raise RuntimeError(msg)
 
     # Write audio to temp file - faster-whisper needs a file path
     with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp:
@@ -69,7 +82,7 @@ def _transcribe_in_subprocess(
         tmp_path = tmp.name
 
     try:
-        segments, info = model.transcribe(tmp_path, **kwargs)
+        segments, info = _state.model.transcribe(tmp_path, **kwargs)
         segment_list = list(segments)  # Consume lazy generator
     finally:
         Path(tmp_path).unlink(missing_ok=True)
@@ -195,16 +208,10 @@ class FasterWhisperBackend:
             "word_timestamps": word_timestamps,
         }
 
-        download_root = str(self._config.cache_dir) if self._config.cache_dir else None
         loop = asyncio.get_running_loop()
         result = await loop.run_in_executor(
             self._executor,
             _transcribe_in_subprocess,
-            self._config.model_name,
-            self._config.device,
-            self._config.compute_type,
-            self._config.cpu_threads,
-            download_root,
             audio,
             kwargs,
         )

agent_cli/server/whisper/wyoming_handler.py

@@ -2,19 +2,18 @@
 
 from __future__ import annotations
 
-import io
 import logging
-import wave
 from functools import partial
 from typing import TYPE_CHECKING
 
 from wyoming.asr import Transcribe, Transcript
-from wyoming.audio import AudioChunk, AudioStop
+from wyoming.audio import AudioChunk, AudioChunkConverter, AudioStop
 from wyoming.info import AsrModel, AsrProgram, Attribution, Describe, Info
 from wyoming.server import AsyncEventHandler, AsyncServer
 
-from agent_cli.server.common import setup_wav_file
+from agent_cli import constants
 from agent_cli.server.whisper.languages import WHISPER_LANGUAGE_CODES
+from agent_cli.services import pcm_to_wav
 
 if TYPE_CHECKING:
     from wyoming.event import Event
@@ -49,8 +48,12 @@ class WyomingWhisperHandler(AsyncEventHandler):
         """
         super().__init__(*args, **kwargs)
         self._registry = registry
-        self._audio_buffer: io.BytesIO | None = None
-        self._wav_file: wave.Wave_write | None = None
+        self._audio_bytes: bytes = b""
+        self._audio_converter = AudioChunkConverter(
+            rate=constants.AUDIO_RATE,
+            width=constants.AUDIO_FORMAT_WIDTH,
+            channels=constants.AUDIO_CHANNELS,
+        )
         self._language: str | None = None
         self._initial_prompt: str | None = None
 
@@ -80,39 +83,31 @@ class WyomingWhisperHandler(AsyncEventHandler):
 
     async def _handle_audio_chunk(self, event: Event) -> bool:
         """Handle an audio chunk event."""
-        chunk = AudioChunk.from_event(event)
-
-        if self._wav_file is None:
+        if not self._audio_bytes:
             logger.debug("AudioChunk begin")
-            self._audio_buffer = io.BytesIO()
-            self._wav_file = wave.open(self._audio_buffer, "wb")  # noqa: SIM115
-            setup_wav_file(
-                self._wav_file,
-                rate=chunk.rate,
-                channels=chunk.channels,
-                sample_width=chunk.width,
-            )
 
-        self._wav_file.writeframes(chunk.audio)
+        chunk = AudioChunk.from_event(event)
+        chunk = self._audio_converter.convert(chunk)
+        self._audio_bytes += chunk.audio
         return True
 
     async def _handle_audio_stop(self) -> bool:
         """Handle audio stop event - transcribe the collected audio."""
         logger.debug("AudioStop")
 
-        if self._wav_file is None or self._audio_buffer is None:
+        if not self._audio_bytes:
             logger.warning("AudioStop received but no audio data")
             await self.write_event(Transcript(text="").event())
             return False
 
-        # Close WAV file
-        self._wav_file.close()
-        self._wav_file = None
-
-        # Get audio data
-        self._audio_buffer.seek(0)
-        audio_data = self._audio_buffer.read()
-        self._audio_buffer = None
+        # Wrap PCM in WAV format for the backend
+        audio_data = pcm_to_wav(
+            self._audio_bytes,
+            sample_rate=constants.AUDIO_RATE,
+            sample_width=constants.AUDIO_FORMAT_WIDTH,
+            channels=constants.AUDIO_CHANNELS,
+        )
+        self._audio_bytes = b""
 
         # Transcribe
         try:

agent_cli/services/_wyoming_utils.py

@@ -5,14 +5,14 @@ from __future__ import annotations
 from contextlib import asynccontextmanager
 from typing import TYPE_CHECKING
 
-from wyoming.client import AsyncClient
-
 from agent_cli.core.utils import print_error_message
 
 if TYPE_CHECKING:
     import logging
     from collections.abc import AsyncGenerator
 
+    from wyoming.client import AsyncClient
+
 
 @asynccontextmanager
 async def wyoming_client_context(
@@ -40,6 +40,8 @@ async def wyoming_client_context(
         Exception: For other connection errors
 
     """
+    from wyoming.client import AsyncClient  # noqa: PLC0415
+
     uri = f"tcp://{server_ip}:{server_port}"
     logger.info("Connecting to Wyoming %s server at %s", server_type, uri)
 

agent_cli/services/asr.py

@@ -10,9 +10,6 @@ from functools import partial
 from pathlib import Path
 from typing import TYPE_CHECKING
 
-from wyoming.asr import Transcribe, Transcript, TranscriptChunk, TranscriptStart, TranscriptStop
-from wyoming.audio import AudioChunk, AudioStart, AudioStop
-
 from agent_cli import constants
 from agent_cli.core.audio import (
     open_audio_stream,
@@ -225,6 +222,9 @@ async def _send_audio(
     initial_prompt: str | None = None,
 ) -> None:
     """Read from mic and send to Wyoming server."""
+    from wyoming.asr import Transcribe  # noqa: PLC0415
+    from wyoming.audio import AudioChunk, AudioStart, AudioStop  # noqa: PLC0415
+
     # Build context with initial_prompt if provided
     context = {"initial_prompt": initial_prompt} if initial_prompt else None
     await client.write_event(Transcribe(context=context).event())
@@ -282,6 +282,13 @@ async def _receive_transcript(
     final_callback: Callable[[str], None] | None = None,
 ) -> str:
     """Receive transcription events and return the final transcript."""
+    from wyoming.asr import (  # noqa: PLC0415
+        Transcript,
+        TranscriptChunk,
+        TranscriptStart,
+        TranscriptStop,
+    )
+
     transcript_text = ""
     while True:
         event = await client.read_event()
@@ -370,6 +377,9 @@ async def _transcribe_recorded_audio_wyoming(
     **_kwargs: object,
 ) -> str:
     """Process pre-recorded audio data with Wyoming ASR server."""
+    from wyoming.asr import Transcribe  # noqa: PLC0415
+    from wyoming.audio import AudioChunk, AudioStart, AudioStop  # noqa: PLC0415
+
     try:
         async with wyoming_client_context(
             wyoming_asr_cfg.asr_wyoming_ip,

agent_cli/services/llm.py

@@ -6,7 +6,6 @@ import sys
 import time
 from typing import TYPE_CHECKING
 
-import pyperclip
 from rich.live import Live
 
 from agent_cli.core.utils import console, live_timer, print_error_message, print_output_panel
@@ -156,6 +155,8 @@ async def get_llm_response(
         result_text = result.output
 
         if clipboard:
+            import pyperclip  # noqa: PLC0415
+
             pyperclip.copy(result_text)
             logger.info("Copied result to clipboard.")