vexor 0.2.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

vexor/cli.py

@@ -2,27 +2,40 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
+import shlex
+import subprocess
 from pathlib import Path
-from typing import Sequence
-import shutil
-import re
+from typing import Sequence, TYPE_CHECKING
 
 import typer
 from rich.console import Console
 from rich.table import Table
 
-from . import __version__
+from . import __version__, config as config_module
+from .cache import clear_all_cache, list_cache_entries
 from .config import (
     DEFAULT_BATCH_SIZE,
     DEFAULT_MODEL,
+    DEFAULT_PROVIDER,
+    SUPPORTED_PROVIDERS,
     load_config,
-    set_api_key,
-    set_batch_size,
-    set_model,
+)
+from .modes import available_modes, get_strategy
+from .services.cache_service import load_index_metadata_safe
+from .services.config_service import apply_config_updates, get_config_snapshot
+from .services.index_service import IndexStatus, build_index, clear_index_entries
+from .services.search_service import SearchRequest, perform_search
+from .services.system_service import (
+    fetch_remote_version,
+    find_command_on_path,
+    resolve_editor_command,
+    version_tuple,
 )
 from .text import Messages, Styles
-from .utils import collect_files, resolve_directory, format_path, ensure_positive
+from .utils import resolve_directory, format_path, ensure_positive
+
+if TYPE_CHECKING:  # pragma: no cover - typing only
+    from .search import SearchResult
 
 REMOTE_VERSION_URL = "https://raw.githubusercontent.com/scarletkc/vexor/refs/heads/main/vexor/__init__.py"
 PROJECT_URL = "https://github.com/scarletkc/vexor"
@@ -36,11 +49,6 @@ app = typer.Typer(
 )
 
 
-@dataclass(slots=True)
-class DisplayResult:
-    path: Path
-    score: float
-
 
 def _version_callback(value: bool) -> None:
     if value:
@@ -48,6 +56,17 @@ def _version_callback(value: bool) -> None:
         raise typer.Exit()
 
 
+def _validate_mode(mode: str) -> str:
+    try:
+        get_strategy(mode)
+    except ValueError as exc:
+        allowed = ", ".join(available_modes())
+        raise typer.BadParameter(
+            Messages.ERROR_MODE_INVALID.format(value=mode, allowed=allowed)
+        ) from exc
+    return mode
+
+
 @app.callback()
 def main(
     version: bool = typer.Option(
@@ -78,11 +97,26 @@ def search(
         "--include-hidden",
         help=Messages.HELP_INCLUDE_HIDDEN,
     ),
+    mode: str = typer.Option(
+        ...,
+        "--mode",
+        "-m",
+        help=Messages.HELP_MODE,
+    ),
+    no_recursive: bool = typer.Option(
+        False,
+        "--no-recursive",
+        "-n",
+        help=Messages.HELP_RECURSIVE,
+    ),
 ) -> None:
     """Run the semantic search using a cached index."""
     config = load_config()
     model_name = config.model or DEFAULT_MODEL
     batch_size = config.batch_size if config.batch_size is not None else DEFAULT_BATCH_SIZE
+    provider = config.provider or DEFAULT_PROVIDER
+    base_url = config.base_url
+    api_key = config.api_key
 
     clean_query = query.strip()
     if not clean_query:
@@ -94,45 +128,45 @@ def search(
         raise typer.BadParameter(str(exc), param_name="top") from exc
 
     directory = resolve_directory(path)
+    mode_value = _validate_mode(mode)
+    recursive = not no_recursive
     console.print(_styled(Messages.INFO_SEARCH_RUNNING.format(path=directory), Styles.INFO))
+    request = SearchRequest(
+        query=clean_query,
+        directory=directory,
+        include_hidden=include_hidden,
+        mode=mode_value,
+        recursive=recursive,
+        top_k=top,
+        model_name=model_name,
+        batch_size=batch_size,
+        provider=provider,
+        base_url=base_url,
+        api_key=api_key,
+    )
     try:
-        cached_paths, file_vectors, meta = _load_index(directory, model_name, include_hidden)
+        response = perform_search(request)
     except FileNotFoundError:
         console.print(
             _styled(Messages.ERROR_INDEX_MISSING.format(path=directory), Styles.ERROR)
         )
         raise typer.Exit(code=1)
-
-    _warn_if_stale(directory, include_hidden, meta.get("files", []))
-
-    if not cached_paths:
-        console.print(_styled(Messages.INFO_INDEX_EMPTY, Styles.WARNING))
-        raise typer.Exit(code=0)
-
-    searcher = _create_searcher(model_name=model_name, batch_size=batch_size)
-    try:
-        query_vector = searcher.embed_texts([clean_query])[0]
     except RuntimeError as exc:
         console.print(_styled(str(exc), Styles.ERROR))
         raise typer.Exit(code=1)
 
-    from sklearn.metrics.pairwise import cosine_similarity  # local import
-
-    similarities = cosine_similarity(
-        query_vector.reshape(1, -1), file_vectors
-    )[0]
-    scored = [
-        DisplayResult(path=path, score=float(score))
-        for path, score in zip(cached_paths, similarities)
-    ]
-    scored.sort(key=lambda item: item.score, reverse=True)
-    results = scored[:top]
-
-    if not results:
+    if response.index_empty:
+        console.print(_styled(Messages.INFO_INDEX_EMPTY, Styles.WARNING))
+        raise typer.Exit(code=0)
+    if response.is_stale:
+        console.print(
+            _styled(Messages.WARNING_INDEX_STALE.format(path=directory), Styles.WARNING)
+        )
+    if not response.results:
         console.print(_styled(Messages.INFO_NO_RESULTS, Styles.WARNING))
         raise typer.Exit(code=0)
 
-    _render_results(results, directory, searcher.device)
+    _render_results(response.results, response.base_path, response.backend)
 
 
 @app.command()
@@ -148,20 +182,84 @@ def index(
         "--include-hidden",
         help=Messages.HELP_INDEX_INCLUDE,
     ),
+    mode: str = typer.Option(
+        ...,
+        "--mode",
+        "-m",
+        help=Messages.HELP_MODE,
+    ),
+    no_recursive: bool = typer.Option(
+        False,
+        "--no-recursive",
+        "-n",
+        help=Messages.HELP_RECURSIVE,
+    ),
     clear: bool = typer.Option(
         False,
         "--clear",
         help=Messages.HELP_INDEX_CLEAR,
     ),
+    show_cache: bool = typer.Option(
+        False,
+        "--show",
+        help=Messages.HELP_INDEX_SHOW,
+    ),
 ) -> None:
     """Create or refresh the cached index for the given directory."""
     config = load_config()
     model_name = config.model or DEFAULT_MODEL
     batch_size = config.batch_size if config.batch_size is not None else DEFAULT_BATCH_SIZE
+    provider = config.provider or DEFAULT_PROVIDER
+    base_url = config.base_url
+    api_key = config.api_key
 
     directory = resolve_directory(path)
+    mode_value = _validate_mode(mode)
+    recursive = not no_recursive
+    if clear and show_cache:
+        raise typer.BadParameter(Messages.ERROR_INDEX_SHOW_CONFLICT)
+
+    if show_cache:
+        metadata = load_index_metadata_safe(
+            directory,
+            model_name,
+            include_hidden,
+            mode_value,
+            recursive,
+        )
+        if not metadata:
+            console.print(
+                _styled(
+                    Messages.INFO_INDEX_CLEAR_NONE.format(path=directory),
+                    Styles.INFO,
+                )
+            )
+            return
+
+        files = metadata.get("files", [])
+        console.print(
+            _styled(Messages.INFO_INDEX_SHOW_HEADER.format(path=directory), Styles.TITLE)
+        )
+        summary = Messages.INFO_INDEX_SHOW_SUMMARY.format(
+            mode=metadata.get("mode"),
+            model=metadata.get("model"),
+            hidden="yes" if metadata.get("include_hidden") else "no",
+            recursive="yes" if metadata.get("recursive") else "no",
+            files=len(files),
+            dimension=metadata.get("dimension"),
+            version=metadata.get("version"),
+            generated=metadata.get("generated_at"),
+        )
+        console.print(_styled(summary, Styles.INFO))
+        return
+
     if clear:
-        removed = _clear_index_cache(directory, include_hidden)
+        removed = clear_index_entries(
+            directory,
+            include_hidden=include_hidden,
+            mode=mode_value,
+            recursive=recursive,
+        )
         if removed:
             plural = "ies" if removed > 1 else "y"
             console.print(
@@ -184,34 +282,31 @@ def index(
         return
 
     console.print(_styled(Messages.INFO_INDEX_RUNNING.format(path=directory), Styles.INFO))
-    files = collect_files(directory, include_hidden=include_hidden)
-    if not files:
+    try:
+        result = build_index(
+            directory,
+            include_hidden=include_hidden,
+            mode=mode_value,
+            recursive=recursive,
+            model_name=model_name,
+            batch_size=batch_size,
+            provider=provider,
+            base_url=base_url,
+            api_key=api_key,
+        )
+    except RuntimeError as exc:
+        console.print(_styled(str(exc), Styles.ERROR))
+        raise typer.Exit(code=1)
+    if result.status == IndexStatus.EMPTY:
         console.print(_styled(Messages.INFO_NO_FILES, Styles.WARNING))
         raise typer.Exit(code=0)
-
-    existing_meta = _load_index_metadata_safe(directory, model_name, include_hidden)
-    if existing_meta:
-        cached_files = existing_meta.get("files", [])
-        if cached_files and _is_cache_current(
-            directory, include_hidden, cached_files, current_files=files
-        ):
-            console.print(
-                _styled(Messages.INFO_INDEX_UP_TO_DATE.format(path=directory), Styles.INFO)
-            )
-            return
-
-    searcher = _create_searcher(model_name=model_name, batch_size=batch_size)
-    file_labels = [_label_for_path(file) for file in files]
-    embeddings = searcher.embed_texts(file_labels)
-
-    cache_path = _store_index(
-        root=directory,
-        model=model_name,
-        include_hidden=include_hidden,
-        files=files,
-        embeddings=embeddings,
-    )
-    console.print(_styled(Messages.INFO_INDEX_SAVED.format(path=cache_path), Styles.SUCCESS))
+    if result.status == IndexStatus.UP_TO_DATE:
+        console.print(
+            _styled(Messages.INFO_INDEX_UP_TO_DATE.format(path=directory), Styles.INFO)
+        )
+        return
+    if result.cache_path is not None:
+        console.print(_styled(Messages.INFO_INDEX_SAVED.format(path=result.cache_path), Styles.SUCCESS))
 
 
 @app.command()
@@ -236,57 +331,158 @@ def config(
         "--set-batch-size",
         help=Messages.HELP_SET_BATCH,
     ),
+    set_provider_option: str | None = typer.Option(
+        None,
+        "--set-provider",
+        help=Messages.HELP_SET_PROVIDER,
+    ),
+    set_base_url_option: str | None = typer.Option(
+        None,
+        "--set-base-url",
+        help=Messages.HELP_SET_BASE_URL,
+    ),
+    clear_base_url: bool = typer.Option(
+        False,
+        "--clear-base-url",
+        help=Messages.HELP_CLEAR_BASE_URL,
+    ),
     show: bool = typer.Option(
         False,
         "--show",
         help=Messages.HELP_SHOW_CONFIG,
     ),
+    show_index_all: bool = typer.Option(
+        False,
+        "--show-index-all",
+        help=Messages.HELP_SHOW_INDEX_ALL,
+    ),
+    clear_index_all: bool = typer.Option(
+        False,
+        "--clear-index-all",
+        help=Messages.HELP_CLEAR_INDEX_ALL,
+    ),
 ) -> None:
     """Manage Vexor configuration stored in ~/.vexor/config.json."""
-    changed = False
+    if set_batch_option is not None and set_batch_option < 0:
+        raise typer.BadParameter(Messages.ERROR_BATCH_NEGATIVE)
+    if set_base_url_option and clear_base_url:
+        raise typer.BadParameter(Messages.ERROR_BASE_URL_CONFLICT)
+    if set_provider_option is not None:
+        normalized_provider = set_provider_option.strip().lower()
+        if normalized_provider not in SUPPORTED_PROVIDERS:
+            allowed = ", ".join(SUPPORTED_PROVIDERS)
+            raise typer.BadParameter(
+                Messages.ERROR_PROVIDER_INVALID.format(
+                    value=set_provider_option, allowed=allowed
+                )
+            )
+        set_provider_option = normalized_provider
+
+    updates = apply_config_updates(
+        api_key=set_api_key_option,
+        clear_api_key=clear_api_key,
+        model=set_model_option,
+        batch_size=set_batch_option,
+        provider=set_provider_option,
+        base_url=set_base_url_option,
+        clear_base_url=clear_base_url,
+    )
 
-    if set_api_key_option is not None:
-        set_api_key(set_api_key_option)
+    if updates.api_key_set:
         console.print(_styled(Messages.INFO_API_SAVED, Styles.SUCCESS))
-        changed = True
-    if clear_api_key:
-        set_api_key(None)
+    if updates.api_key_cleared:
         console.print(_styled(Messages.INFO_API_CLEARED, Styles.SUCCESS))
-        changed = True
-    if set_model_option is not None:
-        set_model(set_model_option)
+    if updates.model_set and set_model_option is not None:
         console.print(
             _styled(Messages.INFO_MODEL_SET.format(value=set_model_option), Styles.SUCCESS)
         )
-        changed = True
-    if set_batch_option is not None:
-        if set_batch_option < 0:
-            raise typer.BadParameter(Messages.ERROR_BATCH_NEGATIVE)
-        set_batch_size(set_batch_option)
+    if updates.batch_size_set and set_batch_option is not None:
         console.print(
             _styled(Messages.INFO_BATCH_SET.format(value=set_batch_option), Styles.SUCCESS)
         )
-        changed = True
+    if updates.provider_set and set_provider_option is not None:
+        console.print(
+            _styled(Messages.INFO_PROVIDER_SET.format(value=set_provider_option), Styles.SUCCESS)
+        )
+    if updates.base_url_set and set_base_url_option is not None:
+        console.print(
+            _styled(Messages.INFO_BASE_URL_SET.format(value=set_base_url_option), Styles.SUCCESS)
+        )
+    if updates.base_url_cleared and clear_base_url:
+        console.print(_styled(Messages.INFO_BASE_URL_CLEARED, Styles.SUCCESS))
+
+    if clear_index_all:
+        removed = clear_all_cache()
+        if removed:
+            plural = "ies" if removed > 1 else "y"
+            console.print(
+                _styled(
+                    Messages.INFO_INDEX_ALL_CLEARED.format(count=removed, plural=plural),
+                    Styles.SUCCESS,
+                )
+            )
+        else:
+            console.print(_styled(Messages.INFO_INDEX_ALL_CLEAR_NONE, Styles.INFO))
+
+    should_edit = not any(
+        (
+            updates.changed,
+            show,
+            show_index_all,
+            clear_index_all,
+        )
+    )
+    if should_edit:
+        _edit_config_file()
+        return
 
-    if show or not changed:
-        cfg = load_config()
+    if show:
+        cfg = get_config_snapshot()
         console.print(
             _styled(
                 Messages.INFO_CONFIG_SUMMARY.format(
                     api="yes" if cfg.api_key else "no",
+                    provider=cfg.provider or DEFAULT_PROVIDER,
                     model=cfg.model or DEFAULT_MODEL,
                     batch=cfg.batch_size if cfg.batch_size is not None else DEFAULT_BATCH_SIZE,
+                    base_url=cfg.base_url or "none",
                 ),
                 Styles.INFO,
             )
         )
 
+    if show_index_all:
+        entries = list_cache_entries()
+        if not entries:
+            console.print(_styled(Messages.INFO_INDEX_ALL_EMPTY, Styles.INFO))
+        else:
+            console.print(_styled(Messages.INFO_INDEX_ALL_HEADER, Styles.TITLE))
+            table = Table(show_header=True, header_style=Styles.TABLE_HEADER)
+            table.add_column(Messages.TABLE_INDEX_HEADER_ROOT)
+            table.add_column(Messages.TABLE_INDEX_HEADER_MODE)
+            table.add_column(Messages.TABLE_INDEX_HEADER_MODEL)
+            table.add_column(Messages.TABLE_INDEX_HEADER_HIDDEN, justify="center")
+            table.add_column(Messages.TABLE_INDEX_HEADER_RECURSIVE, justify="center")
+            table.add_column(Messages.TABLE_INDEX_HEADER_FILES, justify="right")
+            table.add_column(Messages.TABLE_INDEX_HEADER_GENERATED)
+            for entry in entries:
+                table.add_row(
+                    str(entry["root_path"]),
+                    str(entry["mode"]),
+                    str(entry["model"]),
+                    "yes" if entry["include_hidden"] else "no",
+                    "yes" if entry["recursive"] else "no",
+                    str(entry["file_count"]),
+                    str(entry["generated_at"]),
+                )
+            console.print(table)
+
 
 @app.command()
 def doctor() -> None:
     """Check whether the `vexor` command is available on PATH."""
     console.print(_styled(Messages.INFO_DOCTOR_CHECKING, Styles.INFO))
-    command_path = shutil.which("vexor")
+    command_path = find_command_on_path("vexor")
     if command_path:
         console.print(
             _styled(Messages.INFO_DOCTOR_FOUND.format(path=command_path), Styles.SUCCESS)
@@ -302,14 +498,14 @@ def update() -> None:
     console.print(_styled(Messages.INFO_UPDATE_CHECKING, Styles.INFO))
     console.print(_styled(Messages.INFO_UPDATE_CURRENT.format(current=__version__), Styles.INFO))
     try:
-        latest = _fetch_remote_version()
+        latest = fetch_remote_version(REMOTE_VERSION_URL)
     except RuntimeError as exc:
         console.print(
             _styled(Messages.ERROR_UPDATE_FETCH.format(reason=str(exc)), Styles.ERROR)
         )
         raise typer.Exit(code=1)
 
-    if _version_tuple(latest) > _version_tuple(__version__):
+    if version_tuple(latest) > version_tuple(__version__):
         console.print(
             _styled(
                 Messages.INFO_UPDATE_AVAILABLE.format(
@@ -327,7 +523,7 @@ def update() -> None:
     )
 
 
-def _render_results(results: Sequence[DisplayResult], base: Path, backend: str | None) -> None:
+def _render_results(results: Sequence["SearchResult"], base: Path, backend: str | None) -> None:
     console.print(_styled(Messages.TABLE_TITLE, Styles.TITLE))
     if backend:
         console.print(_styled(f"{Messages.TABLE_BACKEND_PREFIX}{backend}", Styles.INFO))
@@ -335,132 +531,83 @@ def _render_results(results: Sequence[DisplayResult], base: Path, backend: str |
     table.add_column(Messages.TABLE_HEADER_INDEX, justify="right")
     table.add_column(Messages.TABLE_HEADER_SIMILARITY, justify="right")
     table.add_column(Messages.TABLE_HEADER_PATH, overflow="fold")
+    table.add_column(Messages.TABLE_HEADER_PREVIEW, overflow="fold")
     for idx, result in enumerate(results, start=1):
         table.add_row(
             str(idx),
             f"{result.score:.3f}",
             format_path(result.path, base),
+            _format_preview(result.preview),
         )
     console.print(table)
 
 
-def _create_searcher(model_name: str, batch_size: int):
-    from .search import VexorSearcher  # Local import keeps CLI startup fast
-
-    return VexorSearcher(model_name=model_name, batch_size=batch_size)
-
-
-def _label_for_path(path: Path) -> str:
-    return path.name.replace("_", " ")
-
-
-def _load_index(root: Path, model: str, include_hidden: bool):
-    from .cache import load_index_vectors  # local import
-
-    return load_index_vectors(root, model, include_hidden)
-
+def _styled(text: str, style: str) -> str:
+    return f"[{style}]{text}[/{style}]"
 
-def _load_index_metadata_safe(root: Path, model: str, include_hidden: bool):
-    from .cache import load_index  # local import
 
-    try:
-        return load_index(root, model, include_hidden)
-    except FileNotFoundError:
-        return None
+def _format_preview(text: str | None, limit: int = 80) -> str:
+    if not text:
+        return "-"
+    snippet = text.strip()
+    if len(snippet) <= limit:
+        return snippet
+    return snippet[: limit - 1].rstrip() + "…"
 
 
-def _store_index(**kwargs):
-    from .cache import store_index  # local import
+def run(argv: list[str] | None = None) -> None:
+    """Entry point wrapper allowing optional argument override."""
+    if argv is None:
+        app()
+    else:
+        app(args=list(argv))
 
-    return store_index(**kwargs)
 
+def _format_command(parts: Sequence[str]) -> str:
+    return " ".join(shlex.quote(part) for part in parts)
 
-def _clear_index_cache(root: Path, include_hidden: bool, model: str | None = None) -> int:
-    from .cache import clear_index  # local import
 
-    return clear_index(root=root, include_hidden=include_hidden, model=model)
+def _ensure_config_file() -> Path:
+    config_path = config_module.CONFIG_FILE
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    if not config_path.exists():
+        config_path.write_text("{}\n", encoding="utf-8")
+    return config_path
 
 
-def _fetch_remote_version(url: str = REMOTE_VERSION_URL) -> str:
-    from urllib import request, error
+def _edit_config_file() -> None:
+    command = resolve_editor_command()
+    if not command:
+        console.print(_styled(Messages.ERROR_CONFIG_EDITOR_NOT_FOUND, Styles.ERROR))
+        raise typer.Exit(code=1)
 
-    try:
-        with request.urlopen(url, timeout=10) as response:
-            if response.status != 200:
-                raise RuntimeError(f"HTTP {response.status}")
-            text = response.read().decode("utf-8")
-    except error.URLError as exc:  # pragma: no cover - network error
-        raise RuntimeError(str(exc)) from exc
-
-    match = re.search(r"__version__\s*=\s*['\"]([^'\"]+)['\"]", text)
-    if not match:
-        raise RuntimeError("Version string not found")
-    return match.group(1)
-
-
-def _version_tuple(raw: str) -> tuple[int, int, int, int]:
-    raw = raw.strip()
-    release_parts: list[int] = []
-    suffix_number = 0
-
-    for piece in raw.split('.'):
-        match = re.match(r"^(\d+)", piece)
-        if not match:
-            break
-        release_parts.append(int(match.group(1)))
-        remainder = piece[match.end():]
-        if remainder:
-            suffix_match = re.match(r"[A-Za-z]+(\d+)", remainder)
-            if suffix_match:
-                suffix_number = int(suffix_match.group(1))
-            break
-        if len(release_parts) >= 4:
-            break
-
-    while len(release_parts) < 4:
-        release_parts.append(0)
-
-    if suffix_number:
-        release_parts[3] = suffix_number
-
-    return tuple(release_parts[:4])
-
-
-def _is_cache_current(
-    root: Path,
-    include_hidden: bool,
-    cached_files: Sequence[dict],
-    *,
-    current_files: Sequence[Path] | None = None,
-) -> bool:
-    if not cached_files:
-        return False
-    from .cache import compare_snapshot  # local import
-
-    return compare_snapshot(
-        root,
-        include_hidden,
-        cached_files,
-        current_files=current_files,
+    cmd_list = list(command)
+    config_path = _ensure_config_file()
+    console.print(
+        _styled(
+            Messages.INFO_CONFIG_EDITING.format(
+                path=config_path,
+                editor=_format_command(cmd_list),
+            ),
+            Styles.INFO,
+        )
     )
-
-
-def _warn_if_stale(root: Path, include_hidden: bool, cached_files: Sequence[dict]) -> None:
-    if not cached_files:
-        return
-    if not _is_cache_current(root, include_hidden, cached_files):
+    try:
+        subprocess.run(cmd_list + [str(config_path)], check=True)
+    except FileNotFoundError as exc:
+        console.print(
+            _styled(
+                Messages.ERROR_CONFIG_EDITOR_LAUNCH.format(reason=str(exc)),
+                Styles.ERROR,
+            )
+        )
+        raise typer.Exit(code=1)
+    except subprocess.CalledProcessError as exc:
+        code = exc.returncode if exc.returncode is not None else 1
         console.print(
-            _styled(Messages.WARNING_INDEX_STALE.format(path=root), Styles.WARNING)
+            _styled(
+                Messages.ERROR_CONFIG_EDITOR_FAILED.format(code=code),
+                Styles.ERROR,
+            )
         )
-
-
-def _styled(text: str, style: str) -> str:
-    return f"[{style}]{text}[/{style}]"
-
-
-def run(argv: list[str] | None = None) -> None:
-    """Entry point wrapper allowing optional argument override."""
-    if argv is None:
-        app()
-    else:
-        app(args=list(argv))
+        raise typer.Exit(code=code)