Class CodeFinder

src/codegraphcontext/tools/code_finder.py:41–1216

Module for finding relevant code snippets and analyzing relationships.

    return s.lower().replace('_', '').replace(' ', '')

class CodeFinder:
    """Module for finding relevant code snippets and analyzing relationships."""

    def __init__(self, db_manager: DatabaseManager):
        self.db_manager = db_manager
        self.driver = self.db_manager.get_driver()
        self._lacks_native_fulltext = getattr(db_manager, 'get_backend_type', lambda: 'neo4j')() != 'neo4j'

    def format_query(self, find_by: Literal["Class", "Function"], fuzzy_search:bool, repo_path: Optional[str] = None) -> str:
        """Format the search query based on the search type and fuzzy search settings."""
        repo_filter = "AND node.path STARTS WITH $repo_path" if repo_path else ""
        if self._lacks_native_fulltext:
            # FalkorDB does not support CALL db.idx.fulltext.queryNodes.
            # Fall back to a pure Cypher CONTAINS/toLower match on node name.
            name_filter = "toLower(node.name) CONTAINS toLower($search_term)"
            return f"""
                MATCH (node:{find_by})
                WHERE {name_filter} {repo_filter}
                RETURN node.name as name, node.path as path, node.line_number as line_number,
                    node.source as source, node.docstring as docstring, node.is_dependency as is_dependency
                ORDER BY node.is_dependency ASC, node.name
                LIMIT 20
            """
        return f"""
            CALL db.index.fulltext.queryNodes("code_search_index", $search_term) YIELD node, score
                WITH node, score
                WHERE node:{find_by} {'AND node.name CONTAINS $search_term' if not fuzzy_search else ''} {repo_filter}
                RETURN node.name as name, node.path as path, node.line_number as line_number,
                    node.source as source, node.docstring as docstring, node.is_dependency as is_dependency
                ORDER BY score DESC
                LIMIT 20
            """

    def _find_by_name_fuzzy_portable(
        self,
        label: Literal["Function", "Class"],
        search_term: str,
        edit_distance: int,
        repo_path: Optional[str],
    ) -> List[Dict]:
        """Fuzzy name match for backends without Lucene fuzzy syntax (Kùzu, FalkorDB, …).

        Compares both the raw query and its identifier-normalised form against each
        candidate name, taking the minimum distance.  This lets camelCase queries
        match snake_case stored names and vice-versa without inflating the distance.
        """
        if not search_term.strip():
            return []
        where_clause = "WHERE node.path STARTS WITH $repo_path" if repo_path else ""
        # Without a repo filter we must cap the candidate scan.  20 000 is enough to
        # cover any realistic single-repo codebase while keeping latency acceptable.
        limit_tail = "" if repo_path else " LIMIT 20000"
        params: Dict[str, Any] = {}
        if repo_path:
            params["repo_path"] = repo_path
        query = f"""
            MATCH (node:{label})
            {where_clause}