Class CodeFinder

src/codegraphcontext/tools/code_finder.py:144–1414

Module for finding relevant code snippets and analyzing relationships.

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 audit_kotlin_call_ambiguity(
        self,
        repo_path: Optional[str] = None,
        limit: int = 20,
    ) -> Dict[str, Any]:
        """Audit Kotlin function-to-function CALLS edges for multi-target callsites."""
        repo_path = Path(repo_path).resolve().as_posix() if repo_path else None
        repo_filter = "AND a.path STARTS WITH $repo_path" if repo_path else ""
        query = f"""
            MATCH (a:Function)-[r:CALLS]->(b:Function)
            WHERE a.path ENDS WITH '.kt'
              AND b.path ENDS WITH '.kt'
              {repo_filter}
            RETURN a.name as caller_name,
                   a.path as caller_path,
                   a.line_number as caller_line,
                   a.end_line as caller_end_line,
                   r.line_number as call_line,
                   r.full_call_name as full_call_name,
                   b.name as target_name,
                   b.path as target_path,
                   b.line_number as target_line,
                   b.context as target_context,
                   r.args as args
        """
        with self.driver.session() as session:
            rows = session.run(query, repo_path=repo_path).data()
        return summarize_kotlin_call_ambiguity(rows, limit=limit)

    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