attocode-code-intel 0.1.0__py3-none-any.whl

attocode_intel/_internal/integrations/context/fuzzy.py

@@ -0,0 +1,320 @@
+"""Fuzzy string matching using Smith-Waterman algorithm.
+
+Provides typo-resistant search that can find "mtxlk" matching "mutex_lock".
+Uses the Smith-Waterman algorithm for local sequence alignment with
+affine gaps for optimal matching.
+
+Based on fff.nvim's fuzzy grep implementation.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+# ---------------------------------------------------------------------------
+# Scoring constants
+# ---------------------------------------------------------------------------
+
+_MATCH_SCORE: int = 2
+_MISMATCH_SCORE: int = -1
+_GAP_OPEN: int = -3
+_GAP_EXTEND: int = -1
+
+# Minimum score threshold (normalized to 0-100)
+_MIN_SCORE_THRESHOLD: float = 30.0
+
+# ---------------------------------------------------------------------------
+# Data structures
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class FuzzyMatch:
+    """A fuzzy match result."""
+    text: str
+    score: float  # 0-100 normalized score
+    matched_indices: list[int]  # Positions in text that matched the pattern
+
+
+@dataclass
+class FuzzyResult:
+    """Result of a fuzzy search."""
+    query: str
+    matches: list[FuzzyMatch]
+    mode: str = "fuzzy"
+
+
+# ---------------------------------------------------------------------------
+# Smith-Waterman implementation
+# ---------------------------------------------------------------------------
+
+
+def _smith_waterman(
+    pattern: str,
+    text: str,
+    *,
+    case_sensitive: bool = True,
+) -> tuple[float, list[int]]:
+    """Perform Smith-Waterman local alignment.
+
+    Args:
+        pattern: The search pattern (query).
+        text: The text to search in.
+        case_sensitive: Whether to match case-sensitively.
+
+    Returns:
+        Tuple of (normalized_score 0-100, list of matched character indices).
+    """
+    if not pattern or not text:
+        return 0.0, []
+
+    p_len = len(pattern)
+    t_len = len(text)
+
+    # Convert to uppercase for case-insensitive matching
+    if not case_sensitive:
+        p_upper = pattern.upper()
+        t_upper = text.upper()
+    else:
+        p_upper = pattern
+        t_upper = text
+
+    # Initialize matrices
+    # We only need two rows for memory efficiency
+    prev_row = [0] * (t_len + 1)
+    curr_row = [0] * (t_len + 1)
+
+    # Traceback matrix (only for matched indices)
+    # Store: 0=end, 1=diag, 2=up, 3=left
+    trace: list[list[int]] = [[0] * (t_len + 1) for _ in range(p_len + 1)]
+
+    max_score = 0
+    max_pos = (0, 0)
+
+    # Fill matrices
+    for i in range(1, p_len + 1):
+        for j in range(1, t_len + 1):
+            p_char = p_upper[i - 1]
+            t_char = t_upper[j - 1]
+
+            # Match/mismatch score
+            if p_char == t_char:
+                diag_score = prev_row[j - 1] + _MATCH_SCORE
+            else:
+                diag_score = prev_row[j - 1] + _MISMATCH_SCORE
+
+            # Gap open (from top)
+            up_score = prev_row[j] + _GAP_OPEN if prev_row[j] < 0 else prev_row[j] + _GAP_EXTEND
+
+            # Gap extend (from left)
+            left_score = curr_row[j - 1] + _GAP_OPEN if curr_row[j - 1] < 0 else curr_row[j - 1] + _GAP_EXTEND
+
+            # Take maximum (local alignment allows 0)
+            scores = [0, diag_score, up_score, left_score]
+            curr_row[j] = max(scores)
+            trace[i][j] = scores.index(curr_row[j])
+
+            if curr_row[j] > max_score:
+                max_score = curr_row[j]
+                max_pos = (i, j)
+
+        # Swap rows
+        prev_row, curr_row = curr_row, prev_row
+
+    if max_score <= 0:
+        return 0.0, []
+
+    # Traceback to find matched indices
+    matched_indices: list[int] = []
+    i, j = max_pos
+
+    while trace[i][j] != 0 and i > 0 and j > 0:
+        if trace[i][j] == 1:  # Diagonal (match/mismatch)
+            matched_indices.append(j - 1)
+            i -= 1
+            j -= 1
+        elif trace[i][j] == 2:  # Up (gap in text)
+            i -= 1
+        else:  # Left (gap in pattern)
+            j -= 1
+
+    matched_indices.reverse()
+
+    # Normalize score to 0-100 range
+    # Maximum possible score is len(pattern) * MATCH_SCORE
+    max_possible = p_len * _MATCH_SCORE
+    normalized = (max_score / max_possible) * 100.0 if max_possible > 0 else 0.0
+
+    return normalized, matched_indices
+
+
+def fuzzy_match(
+    pattern: str,
+    text: str,
+    *,
+    case_sensitive: bool = True,
+    min_score: float = _MIN_SCORE_THRESHOLD,
+) -> FuzzyMatch | None:
+    """Check if pattern fuzzy-matches text.
+
+    Args:
+        pattern: The pattern to search for.
+        text: The text to search in.
+        case_sensitive: Whether matching is case-sensitive.
+        min_score: Minimum score threshold (0-100).
+
+    Returns:
+        FuzzyMatch if score >= min_score, None otherwise.
+    """
+    score, indices = _smith_waterman(pattern, text, case_sensitive=case_sensitive)
+
+    if score >= min_score:
+        return FuzzyMatch(text=text, score=score, matched_indices=indices)
+    return None
+
+
+def fuzzy_match_in_lines(
+    pattern: str,
+    lines: Sequence[str],
+    *,
+    case_sensitive: bool = True,
+    min_score: float = _MIN_SCORE_THRESHOLD,
+    max_results: int = 100,
+) -> list[FuzzyMatch]:
+    """Find fuzzy matches of pattern in lines.
+
+    Args:
+        pattern: The pattern to search for.
+        lines: Lines to search in.
+        case_sensitive: Whether matching is case-sensitive.
+        min_score: Minimum score threshold (0-100).
+        max_results: Maximum number of results to return.
+
+    Returns:
+        List of FuzzyMatch objects for matching lines.
+    """
+    results: list[FuzzyMatch] = []
+
+    for line in lines:
+        match = fuzzy_match(pattern, line, case_sensitive=case_sensitive, min_score=min_score)
+        if match is not None:
+            results.append(match)
+            if len(results) >= max_results:
+                break
+
+    # Sort by score descending
+    results.sort(key=lambda m: m.score, reverse=True)
+    return results
+
+
+def fuzzy_search(
+    pattern: str,
+    text: str,
+    *,
+    case_sensitive: bool = False,
+    min_score: float = _MIN_SCORE_THRESHOLD,
+) -> FuzzyResult:
+    """Perform fuzzy search on text.
+
+    This splits text into lines and finds fuzzy matches.
+
+    Args:
+        pattern: The pattern to search for.
+        text: The text to search in.
+        case_sensitive: Whether matching is case-sensitive.
+        min_score: Minimum score threshold (0-100).
+
+    Returns:
+        FuzzyResult with all matching lines.
+    """
+    lines = text.splitlines()
+    matches = fuzzy_match_in_lines(
+        pattern,
+        lines,
+        case_sensitive=case_sensitive,
+        min_score=min_score,
+    )
+    return FuzzyResult(query=pattern, matches=matches)
+
+
+# ---------------------------------------------------------------------------
+# Quick pattern matching for file names
+# ---------------------------------------------------------------------------
+
+
+def fuzzy_match_filename(pattern: str, filename: str) -> float:
+    """Check how well a pattern matches a filename.
+
+    Uses a simpler scoring for filename matching.
+
+    Args:
+        pattern: The search pattern.
+        filename: The filename to match against.
+
+    Returns:
+        Score 0-100 indicating match quality.
+    """
+    pattern_lower = pattern.lower()
+    filename_lower = filename.lower()
+
+    # Exact substring match gets high score
+    if pattern_lower in filename_lower:
+        # Longer patterns that match are better
+        return 50.0 + (len(pattern) / len(filename)) * 50.0
+
+    # Fall back to Smith-Waterman for fuzzy matching
+    score, _ = _smith_waterman(pattern, filename, case_sensitive=False)
+    return score
+
+
+# ---------------------------------------------------------------------------
+# High-level API for search integration
+# ---------------------------------------------------------------------------
+
+
+class FuzzyMatcher:
+    """Fuzzy matcher for text search."""
+
+    def __init__(
+        self,
+        pattern: str,
+        *,
+        case_sensitive: bool = False,
+        min_score: float = _MIN_SCORE_THRESHOLD,
+    ) -> None:
+        self.pattern = pattern
+        self.case_sensitive = case_sensitive
+        self.min_score = min_score
+
+    def matches(self, text: str) -> bool:
+        """Check if text matches the pattern."""
+        match = fuzzy_match(
+            self.pattern,
+            text,
+            case_sensitive=self.case_sensitive,
+            min_score=self.min_score,
+        )
+        return match is not None
+
+    def get_score(self, text: str) -> float:
+        """Get the match score for text."""
+        match = fuzzy_match(
+            self.pattern,
+            text,
+            case_sensitive=self.case_sensitive,
+            min_score=0.0,  # Get score even if below threshold
+        )
+        return match.score if match else 0.0
+
+    def search(self, lines: Sequence[str]) -> list[FuzzyMatch]:
+        """Find all matching lines."""
+        return fuzzy_match_in_lines(
+            self.pattern,
+            lines,
+            case_sensitive=self.case_sensitive,
+            min_score=self.min_score,
+        )

attocode_intel/_internal/integrations/context/hierarchical_explorer.py

@@ -0,0 +1,331 @@
+"""Hierarchical BFS codebase explorer.
+
+Provides drill-down navigation through the repository, showing one
+directory level at a time with statistics and importance scoring.
+This avoids overwhelming the LLM context with a flat repo map on
+large codebases (1000+ files).
+"""
+
+from __future__ import annotations
+
+import os
+from collections import OrderedDict
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(slots=True)
+class DirectoryNode:
+    """A directory in the explorer view."""
+
+    name: str
+    path: str
+    file_count: int = 0
+    total_lines: int = 0
+    languages: dict[str, int] = field(default_factory=dict)
+    subdirs: int = 0
+
+
+@dataclass(slots=True)
+class FileNode:
+    """A file in the explorer view."""
+
+    name: str
+    path: str
+    relative_path: str
+    importance: float = 0.0
+    line_count: int = 0
+    language: str = ""
+    top_symbols: list[str] = field(default_factory=list)
+    tags: list[str] = field(default_factory=list)
+
+
+@dataclass(slots=True)
+class ExplorerResult:
+    """Result of exploring a directory."""
+
+    path: str
+    breadcrumbs: list[str]
+    total_files: int
+    total_lines: int
+    directories: list[DirectoryNode]
+    files: list[FileNode]
+    omitted_files: int = 0
+    omitted_dirs: int = 0
+
+
+class HierarchicalExplorer:
+    """Interactive BFS codebase explorer with drill-down navigation.
+
+    Exactly ONE directory level deep per call, with predictable
+    token cost (~500-2000 tokens per result).
+
+    Usage::
+
+        explorer = HierarchicalExplorer(codebase_context)
+
+        # Top-level overview
+        result = explorer.explore()
+
+        # Drill into a directory
+        result = explorer.explore("src/attocode/integrations")
+
+        # With filters
+        result = explorer.explore("src", max_items=50, importance_threshold=0.3)
+    """
+
+    def __init__(self, context_manager: Any, ast_service: Any = None) -> None:
+        self._ctx = context_manager
+        self._ast = ast_service
+        self._cache: OrderedDict[str, ExplorerResult] = OrderedDict()
+        self._max_cache = 100
+
+    def explore(
+        self,
+        path: str = "",
+        *,
+        max_items: int = 30,
+        importance_threshold: float = 0.3,
+        task_scores: dict[str, float] | None = None,
+    ) -> ExplorerResult:
+        """Explore one level of a directory.
+
+        Args:
+            path: Relative path to explore ("" for root).
+            max_items: Maximum items (dirs + files) to return.
+            importance_threshold: Minimum importance for files to be shown.
+
+        Returns:
+            ExplorerResult with dirs, files, and breadcrumbs.
+        """
+        cache_key = f"{path}|{max_items}|{importance_threshold}" if not task_scores else None
+        if cache_key is not None and cache_key in self._cache:
+            self._cache.move_to_end(cache_key)
+            return self._cache[cache_key]
+
+        self._ctx._ensure_fresh()
+        files = self._ctx._files
+
+        # Normalize path
+        path = path.strip("/").rstrip("/") if path else ""
+
+        # Filter files to those in this directory (direct children or descendants)
+        if path:
+            prefix = path + "/"
+            relevant = [f for f in files if f.relative_path.startswith(prefix)]
+        else:
+            relevant = list(files)
+
+        if not relevant and path:
+            # Try exact match (file, not directory)
+            exact = [f for f in files if f.relative_path == path]
+            if exact:
+                return self._file_detail(exact[0], path)
+
+        # Group into direct children (dirs and files at this level)
+        dir_stats: dict[str, _DirAccum] = {}
+        direct_files: list[Any] = []
+        _depth = path.count("/") + 1 if path else 0
+
+        for f in relevant:
+            rel = f.relative_path
+            child = rel[len(path) + 1:] if path else rel
+
+            parts = child.split("/")
+            if len(parts) == 1:
+                # Direct file child
+                direct_files.append(f)
+            else:
+                # In a subdirectory
+                subdir_name = parts[0]
+                subdir_path = f"{path}/{subdir_name}" if path else subdir_name
+                if subdir_path not in dir_stats:
+                    dir_stats[subdir_path] = _DirAccum(name=subdir_name, path=subdir_path)
+                acc = dir_stats[subdir_path]
+                acc.file_count += 1
+                acc.total_lines += f.line_count
+                if f.language:
+                    acc.languages[f.language] = acc.languages.get(f.language, 0) + 1
+                # Count unique immediate subdirectories within this subdir
+                if len(parts) > 2:
+                    acc.seen_subdirs.add(parts[1])
+
+        # Build directory nodes
+        directories: list[DirectoryNode] = []
+        for _sp, acc in sorted(dir_stats.items()):
+            directories.append(DirectoryNode(
+                name=acc.name,
+                path=acc.path,
+                file_count=acc.file_count,
+                total_lines=acc.total_lines,
+                languages=dict(acc.languages),
+                subdirs=len(acc.seen_subdirs),
+            ))
+        if task_scores:
+            directories.sort(key=lambda node: (
+                -max((score for file_path, score in task_scores.items()
+                      if file_path.startswith(node.path + "/")), default=0.0),
+                node.path,
+            ))
+
+        # Build file nodes (filtered by importance threshold)
+        file_nodes: list[FileNode] = []
+        for f in sorted(direct_files, key=lambda x: (
+            -(task_scores or {}).get(x.relative_path, 0.0), -x.importance, x.relative_path,
+        )):
+            if (f.importance < importance_threshold and len(file_nodes) >= 5
+                    and not (task_scores or {}).get(f.relative_path)):
+                break
+            tags: list[str] = []
+            if f.is_config:
+                tags.append("config")
+            if f.is_test:
+                tags.append("test")
+            name = os.path.basename(f.relative_path).lower()
+            if name in ("main.py", "main.ts", "app.py", "cli.py", "__init__.py",
+                         "index.ts", "index.js"):
+                tags.append("entry")
+
+            # Get top symbols if AST service is available
+            top_syms: list[str] = []
+            if self._ast and self._ast.initialized:
+                cached = self._ast._ast_cache.get(f.relative_path)
+                if cached:
+                    top_syms = cached.get_symbols()[:5]
+
+            file_nodes.append(FileNode(
+                name=os.path.basename(f.relative_path),
+                path=f.path,
+                relative_path=f.relative_path,
+                importance=round(f.importance, 2),
+                line_count=f.line_count,
+                language=f.language,
+                top_symbols=top_syms,
+                tags=tags,
+            ))
+
+        # Enforce max_items limit
+        total_items = len(directories) + len(file_nodes)
+        omitted_dir_count = 0
+        if total_items > max_items:
+            # Prioritize directories, then high-importance files
+            dir_budget = min(len(directories), max_items // 2)
+            file_budget = max_items - dir_budget
+            omitted_dir_count = max(0, len(directories) - dir_budget)
+            directories = directories[:dir_budget]
+            file_nodes = file_nodes[:file_budget]
+
+        omitted = len(direct_files) - len(file_nodes)
+
+        # Build breadcrumbs
+        breadcrumbs = ["(root)"]
+        if path:
+            parts = path.split("/")
+            for i in range(len(parts)):
+                breadcrumbs.append("/".join(parts[:i + 1]))
+
+        result = ExplorerResult(
+            path=path or "(root)",
+            breadcrumbs=breadcrumbs,
+            total_files=len(relevant),
+            total_lines=sum(f.line_count for f in relevant),
+            directories=directories,
+            files=file_nodes,
+            omitted_files=max(0, omitted),
+            omitted_dirs=omitted_dir_count,
+        )
+
+        # Cache with LRU eviction
+        if cache_key is not None:
+            self._cache[cache_key] = result
+            if len(self._cache) > self._max_cache:
+                self._cache.popitem(last=False)
+
+        return result
+
+    def _file_detail(self, file_info: Any, path: str) -> ExplorerResult:
+        """Return a single file as an explorer result."""
+        tags: list[str] = []
+        if file_info.is_config:
+            tags.append("config")
+        if file_info.is_test:
+            tags.append("test")
+        fn = FileNode(
+            name=os.path.basename(file_info.relative_path),
+            path=file_info.path,
+            relative_path=file_info.relative_path,
+            importance=round(file_info.importance, 2),
+            line_count=file_info.line_count,
+            language=file_info.language,
+            tags=tags,
+        )
+        return ExplorerResult(
+            path=path,
+            breadcrumbs=["(root)"] + path.split("/"),
+            total_files=1,
+            total_lines=file_info.line_count,
+            directories=[],
+            files=[fn],
+        )
+
+    def invalidate(self, path: str = "") -> None:
+        """Invalidate cached results for a path or all paths."""
+        if not path:
+            self._cache.clear()
+            return
+        keys_to_remove = [k for k in self._cache if k.startswith(path + "|") or k.startswith(path + "/")]
+        for k in keys_to_remove:
+            del self._cache[k]
+
+    def format_result(self, result: ExplorerResult) -> str:
+        """Format an ExplorerResult as a human-readable string."""
+        lines: list[str] = []
+
+        # Header
+        lines.append(f"{result.path} ({result.total_files} files, {result.total_lines:,} lines)")
+        lines.append(f"Breadcrumb: {' > '.join(result.breadcrumbs)}")
+        lines.append("")
+
+        # Directories
+        for d in result.directories:
+            lang_str = ""
+            if d.languages:
+                top_langs = sorted(d.languages.items(), key=lambda x: -x[1])[:3]
+                lang_str = f"  [{', '.join(line for line, _ in top_langs)}]"
+            lines.append(
+                f"  [dir] {d.name}/  "
+                f"{d.file_count} files  {d.total_lines:,} lines{lang_str}"
+            )
+
+        # Files
+        for f in result.files:
+            tags_str = f"  [{', '.join(f.tags)}]" if f.tags else ""
+            syms_str = ""
+            if f.top_symbols:
+                syms_str = f"  [{', '.join(f.top_symbols)}]"
+            lines.append(
+                f"  [file] {f.name}  "
+                f"{f.line_count}L  imp={f.importance}{tags_str}{syms_str}"
+            )
+
+        if result.omitted_files > 0 or result.omitted_dirs > 0:
+            parts = []
+            if result.omitted_files > 0:
+                parts.append(f"{result.omitted_files} more files")
+            if result.omitted_dirs > 0:
+                parts.append(f"{result.omitted_dirs} more directories")
+            lines.append(f"  ... +{', '.join(parts)}")
+
+        return "\n".join(lines)
+
+
+@dataclass(slots=True)
+class _DirAccum:
+    """Accumulator for directory statistics."""
+
+    name: str
+    path: str
+    file_count: int = 0
+    total_lines: int = 0
+    languages: dict[str, int] = field(default_factory=dict)
+    seen_subdirs: set[str] = field(default_factory=set)