codemaster-cli 2.2.0__py3-none-any.whl

vibe/core/autocompletion/file_indexer/store.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+import os
+from pathlib import Path
+
+from vibe.core.autocompletion.file_indexer.ignore_rules import IgnoreRules
+from vibe.core.autocompletion.file_indexer.watcher import Change
+
+
+@dataclass(slots=True)
+class FileIndexStats:
+    rebuilds: int = 0
+    incremental_updates: int = 0
+
+
+@dataclass(slots=True)
+class IndexEntry:
+    rel: str
+    rel_lower: str
+    name: str
+    path: Path
+    is_dir: bool
+
+
+class FileIndexStore:
+    def __init__(
+        self,
+        ignore_rules: IgnoreRules,
+        stats: FileIndexStats,
+        mass_change_threshold: int = 200,
+    ) -> None:
+        self._ignore_rules = ignore_rules
+        self._stats = stats
+        self._mass_change_threshold = mass_change_threshold
+        self._entries_by_rel: dict[str, IndexEntry] = {}
+        self._ordered_entries: list[IndexEntry] | None = None
+        self._root: Path | None = None
+
+    @property
+    def root(self) -> Path | None:
+        return self._root
+
+    def clear(self) -> None:
+        self._entries_by_rel.clear()
+        self._ordered_entries = None
+        self._root = None
+
+    def rebuild(
+        self, root: Path, should_cancel: Callable[[], bool] | None = None
+    ) -> None:
+        resolved_root = root.resolve()
+        self._ignore_rules.ensure_for_root(resolved_root)
+        entries = self._walk_directory(resolved_root, cancel_check=should_cancel)
+        self._entries_by_rel = {entry.rel: entry for entry in entries}
+        self._ordered_entries = entries
+        self._root = resolved_root
+        self._stats.rebuilds += 1
+
+    def snapshot(self) -> list[IndexEntry]:
+        if not self._entries_by_rel:
+            return []
+
+        if self._ordered_entries is None:
+            self._ordered_entries = sorted(
+                self._entries_by_rel.values(), key=lambda entry: entry.rel
+            )
+
+        return list(self._ordered_entries)
+
+    def apply_changes(self, changes: list[tuple[Change, Path]]) -> None:
+        if self._root is None:
+            return
+
+        if len(changes) > self._mass_change_threshold:
+            self.rebuild(self._root)
+            return
+
+        modified = False
+        for change, path in changes:
+            try:
+                rel_str = path.relative_to(self._root).as_posix()
+            except ValueError:
+                continue
+
+            if not rel_str:
+                continue
+
+            if change is Change.deleted:
+                if self._remove_entry(rel_str):
+                    modified = True
+                continue
+
+            if not path.exists():
+                continue
+
+            if path.is_dir():
+                dir_entry = self._create_entry(rel_str, path.name, path, True)
+                if dir_entry:
+                    self._entries_by_rel[rel_str] = dir_entry
+                    modified = True
+                for entry in self._walk_directory(path, rel_str):
+                    self._entries_by_rel[entry.rel] = entry
+                    modified = True
+            else:
+                file_entry = self._create_entry(rel_str, path.name, path, False)
+                if file_entry:
+                    self._entries_by_rel[file_entry.rel] = file_entry
+                    modified = True
+
+        if modified:
+            self._ordered_entries = None
+            self._stats.incremental_updates += 1
+
+    def _create_entry(
+        self, rel_str: str, name: str, path: Path, is_dir: bool
+    ) -> IndexEntry | None:
+        if self._ignore_rules.should_ignore(rel_str, name, is_dir):
+            return None
+        return IndexEntry(
+            rel=rel_str, rel_lower=rel_str.lower(), name=name, path=path, is_dir=is_dir
+        )
+
+    def _walk_directory(
+        self,
+        directory: Path,
+        rel_prefix: str = "",
+        cancel_check: Callable[[], bool] | None = None,
+    ) -> list[IndexEntry]:
+        results: list[IndexEntry] = []
+        try:
+            with os.scandir(directory) as iterator:
+                for entry in iterator:
+                    if cancel_check and cancel_check():
+                        break
+
+                    is_dir = entry.is_dir(follow_symlinks=False)
+                    name = entry.name
+                    rel_str = f"{rel_prefix}/{name}" if rel_prefix else name
+                    path = Path(entry.path)
+
+                    index_entry = self._create_entry(rel_str, name, path, is_dir)
+                    if not index_entry:
+                        continue
+
+                    results.append(index_entry)
+
+                    if is_dir:
+                        results.extend(
+                            self._walk_directory(path, rel_str, cancel_check)
+                        )
+        except (PermissionError, OSError):
+            pass
+
+        return results
+
+    def _remove_entry(self, rel_str: str) -> bool:
+        entry = self._entries_by_rel.pop(rel_str, None)
+        if not entry:
+            return False
+
+        if entry.is_dir:
+            prefix = f"{rel_str}/"
+            to_remove = [key for key in self._entries_by_rel if key.startswith(prefix)]
+            for key in to_remove:
+                self._entries_by_rel.pop(key, None)
+
+        return True

vibe/core/autocompletion/file_indexer/watcher.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable
+from pathlib import Path
+from threading import Event, Thread
+
+from watchfiles import Change, watch
+
+
+class WatchController:
+    def __init__(
+        self, on_changes: Callable[[Path, Iterable[tuple[Change, str]]], None]
+    ) -> None:
+        self._on_changes = on_changes
+        self._thread: Thread | None = None
+        self._stop_event: Event | None = None
+        self._ready_event: Event | None = None
+        self._root: Path | None = None
+
+    def start(self, root: Path) -> None:
+        resolved_root = root.resolve()
+        if self._thread and self._thread.is_alive() and self._root == resolved_root:
+            return
+
+        self.stop()
+
+        stop_event = Event()
+        ready_event = Event()
+        thread = Thread(
+            target=self._watch_loop,
+            args=(resolved_root, stop_event, ready_event),
+            name="file-indexer-watch",
+            daemon=True,
+        )
+
+        self._thread = thread
+        self._stop_event = stop_event
+        self._ready_event = ready_event
+        self._root = resolved_root
+
+        thread.start()
+        ready_event.wait(timeout=0.5)
+
+    def stop(self) -> None:
+        thread = self._thread
+        if self._stop_event:
+            self._stop_event.set()
+        self._thread = None
+        self._stop_event = None
+        self._ready_event = None
+        self._root = None
+
+        if thread and thread.is_alive():
+            thread.join(timeout=1)
+
+    def _watch_loop(self, root: Path, stop_event: Event, ready_event: Event) -> None:
+        try:
+            watcher = watch(
+                str(root), stop_event=stop_event, step=200, yield_on_timeout=True
+            )
+            ready_event.set()
+            for changes in watcher:
+                if not ready_event.is_set():
+                    ready_event.set()
+                if stop_event.is_set():
+                    break
+                if not changes:
+                    continue
+                self._on_changes(root, changes)
+        except Exception:
+            ready_event.set()

vibe/core/autocompletion/fuzzy.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+PREFIX_MULTIPLIER = 2.0
+WORD_BOUNDARY_MULTIPLIER = 1.8
+CONSECUTIVE_MULTIPLIER = 1.3
+
+
+@dataclass(frozen=True)
+class MatchResult:
+    matched: bool
+    score: float
+    matched_indices: tuple[int, ...]
+
+
+def fuzzy_match(pattern: str, text: str, text_lower: str | None = None) -> MatchResult:
+    if not pattern:
+        return MatchResult(matched=True, score=0.0, matched_indices=())
+
+    if text_lower is None:
+        text_lower = text.lower()
+    return _find_best_match(pattern, pattern.lower(), text_lower, text)
+
+
+def _find_best_match(
+    pattern_original: str, pattern_lower: str, text_lower: str, text_original: str
+) -> MatchResult:
+    if len(pattern_lower) > len(text_lower):
+        return MatchResult(matched=False, score=0.0, matched_indices=())
+
+    if text_lower.startswith(pattern_lower):
+        indices = tuple(range(len(pattern_lower)))
+        score = _calculate_score(
+            pattern_original, pattern_lower, text_lower, indices, text_original
+        )
+        return MatchResult(
+            matched=True, score=score * PREFIX_MULTIPLIER, matched_indices=indices
+        )
+
+    best_score = -1.0
+    best_indices: tuple[int, ...] = ()
+
+    for matcher in (
+        _try_word_boundary_match,
+        _try_consecutive_match,
+        _try_subsequence_match,
+    ):
+        match = matcher(pattern_original, pattern_lower, text_lower, text_original)
+        if match.matched and match.score > best_score:
+            best_score = match.score
+            best_indices = match.matched_indices
+
+    if best_score >= 0:
+        return MatchResult(matched=True, score=best_score, matched_indices=best_indices)
+
+    return MatchResult(matched=False, score=0.0, matched_indices=())
+
+
+def _try_word_boundary_match(
+    pattern_original: str, pattern: str, text_lower: str, text_original: str
+) -> MatchResult:
+    indices: list[int] = []
+    pattern_idx = 0
+
+    for i, char in enumerate(text_lower):
+        if pattern_idx >= len(pattern):
+            break
+
+        is_boundary = (
+            i == 0
+            or text_lower[i - 1] in "/-_."
+            or (text_original[i].isupper() and not text_original[i - 1].isupper())
+        )
+
+        if char == pattern[pattern_idx]:
+            if is_boundary or (indices and i == indices[-1] + 1) or not indices:
+                indices.append(i)
+                pattern_idx += 1
+
+    if pattern_idx == len(pattern):
+        score = _calculate_score(
+            pattern_original, pattern, text_lower, tuple(indices), text_original
+        )
+        return MatchResult(
+            matched=True,
+            score=score * WORD_BOUNDARY_MULTIPLIER,
+            matched_indices=tuple(indices),
+        )
+
+    return MatchResult(matched=False, score=0.0, matched_indices=())
+
+
+def _try_consecutive_match(
+    pattern_original: str, pattern: str, text_lower: str, text_original: str
+) -> MatchResult:
+    indices: list[int] = []
+    pattern_idx = 0
+
+    for i, char in enumerate(text_lower):
+        if pattern_idx >= len(pattern):
+            break
+
+        if char == pattern[pattern_idx]:
+            indices.append(i)
+            pattern_idx += 1
+        elif indices:
+            indices.clear()
+            pattern_idx = 0
+
+    if pattern_idx == len(pattern):
+        score = _calculate_score(
+            pattern_original, pattern, text_lower, tuple(indices), text_original
+        )
+        return MatchResult(
+            matched=True,
+            score=score * CONSECUTIVE_MULTIPLIER,
+            matched_indices=tuple(indices),
+        )
+
+    return MatchResult(matched=False, score=0.0, matched_indices=())
+
+
+def _try_subsequence_match(
+    pattern_original: str, pattern: str, text_lower: str, text_original: str
+) -> MatchResult:
+    indices: list[int] = []
+    pattern_idx = 0
+
+    for i, char in enumerate(text_lower):
+        if pattern_idx >= len(pattern):
+            break
+        if char == pattern[pattern_idx]:
+            indices.append(i)
+            pattern_idx += 1
+
+    if pattern_idx == len(pattern):
+        score = _calculate_score(
+            pattern_original, pattern, text_lower, tuple(indices), text_original
+        )
+        return MatchResult(matched=True, score=score, matched_indices=tuple(indices))
+
+    return MatchResult(matched=False, score=0.0, matched_indices=())
+
+
+def _calculate_score(
+    pattern_original: str,
+    pattern: str,
+    text_lower: str,
+    indices: tuple[int, ...],
+    text_original: str,
+) -> float:
+    if not indices:
+        return 0.0
+
+    base_score = 100.0
+    if indices[0] == 0:
+        base_score += 50.0
+    else:
+        base_score -= indices[0] * 2
+
+    consecutive_bonus = sum(
+        10.0 for i in range(len(indices) - 1) if indices[i + 1] == indices[i] + 1
+    )
+
+    boundary_bonus = 0.0
+    for idx in indices:
+        if idx == 0 or text_lower[idx - 1] in "/-_.":
+            boundary_bonus += 5.0
+        elif text_original[idx].isupper() and (
+            idx == 0 or not text_original[idx - 1].isupper()
+        ):
+            boundary_bonus += 3.0
+
+    case_bonus = sum(
+        2.0
+        for i, text_idx in enumerate(indices)
+        if i < len(pattern_original)
+        and text_idx < len(text_original)
+        and pattern_original[i] == text_original[text_idx]
+    )
+
+    gap_penalty = sum(
+        (indices[i + 1] - indices[i] - 1) * 1.5 for i in range(len(indices) - 1)
+    )
+
+    return max(
+        0.0, base_score + consecutive_bonus + boundary_bonus + case_bonus - gap_penalty
+    )

vibe/core/autocompletion/path_prompt.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+
+@dataclass(frozen=True, slots=True)
+class PathResource:
+    path: Path
+    alias: str
+    kind: Literal["file", "directory"]
+
+
+@dataclass(frozen=True, slots=True)
+class PathPromptPayload:
+    display_text: str
+    prompt_text: str
+    resources: list[PathResource]
+
+
+def build_path_prompt_payload(
+    message: str, *, base_dir: Path | None = None
+) -> PathPromptPayload:
+    if not message:
+        return PathPromptPayload(message, message, [])
+
+    resolved_base = (base_dir or Path.cwd()).resolve()
+    prompt_parts: list[str] = []
+    resources: list[PathResource] = []
+    pos = 0
+
+    while pos < len(message):
+        if _is_path_anchor(message, pos):
+            candidate, new_pos = _extract_candidate(message, pos + 1)
+            if candidate and (resource := _to_resource(candidate, resolved_base)):
+                resources.append(resource)
+                prompt_parts.append(candidate)
+                pos = new_pos
+                continue
+
+        prompt_parts.append(message[pos])
+        pos += 1
+
+    prompt_text = "".join(prompt_parts)
+    unique_resources = _dedupe_resources(resources)
+    return PathPromptPayload(message, prompt_text, unique_resources)
+
+
+def _is_path_anchor(message: str, pos: int) -> bool:
+    if message[pos] != "@":
+        return False
+    if pos == 0:
+        return True
+    return not (message[pos - 1].isalnum() or message[pos - 1] == "_")
+
+
+def _extract_candidate(message: str, start: int) -> tuple[str | None, int]:
+    if start >= len(message):
+        return None, start
+
+    quote = message[start]
+    if quote in {"'", '"'}:
+        end_quote = message.find(quote, start + 1)
+        if end_quote == -1:
+            return None, start
+        return message[start + 1 : end_quote], end_quote + 1
+
+    end = start
+    while end < len(message) and _is_path_char(message[end]):
+        end += 1
+
+    if end == start:
+        return None, start
+
+    return message[start:end], end
+
+
+def _is_path_char(char: str) -> bool:
+    return char.isalnum() or char in "._/\\-()[]{}"
+
+
+def _to_resource(candidate: str, base_dir: Path) -> PathResource | None:
+    if not candidate:
+        return None
+
+    candidate_path = Path(candidate)
+    resolved = (
+        candidate_path if candidate_path.is_absolute() else base_dir / candidate_path
+    )
+    resolved = resolved.resolve()
+
+    if not resolved.exists():
+        return None
+
+    kind = "directory" if resolved.is_dir() else "file"
+    return PathResource(path=resolved, alias=candidate, kind=kind)
+
+
+def _dedupe_resources(resources: list[PathResource]) -> list[PathResource]:
+    seen: set[Path] = set()
+    unique: list[PathResource] = []
+    for resource in resources:
+        if resource.path in seen:
+            continue
+        seen.add(resource.path)
+        unique.append(resource)
+    return unique

vibe/core/autocompletion/path_prompt_adapter.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+import mimetypes
+from pathlib import Path
+
+from vibe.core.autocompletion.path_prompt import (
+    PathPromptPayload,
+    PathResource,
+    build_path_prompt_payload,
+)
+
+DEFAULT_MAX_EMBED_BYTES = 256 * 1024
+
+ResourceBlock = dict[str, str | None]
+
+
+def render_path_prompt(
+    message: str,
+    *,
+    base_dir: Path,
+    max_embed_bytes: int | None = DEFAULT_MAX_EMBED_BYTES,
+) -> str:
+    payload = build_path_prompt_payload(message, base_dir=base_dir)
+    blocks = _path_prompt_to_content_blocks(payload, max_embed_bytes=max_embed_bytes)
+    return _content_blocks_to_prompt_text(blocks)
+
+
+def _path_prompt_to_content_blocks(
+    payload: PathPromptPayload, *, max_embed_bytes: int | None = DEFAULT_MAX_EMBED_BYTES
+) -> list[ResourceBlock]:
+    blocks: list[ResourceBlock] = [{"type": "text", "text": payload.prompt_text}]
+
+    for resource in payload.resources:
+        match resource.kind:
+            case "file":
+                embedded = _try_embed_text_resource(resource, max_embed_bytes)
+                if embedded:
+                    blocks.append(embedded)
+                else:
+                    blocks.append({
+                        "type": "resource_link",
+                        "uri": resource.path.as_uri(),
+                        "name": resource.alias,
+                    })
+            case "directory":
+                blocks.append({
+                    "type": "resource_link",
+                    "uri": resource.path.as_uri(),
+                    "name": resource.alias,
+                })
+
+    return blocks
+
+
+def _try_embed_text_resource(
+    resource: PathResource, max_embed_bytes: int | None
+) -> ResourceBlock | None:
+    try:
+        data = resource.path.read_bytes()
+    except OSError:
+        return None
+
+    if max_embed_bytes is not None and len(data) > max_embed_bytes:
+        return None
+
+    if not _is_probably_text(resource, data):
+        return None
+
+    try:
+        text = data.decode("utf-8")
+    except UnicodeDecodeError:
+        return None
+
+    return {"type": "resource", "uri": resource.path.as_uri(), "text": text}
+
+
+def _content_blocks_to_prompt_text(blocks: Sequence[ResourceBlock]) -> str:
+    parts = []
+
+    for block in blocks:
+        block_text = _format_content_block(block)
+        if block_text is not None:
+            parts.append(block_text)
+
+    return "\n\n".join(parts)
+
+
+def _format_content_block(block: ResourceBlock) -> str | None:
+    match block.get("type"):
+        case "text":
+            return block.get("text") or ""
+
+        case "resource":
+            block_content = block.get("text") or ""
+            fence = "```"
+            return f"{block.get('uri')}\n{fence}\n{block_content}\n{fence}"
+
+        case "resource_link":
+            fields = {
+                "uri": block.get("uri"),
+                "name": block.get("name"),
+                "title": block.get("title"),
+                "description": block.get("description"),
+                "mime_type": block.get("mime_type"),
+                "size": block.get("size"),
+            }
+            parts = [
+                f"{k}: {v}"
+                for k, v in fields.items()
+                if v is not None and (v or isinstance(v, (int, float)))
+            ]
+            return "\n".join(parts)
+
+        case _:
+            return None
+
+
+BINARY_MIME_PREFIXES = (
+    "audio/",
+    "image/",
+    "video/",
+    "application/zip",
+    "application/x-zip-compressed",
+)
+
+
+def _is_probably_text(path: PathResource, data: bytes) -> bool:
+    mime_guess, _ = mimetypes.guess_type(path.path.name)
+    if mime_guess and mime_guess.startswith(BINARY_MIME_PREFIXES):
+        return False
+
+    if not data:
+        return True
+    if b"\x00" in data:
+        return False
+
+    DEL_CODE = 127
+    NON_PRINTABLE_MAX_PROPORTION = 0.1
+    NON_PRINTABLE_MAX_CODE = 31
+    NON_PRINTABLE_EXCEPTIONS = [9, 10, 11, 12]
+    non_text = sum(
+        1
+        for b in data
+        if b <= NON_PRINTABLE_MAX_CODE
+        and b not in NON_PRINTABLE_EXCEPTIONS
+        or b == DEL_CODE
+    )
+    return (non_text / len(data)) < NON_PRINTABLE_MAX_PROPORTION