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

agent_cli/dev/worktree.py

@@ -55,6 +55,15 @@ def is_git_repo(path: Path | None = None) -> bool:
         return False
 
 
+def has_origin_remote(path: Path | None = None) -> bool:
+    """Check if the repository has an 'origin' remote configured."""
+    try:
+        result = _run_git("remote", "get-url", "origin", cwd=path, check=False)
+        return result.returncode == 0
+    except Exception:
+        return False
+
+
 def get_repo_root(path: Path | None = None) -> Path | None:
     """Get the root directory of the git repository."""
     try:
@@ -461,6 +470,35 @@ def _init_submodules(
     )
 
 
+def _pull_lfs(
+    worktree_path: Path,
+    *,
+    on_log: Callable[[str], None] | None = None,
+    capture_output: bool = True,
+) -> None:
+    """Pull Git LFS files in a worktree if LFS is used.
+
+    Evidence: https://git-lfs.com/ - `git lfs pull` fetches LFS objects.
+    This is a no-op if LFS is not used or files are already present.
+    """
+    # Check if .gitattributes contains LFS filters
+    gitattributes = worktree_path / ".gitattributes"
+    if not gitattributes.exists():
+        return
+
+    if "filter=lfs" not in gitattributes.read_text():
+        return
+
+    # Check if git-lfs is installed
+    if not shutil.which("git-lfs"):
+        return
+
+    if on_log:
+        on_log("Pulling Git LFS files...")
+
+    _run_git("lfs", "pull", cwd=worktree_path, check=False, capture_output=capture_output)
+
+
 def _add_worktree(
     branch_name: str,
     worktree_path: Path,
@@ -586,8 +624,11 @@ def create_worktree(
     # Create base directory if needed
     base_dir.mkdir(parents=True, exist_ok=True)
 
-    # Fetch latest refs
-    if fetch:
+    # Check if origin remote exists
+    origin_exists = has_origin_remote(repo_root)
+
+    # Fetch latest refs (only if origin exists)
+    if fetch and origin_exists:
         if on_log:
             on_log("Running: git fetch origin")
         _run_git("fetch", "origin", cwd=repo_root, check=False, capture_output=capture_output)
@@ -596,10 +637,10 @@ def create_worktree(
     from_ref_explicit = from_ref is not None
 
     # Determine the reference to create from
-    # Use origin/{branch} to ensure we're using the freshly-fetched remote ref,
-    # not a potentially stale local branch
+    # Use origin/{branch} if origin exists, otherwise use local branch
     if from_ref is None:
-        from_ref = f"origin/{get_default_branch(repo_root)}"
+        default_branch = get_default_branch(repo_root)
+        from_ref = f"origin/{default_branch}" if origin_exists else default_branch
 
     # Check if branch exists remotely or locally
     remote_exists, local_exists = _check_branch_exists(branch_name, repo_root)
@@ -634,6 +675,13 @@ def create_worktree(
             capture_output=capture_output,
         )
 
+        # Pull Git LFS files if the repo uses LFS
+        _pull_lfs(
+            worktree_path,
+            on_log=on_log,
+            capture_output=capture_output,
+        )
+
         return CreateWorktreeResult(
             success=True,
             path=worktree_path,

agent_cli/docs_gen.py

@@ -16,7 +16,6 @@ Example usage in Markdown files:
 
 from __future__ import annotations
 
-from pathlib import Path
 from typing import Any, get_origin
 
 import click
@@ -24,6 +23,7 @@ from typer.main import get_command
 
 from agent_cli import opts
 from agent_cli.cli import app
+from agent_cli.install.extras import EXTRAS
 
 
 def _get_type_str(annotation: Any) -> str:
@@ -368,47 +368,6 @@ def config_example(command_path: str | None = None) -> str:
     return "\n".join(lines)
 
 
-def readme_section(section_name: str) -> str:
-    """Extract a section from README.md for reuse in other docs.
-
-    Sections are marked with HTML comments like:
-        <!-- SECTION:section_name:START -->
-        Content here...
-        <!-- SECTION:section_name:END -->
-
-    Args:
-        section_name: The name of the section to extract (e.g., "why-i-built-this")
-
-    Returns:
-        The content between the section markers (without the markers themselves)
-
-    """
-    # Find the README.md relative to this module
-    readme_path = Path(__file__).parent.parent / "README.md"
-    if not readme_path.exists():
-        return f"*Could not find README.md at {readme_path}*"
-
-    content = readme_path.read_text()
-
-    # Look for section markers
-    start_marker = f"<!-- SECTION:{section_name}:START -->"
-    end_marker = f"<!-- SECTION:{section_name}:END -->"
-
-    start_idx = content.find(start_marker)
-    if start_idx == -1:
-        return f"*Section '{section_name}' not found in README.md*"
-
-    end_idx = content.find(end_marker, start_idx)
-    if end_idx == -1:
-        return f"*End marker for section '{section_name}' not found in README.md*"
-
-    # Extract content between markers (excluding the markers themselves)
-    section_content = content[start_idx + len(start_marker) : end_idx]
-
-    # Strip leading/trailing whitespace but preserve internal formatting
-    return section_content.strip()
-
-
 def all_options_for_docs(command_path: str) -> str:
     """Generate complete options documentation for a command page.
 
@@ -430,6 +389,17 @@ def all_options_for_docs(command_path: str) -> str:
     )
 
 
+def extras_table() -> str:
+    """Generate a table of available extras for install-extras command."""
+    lines = [
+        "| Extra | Description |",
+        "|-------|-------------|",
+    ]
+    for name, description in EXTRAS.items():
+        lines.append(f"| `{name}` | {description} |")
+    return "\n".join(lines)
+
+
 if __name__ == "__main__":
     # Demo: print options for transcribe command
     print("=== Available Commands ===")

agent_cli/install/__init__.py

@@ -2,4 +2,4 @@
 
 from __future__ import annotations
 
-__all__ = ["hotkeys", "services"]
+__all__ = ["extras", "hotkeys", "services"]

agent_cli/install/extras.py

@@ -0,0 +1,174 @@
+"""Install optional extras at runtime with pinned versions."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+import tomllib
+from importlib.metadata import version as get_version
+from pathlib import Path
+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.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()}
+
+
+def _requirements_dir() -> Path:
+    return Path(__file__).parent.parent / "_requirements"
+
+
+def _available_extras() -> list[str]:
+    """List available extras based on requirements files."""
+    req_dir = _requirements_dir()
+    if not req_dir.exists():
+        return []
+    return sorted(p.stem for p in req_dir.glob("*.txt"))
+
+
+def _requirements_path(extra: str) -> Path:
+    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."""
+    current_version = get_version("agent-cli").split("+")[0]  # Strip local version
+    extras_str = ",".join(extras)
+    package_spec = f"agent-cli[{extras_str}]=={current_version}"
+    python_version = f"{sys.version_info.major}.{sys.version_info.minor}"
+    cmd = ["uv", "tool", "install", package_spec, "--force", "--python", python_version]
+    if quiet:
+        cmd.append("-q")
+    console.print(f"Running: [cyan]{' '.join(cmd)}[/]")
+    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:
+            # Allow installing to system Python when not in a venv
+            cmd.append("--system")
+        return cmd
+    cmd = [sys.executable, "-m", "pip", "install"]
+    if not in_venv:
+        # Install to user site-packages when not in a 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:
+        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", no_args_is_help=True)
+def install_extras(
+    extras: Annotated[list[str] | None, typer.Argument(help="Extras to install")] = None,
+    list_extras: Annotated[
+        bool,
+        typer.Option("--list", "-l", help="List available extras"),
+    ] = False,
+    all_extras: Annotated[
+        bool,
+        typer.Option("--all", "-a", help="Install all available extras"),
+    ] = False,
+) -> None:
+    """Install optional extras (rag, memory, vad, etc.) with pinned versions.
+
+    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/memory/__init__.py

@@ -2,23 +2,6 @@
 
 from __future__ import annotations
 
-from agent_cli.core.deps import ensure_optional_dependencies
-
-_REQUIRED_DEPS = {
-    "chromadb": "chromadb",
-    "fastapi": "fastapi",
-    "uvicorn": "uvicorn",
-    "onnxruntime": "onnxruntime",
-    "huggingface_hub": "huggingface-hub",
-    "transformers": "transformers",
-}
-
-ensure_optional_dependencies(
-    _REQUIRED_DEPS,
-    extra_name="memory",
-    install_hint="`pip install agent-cli[memory]` or `uv sync --extra memory`",
-)
-
-from agent_cli.memory.client import MemoryClient  # noqa: E402
+from agent_cli.memory.client import MemoryClient
 
 __all__ = ["MemoryClient"]

agent_cli/memory/_files.py

@@ -9,7 +9,6 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 from uuid import uuid4
 
-import yaml
 from pydantic import ValidationError
 
 from agent_cli.core.utils import atomic_write_text
@@ -218,6 +217,8 @@ def load_snapshot(snapshot_path: Path) -> dict[str, MemoryFileRecord]:
 
 def _render_front_matter(doc_id: str, metadata: MemoryMetadata) -> str:
     """Return YAML front matter string."""
+    import yaml  # noqa: PLC0415
+
     meta_dict = metadata.model_dump(exclude_none=True)
     meta_dict = {"id": doc_id, **meta_dict}
     yaml_block = yaml.safe_dump(meta_dict, sort_keys=False)
@@ -233,6 +234,8 @@ def _split_front_matter(text: str) -> tuple[dict | None, str]:
         return None, text
     yaml_part = text[3:end]
     try:
+        import yaml  # noqa: PLC0415
+
         meta = yaml.safe_load(yaml_part) or {}
     except Exception:
         return None, text

agent_cli/memory/_indexer.py

@@ -6,8 +6,6 @@ import logging
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING
 
-from watchfiles import Change
-
 from agent_cli.core.watch import watch_directory
 from agent_cli.memory._files import (
     _DELETED_DIRNAME,
@@ -24,6 +22,7 @@ if TYPE_CHECKING:
     from pathlib import Path
 
     from chromadb import Collection
+    from watchfiles import Change
 
 LOGGER = logging.getLogger(__name__)
 
@@ -108,6 +107,8 @@ async def watch_memory_store(collection: Collection, root: Path, *, index: Memor
 
 
 def _handle_change(change: Change, path: Path, collection: Collection, index: MemoryIndex) -> None:
+    from watchfiles import Change  # noqa: PLC0415
+
     if path.suffix == ".tmp":
         return
 

agent_cli/memory/_ingest.py

@@ -9,8 +9,6 @@ from time import perf_counter
 from typing import TYPE_CHECKING
 from uuid import uuid4
 
-import httpx
-
 from agent_cli.memory._git import commit_changes
 from agent_cli.memory._persistence import delete_memory_files, persist_entries, persist_summary
 from agent_cli.memory._prompt import (
@@ -58,6 +56,7 @@ async def extract_salient_facts(
     if not user_message and not assistant_message:
         return []
 
+    import httpx  # noqa: PLC0415
     from pydantic_ai import Agent  # noqa: PLC0415
     from pydantic_ai.exceptions import AgentRunError, UnexpectedModelBehavior  # noqa: PLC0415
     from pydantic_ai.models.openai import OpenAIChatModel  # noqa: PLC0415
@@ -174,16 +173,18 @@ async def reconcile_facts(
             if f.strip()
         ]
         return entries, [], {}
-    id_map: dict[int, str] = {idx: mem.id for idx, mem in enumerate(existing)}
-    existing_json = [{"id": idx, "text": mem.content} for idx, mem in enumerate(existing)]
-    existing_ids = set(id_map.keys())
 
+    import httpx  # noqa: PLC0415
     from pydantic_ai import Agent, ModelRetry, PromptedOutput  # noqa: PLC0415
     from pydantic_ai.exceptions import AgentRunError, UnexpectedModelBehavior  # noqa: PLC0415
     from pydantic_ai.models.openai import OpenAIChatModel  # noqa: PLC0415
     from pydantic_ai.providers.openai import OpenAIProvider  # noqa: PLC0415
     from pydantic_ai.settings import ModelSettings  # noqa: PLC0415
 
+    id_map: dict[int, str] = {idx: mem.id for idx, mem in enumerate(existing)}
+    existing_json = [{"id": idx, "text": mem.content} for idx, mem in enumerate(existing)]
+    existing_ids = set(id_map.keys())
+
     provider = OpenAIProvider(api_key=api_key or "dummy", base_url=openai_base_url)
     model_cfg = OpenAIChatModel(
         model_name=model,

agent_cli/memory/_retrieval.py

@@ -25,6 +25,7 @@ LOGGER = logging.getLogger(__name__)
 
 _DEFAULT_MMR_LAMBDA = 0.7
 _SUMMARY_ROLE = "summary"
+_MIN_MAX_EPSILON = 1e-8  # Avoid division by zero in min-max normalization
 
 
 def gather_relevant_existing_memories(
@@ -135,7 +136,7 @@ def retrieve_memory(
     include_summary: bool = True,
     mmr_lambda: float = _DEFAULT_MMR_LAMBDA,
     recency_weight: float = 0.2,
-    score_threshold: float = 0.35,
+    score_threshold: float | None = None,
     filters: dict[str, Any] | None = None,
 ) -> tuple[MemoryRetrieval, list[str]]:
     """Execute search + rerank + recency + MMR."""
@@ -161,8 +162,15 @@ def retrieve_memory(
             seen_ids.add(rec_id)
             raw_candidates.append(rec)
 
-    def _sigmoid(x: float) -> float:
-        return 1.0 / (1.0 + math.exp(-x))
+    def _min_max_normalize(scores: list[float]) -> list[float]:
+        """Normalize scores to 0-1 range using min-max scaling."""
+        if not scores:
+            return scores
+        min_score = min(scores)
+        max_score = max(scores)
+        if max_score - min_score < _MIN_MAX_EPSILON:
+            return [0.5] * len(scores)  # All scores equal
+        return [(s - min_score) / (max_score - min_score) for s in scores]
 
     def recency_score(meta: MemoryMetadata) -> float:
         dt = datetime.fromisoformat(meta.created_at)
@@ -176,10 +184,12 @@ def retrieve_memory(
     if raw_candidates:
         pairs = [(query, mem.content) for mem in raw_candidates]
         rr_scores = predict_relevance(reranker_model, pairs)
-        for mem, rr in zip(raw_candidates, rr_scores, strict=False):
-            relevance = _sigmoid(rr)
-            # Filter out low-relevance memories to reduce noise
-            if relevance < score_threshold:
+        # Normalize raw reranker scores to 0-1 range
+        normalized_scores = _min_max_normalize(rr_scores)
+
+        for mem, relevance in zip(raw_candidates, normalized_scores, strict=False):
+            # Filter out low-relevance memories if threshold is set
+            if score_threshold is not None and relevance < score_threshold:
                 continue
 
             recency = recency_score(mem.metadata)
@@ -235,7 +245,7 @@ async def augment_chat_request(
     include_global: bool = True,
     mmr_lambda: float = _DEFAULT_MMR_LAMBDA,
     recency_weight: float = 0.2,
-    score_threshold: float = 0.35,
+    score_threshold: float | None = None,
     filters: dict[str, Any] | None = None,
 ) -> tuple[ChatRequest, MemoryRetrieval | None, str, list[str]]:
     """Retrieve memory context and augment the chat request."""

agent_cli/memory/_streaming.py

@@ -4,8 +4,6 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
-import httpx
-
 from agent_cli.core.sse import extract_content_from_chunk, parse_chunk
 
 if TYPE_CHECKING:
@@ -20,6 +18,8 @@ async def stream_chat_sse(
     request_timeout: float = 120.0,
 ) -> AsyncGenerator[str, None]:
     """Stream Server-Sent Events from an OpenAI-compatible chat completion endpoint."""
+    import httpx  # noqa: PLC0415
+
     url = f"{openai_base_url.rstrip('/')}/chat/completions"
     async with (
         httpx.AsyncClient(timeout=request_timeout) as client,

agent_cli/memory/api.py

@@ -30,7 +30,7 @@ def create_app(
     max_entries: int = 500,
     mmr_lambda: float = 0.7,
     recency_weight: float = 0.2,
-    score_threshold: float = 0.35,
+    score_threshold: float | None = None,
     enable_git_versioning: bool = True,
 ) -> FastAPI:
     """Create the FastAPI app for memory-backed chat."""

agent_cli/memory/client.py

@@ -49,7 +49,7 @@ class MemoryClient:
         max_entries: int = 500,
         mmr_lambda: float = 0.7,
         recency_weight: float = 0.2,
-        score_threshold: float = 0.35,
+        score_threshold: float | None = None,
         start_watcher: bool = False,
         enable_git_versioning: bool = True,
     ) -> None:

agent_cli/memory/engine.py

@@ -236,7 +236,7 @@ async def process_chat_request(
     max_entries: int = _DEFAULT_MAX_ENTRIES,
     mmr_lambda: float = _DEFAULT_MMR_LAMBDA,
     recency_weight: float = 0.2,
-    score_threshold: float = 0.35,
+    score_threshold: float | None = None,
     postprocess_in_background: bool = True,
     enable_git_versioning: bool = False,
     filters: dict[str, Any] | None = None,

agent_cli/rag/__init__.py

@@ -1,22 +1,3 @@
 """RAG module."""
 
 from __future__ import annotations
-
-from agent_cli.core.deps import ensure_optional_dependencies
-
-_REQUIRED_DEPS = {
-    "chromadb": "chromadb",
-    "watchfiles": "watchfiles",
-    "markitdown": "markitdown",
-    "fastapi": "fastapi",
-    "uvicorn": "uvicorn",
-    "onnxruntime": "onnxruntime",
-    "huggingface_hub": "huggingface-hub",
-    "transformers": "transformers",
-}
-
-ensure_optional_dependencies(
-    _REQUIRED_DEPS,
-    extra_name="rag",
-    install_hint="`pip install agent-cli[rag]` or `uv sync --extra rag`",
-)

agent_cli/rag/_indexer.py

@@ -5,8 +5,6 @@ from __future__ import annotations
 import logging
 from typing import TYPE_CHECKING
 
-from watchfiles import Change
-
 from agent_cli.core.watch import watch_directory
 from agent_cli.rag._indexing import index_file, remove_file
 from agent_cli.rag._utils import should_ignore_path
@@ -15,6 +13,7 @@ if TYPE_CHECKING:
     from pathlib import Path
 
     from chromadb import Collection
+    from watchfiles import Change
 
 LOGGER = logging.getLogger(__name__)
 
@@ -50,6 +49,8 @@ def _handle_change(
     file_hashes: dict[str, str],
     file_mtimes: dict[str, float],
 ) -> None:
+    from watchfiles import Change  # noqa: PLC0415
+
     try:
         if change == Change.deleted:
             LOGGER.info("[deleted] Removing from index: %s", file_path.name)

agent_cli/rag/api.py

@@ -24,6 +24,7 @@ from agent_cli.rag.models import ChatRequest  # noqa: TC001
 if TYPE_CHECKING:
     from pathlib import Path
 
+
 LOGGER = logging.getLogger(__name__)