codemaster-cli 2.2.0__py3-none-any.whl

vibe/core/autocompletion/completers.py

@@ -0,0 +1,257 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+from typing import NamedTuple
+
+from vibe.core.autocompletion.file_indexer import FileIndexer, IndexEntry
+from vibe.core.autocompletion.fuzzy import fuzzy_match
+
+DEFAULT_MAX_ENTRIES_TO_PROCESS = 32000
+DEFAULT_TARGET_MATCHES = 100
+
+
+class Completer:
+    def get_completions(self, text: str, cursor_pos: int) -> list[str]:
+        return []
+
+    def get_completion_items(self, text: str, cursor_pos: int) -> list[tuple[str, str]]:
+        return [
+            (completion, "") for completion in self.get_completions(text, cursor_pos)
+        ]
+
+    def get_replacement_range(
+        self, text: str, cursor_pos: int
+    ) -> tuple[int, int] | None:
+        return None
+
+
+class CommandCompleter(Completer):
+    def __init__(self, entries: Callable[[], list[tuple[str, str]]]) -> None:
+        self._get_entries = entries
+
+    def _build_lookup(self) -> tuple[list[str], dict[str, str]]:
+        descriptions: dict[str, str] = {}
+        for alias, description in self._get_entries():
+            descriptions[alias] = description
+        return list(descriptions.keys()), descriptions
+
+    def get_completions(self, text: str, cursor_pos: int) -> list[str]:
+        if not text.startswith("/"):
+            return []
+
+        aliases, _ = self._build_lookup()
+        word = text[1:cursor_pos].lower()
+        search_str = "/" + word
+        return [alias for alias in aliases if alias.lower().startswith(search_str)]
+
+    def get_completion_items(self, text: str, cursor_pos: int) -> list[tuple[str, str]]:
+        if not text.startswith("/"):
+            return []
+
+        aliases, descriptions = self._build_lookup()
+        word = text[1:cursor_pos].lower()
+        search_str = "/" + word
+        return [
+            (alias, descriptions.get(alias, ""))
+            for alias in aliases
+            if alias.lower().startswith(search_str)
+        ]
+
+    def get_replacement_range(
+        self, text: str, cursor_pos: int
+    ) -> tuple[int, int] | None:
+        if text.startswith("/"):
+            return (0, cursor_pos)
+        return None
+
+
+class PathCompleter(Completer):
+    def __init__(
+        self,
+        max_entries_to_process: int = DEFAULT_MAX_ENTRIES_TO_PROCESS,
+        target_matches: int = DEFAULT_TARGET_MATCHES,
+    ) -> None:
+        self._indexer = FileIndexer()
+        self._max_entries_to_process = max_entries_to_process
+        self._target_matches = target_matches
+
+    class _SearchContext(NamedTuple):
+        suffix: str
+        search_pattern: str
+        path_prefix: str
+        immediate_only: bool
+
+    def _extract_partial(self, before_cursor: str) -> str | None:
+        if "@" not in before_cursor:
+            return None
+
+        at_index = before_cursor.rfind("@")
+        fragment = before_cursor[at_index + 1 :]
+
+        if " " in fragment:
+            return None
+
+        return fragment
+
+    def _build_search_context(self, partial_path: str) -> _SearchContext:
+        suffix = partial_path.split("/")[-1]
+
+        if not partial_path:
+            # "@" => show top-level dir and files
+            return self._SearchContext(
+                search_pattern="", path_prefix="", suffix=suffix, immediate_only=True
+            )
+
+        if partial_path.endswith("/"):
+            # "@something/" => list immediate children
+            return self._SearchContext(
+                search_pattern="",
+                path_prefix=partial_path,
+                suffix=suffix,
+                immediate_only=True,
+            )
+
+        return self._SearchContext(
+            # => run fuzzy search across the index
+            search_pattern=partial_path,
+            path_prefix="",
+            suffix=suffix,
+            immediate_only=False,
+        )
+
+    def _matches_prefix(self, entry: IndexEntry, context: _SearchContext) -> bool:
+        path_str = entry.rel
+
+        if context.path_prefix:
+            prefix_without_slash = context.path_prefix.rstrip("/")
+            prefix_with_slash = f"{prefix_without_slash}/"
+
+            if path_str == prefix_without_slash and entry.is_dir:
+                # do not suggest the dir itself (e.g. "@src/" => don't suggest "@src/")
+                return False
+
+            if path_str.startswith(prefix_with_slash):
+                after_prefix = path_str[len(prefix_with_slash) :]
+            else:
+                idx = path_str.find(prefix_with_slash)
+                if idx == -1 or (idx > 0 and path_str[idx - 1] != "/"):
+                    return False
+                after_prefix = path_str[idx + len(prefix_with_slash) :]
+
+            # only suggest files/dirs that are immediate children of the prefix
+            return bool(after_prefix) and "/" not in after_prefix
+
+        if context.immediate_only and "/" in path_str:
+            # when user just typed "@", only show top-level entries
+            return False
+
+        # entry matches the prefix: let the fuzzy matcher decide if it's a good match
+        return True
+
+    def _is_visible(self, entry: IndexEntry, context: _SearchContext) -> bool:
+        return not (entry.name.startswith(".") and not context.suffix.startswith("."))
+
+    def _format_label(self, entry: IndexEntry) -> str:
+        suffix = "/" if entry.is_dir else ""
+        return f"@{entry.rel}{suffix}"
+
+    def _score_matches(
+        self, entries: list[IndexEntry], context: _SearchContext
+    ) -> list[tuple[str, float]]:
+        scored_matches: list[tuple[str, float]] = []
+        MAX_MATCHES = 50
+
+        for i, entry in enumerate(entries):
+            if i >= self._max_entries_to_process:
+                break
+
+            if not self._matches_prefix(entry, context):
+                continue
+
+            if not self._is_visible(entry, context):
+                continue
+
+            label = self._format_label(entry)
+
+            if not context.search_pattern:
+                scored_matches.append((label, 0.0))
+                if len(scored_matches) >= self._target_matches:
+                    break
+                continue
+
+            match_result = fuzzy_match(
+                context.search_pattern, entry.rel, entry.rel_lower
+            )
+            if match_result.matched:
+                scored_matches.append((label, match_result.score))
+                if (
+                    len(scored_matches) >= self._target_matches
+                    and match_result.score > MAX_MATCHES
+                ):
+                    break
+
+        scored_matches.sort(key=lambda x: (-x[1], x[0]))
+        return scored_matches
+
+    def _collect_matches(self, text: str, cursor_pos: int) -> list[str]:
+        before_cursor = text[:cursor_pos]
+        partial_path = self._extract_partial(before_cursor)
+        if partial_path is None:
+            return []
+
+        context = self._build_search_context(partial_path)
+
+        try:
+            # TODO (Vince): doing the assumption that "." is the root directory... Reliable?
+            file_index = self._indexer.get_index(Path("."))
+        except (OSError, RuntimeError):
+            return []
+
+        scored_matches = self._score_matches(file_index, context)
+        return [path for path, _ in scored_matches]
+
+    def get_completions(self, text: str, cursor_pos: int) -> list[str]:
+        return self._collect_matches(text, cursor_pos)
+
+    def get_completion_items(self, text: str, cursor_pos: int) -> list[tuple[str, str]]:
+        matches = self._collect_matches(text, cursor_pos)
+        return [(completion, "") for completion in matches]
+
+    def get_replacement_range(
+        self, text: str, cursor_pos: int
+    ) -> tuple[int, int] | None:
+        before_cursor = text[:cursor_pos]
+        if "@" in before_cursor:
+            at_index = before_cursor.rfind("@")
+            return (at_index, cursor_pos)
+        return None
+
+
+class MultiCompleter(Completer):
+    def __init__(self, completers: list[Completer]) -> None:
+        self.completers = completers
+
+    def get_completions(self, text: str, cursor_pos: int) -> list[str]:
+        all_completions = []
+        for completer in self.completers:
+            completions = completer.get_completions(text, cursor_pos)
+            all_completions.extend(completions)
+
+        seen = set()
+        unique = []
+        for comp in all_completions:
+            if comp not in seen:
+                seen.add(comp)
+                unique.append(comp)
+
+        return unique
+
+    def get_replacement_range(
+        self, text: str, cursor_pos: int
+    ) -> tuple[int, int] | None:
+        for completer in self.completers:
+            range_result = completer.get_replacement_range(text, cursor_pos)
+            if range_result is not None:
+                return range_result
+        return None

vibe/core/autocompletion/file_indexer/__init__.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from vibe.core.autocompletion.file_indexer.indexer import FileIndexer
+from vibe.core.autocompletion.file_indexer.store import (
+    FileIndexStats,
+    FileIndexStore,
+    IndexEntry,
+)
+
+__all__ = ["FileIndexStats", "FileIndexStore", "FileIndexer", "IndexEntry"]

vibe/core/autocompletion/file_indexer/ignore_rules.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import fnmatch
+from pathlib import Path
+
+DEFAULT_IGNORE_PATTERNS: list[tuple[str, bool]] = [
+    (".git/", True),
+    ("__pycache__/", True),
+    ("node_modules/", True),
+    (".DS_Store", True),
+    ("*.pyc", True),
+    ("*.log", True),
+    (".vscode/", True),
+    (".idea/", True),
+    ("/build/", True),
+    ("dist/", True),
+    ("target/", True),
+    (".next/", True),
+    (".nuxt/", True),
+    ("coverage/", True),
+    (".nyc_output/", True),
+    ("*.egg-info", True),
+    (".pytest_cache/", True),
+    (".tox/", True),
+    ("vendor/", True),
+    ("third_party/", True),
+    ("deps/", True),
+    ("*.min.js", True),
+    ("*.min.css", True),
+    ("*.bundle.js", True),
+    ("*.chunk.js", True),
+    (".cache/", True),
+    ("tmp/", True),
+    ("temp/", True),
+    ("logs/", True),
+    (".uv-cache/", True),
+    (".ruff_cache/", True),
+    (".venv/", True),
+    ("venv/", True),
+    (".mypy_cache/", True),
+    ("htmlcov/", True),
+    (".coverage", True),
+]
+
+
+@dataclass(slots=True)
+class CompiledPattern:
+    raw: str
+    stripped: str
+    is_exclude: bool
+    dir_only: bool
+    name_only: bool
+    anchor_root: bool
+
+
+class IgnoreRules:
+    def __init__(self, defaults: list[tuple[str, bool]] | None = None) -> None:
+        self._defaults = defaults or DEFAULT_IGNORE_PATTERNS
+        self._patterns: list[CompiledPattern] | None = None
+        self._root: Path | None = None
+
+    def ensure_for_root(self, root: Path) -> None:
+        resolved_root = root.resolve()
+        if self._patterns is None or self._root != resolved_root:
+            self._patterns = self._build_patterns(resolved_root)
+            self._root = resolved_root
+
+    def should_ignore(self, rel_str: str, name: str, is_dir: bool) -> bool:
+        if not self._patterns:
+            return False
+
+        ignored = False
+        for pattern in self._patterns:
+            if self._matches(rel_str, name, is_dir, pattern):
+                ignored = pattern.is_exclude
+        return ignored
+
+    def reset(self) -> None:
+        self._patterns = None
+        self._root = None
+
+    def _build_patterns(self, root: Path) -> list[CompiledPattern]:
+        patterns: list[CompiledPattern] = []
+        for raw, is_exclude in self._defaults:
+            anchor_root = raw.startswith("/")
+            if anchor_root:
+                raw = raw[1:]
+
+            stripped = raw.rstrip("/")
+            patterns.append(
+                CompiledPattern(
+                    raw=raw,
+                    stripped=stripped,
+                    is_exclude=is_exclude,
+                    dir_only=raw.endswith("/"),
+                    name_only="/" not in stripped,
+                    anchor_root=anchor_root,
+                )
+            )
+
+        gitignore_path = root / ".gitignore"
+        if gitignore_path.exists():
+            try:
+                text = gitignore_path.read_text(encoding="utf-8")
+            except Exception:
+                return patterns
+
+            for line in text.splitlines():
+                raw = line.strip()
+                if not raw or raw.startswith("#"):
+                    continue
+
+                if "#" in raw:
+                    raw = raw.split("#", 1)[0].rstrip()
+                    if not raw:
+                        continue
+
+                is_exclude = not raw.startswith("!")
+                if not is_exclude:
+                    raw = raw[1:].lstrip()
+                    if not raw:
+                        continue
+
+                anchor_root = raw.startswith("/")
+                if anchor_root:
+                    raw = raw[1:]
+
+                stripped = raw.rstrip("/")
+                patterns.append(
+                    CompiledPattern(
+                        raw=raw,
+                        stripped=stripped,
+                        is_exclude=is_exclude,
+                        dir_only=raw.endswith("/"),
+                        name_only="/" not in stripped,
+                        anchor_root=anchor_root,
+                    )
+                )
+
+        return patterns
+
+    def _matches(
+        self, rel_str: str, name: str, is_dir: bool, pattern: CompiledPattern
+    ) -> bool:
+        if pattern.name_only:
+            if pattern.anchor_root and "/" in rel_str:
+                return False
+            target = name
+        else:
+            target = rel_str
+
+        if not fnmatch.fnmatch(target, pattern.stripped):
+            return False
+
+        return not pattern.dir_only or is_dir

vibe/core/autocompletion/file_indexer/indexer.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+import atexit
+from collections.abc import Iterable
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
+from pathlib import Path
+from threading import Event, RLock
+
+from vibe.core.autocompletion.file_indexer.ignore_rules import IgnoreRules
+from vibe.core.autocompletion.file_indexer.store import (
+    FileIndexStats,
+    FileIndexStore,
+    IndexEntry,
+)
+from vibe.core.autocompletion.file_indexer.watcher import Change, WatchController
+
+
+@dataclass(slots=True)
+class _RebuildTask:
+    cancel_event: Event
+    done_event: Event
+
+
+class FileIndexer:
+    def __init__(self, mass_change_threshold: int = 200) -> None:
+        self._lock = RLock()  # guards _store snapshot access and watcher callbacks.
+        self._stats = FileIndexStats()
+        self._ignore_rules = IgnoreRules()
+        self._store = FileIndexStore(
+            self._ignore_rules, self._stats, mass_change_threshold=mass_change_threshold
+        )
+        self._watcher = WatchController(self._handle_watch_changes)
+        self._rebuild_executor = ThreadPoolExecutor(
+            max_workers=1, thread_name_prefix="file-indexer"
+        )
+        self._active_rebuilds: dict[Path, _RebuildTask] = {}
+        self._rebuild_lock = (
+            RLock()
+        )  # coordinates updates to _active_rebuilds and _target_root.
+        self._target_root: Path | None = None
+        self._shutdown = False
+
+        atexit.register(self.shutdown)
+
+    @property
+    def stats(self) -> FileIndexStats:
+        return self._stats
+
+    def get_index(self, root: Path) -> list[IndexEntry]:
+        resolved_root = root.resolve()
+
+        with self._lock:  # read current root without blocking rebuild bookkeeping
+            root_changed = (
+                self._store.root is not None and self._store.root != resolved_root
+            )
+
+        if root_changed:
+            self._watcher.stop()
+            with self._rebuild_lock:  # cancel rebuilds targeting other roots
+                self._target_root = resolved_root
+                for other_root, task in self._active_rebuilds.items():
+                    if other_root != resolved_root:
+                        task.cancel_event.set()
+                        task.done_event.set()
+                        self._active_rebuilds.pop(other_root, None)
+
+        with self._lock:
+            needs_rebuild = self._store.root != resolved_root
+
+        if needs_rebuild:
+            with self._rebuild_lock:
+                self._target_root = resolved_root
+            self._start_background_rebuild(resolved_root)
+            self._wait_for_rebuild(resolved_root)
+
+        self._watcher.start(resolved_root)
+
+        with self._lock:  # ensure root reference is fresh before snapshotting
+            return self._store.snapshot()
+
+    def refresh(self) -> None:
+        self._watcher.stop()
+        with self._rebuild_lock:
+            for task in self._active_rebuilds.values():
+                task.cancel_event.set()
+                task.done_event.set()
+            self._active_rebuilds.clear()
+            self._target_root = None
+        with self._lock:
+            self._store.clear()
+            self._ignore_rules.reset()
+
+    def shutdown(self) -> None:
+        if self._shutdown:
+            return
+        self._shutdown = True
+        self.refresh()
+        self._rebuild_executor.shutdown(wait=True)
+
+    def __del__(self) -> None:
+        if not self._shutdown:
+            try:
+                self.shutdown()
+            except Exception:
+                pass
+
+    def _start_background_rebuild(self, root: Path) -> None:
+        with self._rebuild_lock:  # one rebuild per root
+            if root in self._active_rebuilds:
+                return
+
+            cancel_event = Event()
+            done_event = Event()
+            self._active_rebuilds[root] = _RebuildTask(
+                cancel_event=cancel_event, done_event=done_event
+            )
+
+        try:
+            self._rebuild_executor.submit(
+                self._rebuild_worker, root, self._active_rebuilds[root]
+            )
+        except RuntimeError:
+            with self._rebuild_lock:
+                self._active_rebuilds.pop(root, None)
+            done_event.set()
+
+    def _rebuild_worker(self, root: Path, task: _RebuildTask) -> None:
+        try:
+            if task.cancel_event.is_set():  # cancelled before work began
+                with self._rebuild_lock:
+                    self._active_rebuilds.pop(root, None)
+                return
+
+            with self._rebuild_lock:  # bail if another root took ownership
+                if self._target_root != root:
+                    self._active_rebuilds.pop(root, None)
+                    return
+
+            with self._lock:  # exclusive access while rebuilding the store
+                if task.cancel_event.is_set():
+                    with self._rebuild_lock:
+                        self._active_rebuilds.pop(root, None)
+                    return
+
+                self._store.rebuild(
+                    root, should_cancel=lambda: task.cancel_event.is_set()
+                )
+
+            with self._rebuild_lock:
+                self._active_rebuilds.pop(root, None)
+        except Exception:
+            with self._rebuild_lock:
+                self._active_rebuilds.pop(root, None)
+        finally:
+            task.done_event.set()
+
+    def _wait_for_rebuild(self, root: Path) -> None:
+        with self._rebuild_lock:
+            task = self._active_rebuilds.get(root)
+        if task:
+            task.done_event.wait()
+
+    def _handle_watch_changes(
+        self, root: Path, raw_changes: Iterable[tuple[Change, str]]
+    ) -> None:
+        normalized: list[tuple[Change, Path]] = []
+        for change, path_str in raw_changes:
+            if change not in {Change.added, Change.deleted, Change.modified}:
+                continue
+            normalized.append((change, Path(path_str).resolve()))
+
+        if not normalized:
+            return
+
+        with self._lock:  # make watcher ignore stale roots
+            if self._store.root != root:
+                return
+            self._store.apply_changes(normalized)