Merge branch 'dvirdukhan/analyzer-import-override-edges' into dvirdukhan/mcp-nav-base

Author: DvirDukhan

api/analyzers/analyzer.py

@@ -58,7 +58,51 @@ def resolve(self, files: dict[Path, File], lsp: SyncLanguageServer, file_path: P
             return [(files[Path(self.resolve_path(location['absolutePath'], path))], files[Path(self.resolve_path(location['absolutePath'], path))].tree.root_node.descendant_for_point_range(Point(location['range']['start']['line'], location['range']['start']['character']), Point(location['range']['end']['line'], location['range']['end']['character']))) for location in locations if location and Path(self.resolve_path(location['absolutePath'], path)) in files]
         except Exception:
             return []
+
+    def needs_lsp(self) -> bool:
+        """Whether this analyzer needs an LSP server started in second_pass.
+
+        Defaults to True for backward compatibility with the original
+        jedi/multilspy-backed analyzers. Subclasses that resolve symbols
+        statically (e.g. the tree-sitter resolver in #689) override to
+        return False so the orchestrator can skip the expensive LSP
+        warm-up.
+        """
+        return True
 
+    def build_import_index(self, files: dict[Path, File], root: Path) -> object:
+        """
+        Build a language-specific index used to resolve import statements to
+        in-repo files. Returns an opaque structure consumed by
+        ``resolve_imports``. Default: no import resolution for this language.
+
+        Args:
+            files (dict[Path, File]): All parsed files keyed by absolute path.
+            root (Path): The analyzed repository root.
+
+        Returns:
+            object: Opaque index, or ``None`` when unsupported.
+        """
+
+        return None
+
+    def resolve_imports(self, file: File, root: Path, index: object) -> list[File]:
+        """
+        Resolve the import statements of ``file`` to the in-repo files they
+        depend on. Purely syntactic by default (no LSP). Each returned File is
+        connected to ``file`` with an ``IMPORTS`` edge by the orchestrator.
+
+        Args:
+            file (File): The importing file (already parsed; ``file.tree`` set).
+            root (Path): The analyzed repository root.
+            index (object): The structure returned by ``build_import_index``.
+
+        Returns:
+            list[File]: In-repo files imported by ``file`` (deduped, self excluded).
+        """
+
+        return []
+
     @abstractmethod
     def add_dependencies(self, path: Path, files: list[Path]):
         """

api/analyzers/javascript/analyzer.py

@@ -3,10 +3,8 @@
 from pathlib import Path
 from typing import Optional
 
-from multilspy import SyncLanguageServer
 from ...entities.entity import Entity
-from ...entities.file import File
-from ..analyzer import AbstractAnalyzer
+from ..tree_sitter_base import TreeSitterAnalyzer
 
 import tree_sitter_javascript as tsjs
 from tree_sitter import Language, Node
@@ -15,13 +13,28 @@
 logger = logging.getLogger('code_graph')
 
 
-class JavaScriptAnalyzer(AbstractAnalyzer):
+class JavaScriptAnalyzer(TreeSitterAnalyzer):
     """Analyzer for JavaScript source files using tree-sitter.
 
     Extracts functions, classes, and methods from JavaScript code.
     Resolves class inheritance (extends) and function/method call references.
     """
 
+    entity_node_types = {
+        'function_declaration': "Function",
+        'class_declaration': "Class",
+        'method_definition': "Method",
+    }
+    type_definition_node_types = ('class_declaration',)
+    callable_definition_node_types = (
+        'function_declaration',
+        'method_definition',
+        'class_declaration',
+    )
+    callable_exclude_node_types = ('class_declaration',)
+    type_resolution_keys = ("base_class",)
+    method_resolution_keys = ("call",)
+
     def __init__(self) -> None:
         """Initialize the JavaScript analyzer with the tree-sitter JS grammar."""
         super().__init__(Language(tsjs.language()))
@@ -33,26 +46,6 @@ def add_dependencies(self, path: Path, files: list[Path]) -> None:
         """
         pass
 
-    def get_entity_label(self, node: Node) -> str:
-        """Return the graph label for a given AST node type.
-
-        Args:
-            node: A tree-sitter AST node representing a JavaScript entity.
-
-        Returns:
-            One of 'Function', 'Class', or 'Method'.
-
-        Raises:
-            ValueError: If the node type is not a recognised entity.
-        """
-        if node.type == 'function_declaration':
-            return "Function"
-        elif node.type == 'class_declaration':
-            return "Class"
-        elif node.type == 'method_definition':
-            return "Method"
-        raise ValueError(f"Unknown entity type: {node.type}")
-
     def get_entity_name(self, node: Node) -> str:
         """Extract the declared name from a JavaScript entity node.
 
@@ -92,10 +85,6 @@ def get_entity_docstring(self, node: Node) -> Optional[str]:
             return None
         raise ValueError(f"Unknown entity type: {node.type}")
 
-    def get_entity_types(self) -> list[str]:
-        """Return the tree-sitter node types recognised as JavaScript entities."""
-        return ['function_declaration', 'class_declaration', 'method_definition']
-
     def add_symbols(self, entity: Entity) -> None:
         """Extract symbols (references) from a JavaScript entity.
 
@@ -128,45 +117,12 @@ def is_dependency(self, file_path: str) -> bool:
         """
         return "node_modules" in Path(file_path).parts
 
-    def resolve_path(self, file_path: str, path: Path) -> str:
-        """Resolve an import path relative to the project root."""
-        return file_path
-
-    def resolve_type(self, files: dict[Path, File], lsp: SyncLanguageServer, file_path: Path, path: Path, node: Node) -> list[Entity]:
-        """Resolve a type reference to its class declaration entity."""
-        res = []
-        for file, resolved_node in self.resolve(files, lsp, file_path, path, node):
-            type_dec = self.find_parent(resolved_node, ['class_declaration'])
-            if type_dec in file.entities:
-                res.append(file.entities[type_dec])
-        return res
-
-    def resolve_method(self, files: dict[Path, File], lsp: SyncLanguageServer, file_path: Path, path: Path, node: Node) -> list[Entity]:
-        """Resolve a call expression to the target function or method entity."""
-        res = []
+    def _extract_call_target(self, node: Node) -> Optional[Node]:
+        """Extract the callable target from a JavaScript call expression."""
         if node.type == 'call_expression':
             func_node = node.child_by_field_name('function')
             if func_node and func_node.type == 'member_expression':
                 func_node = func_node.child_by_field_name('property')
             if func_node:
                 node = func_node
-        for file, resolved_node in self.resolve(files, lsp, file_path, path, node):
-            method_dec = self.find_parent(resolved_node, ['function_declaration', 'method_definition', 'class_declaration'])
-            if method_dec and method_dec.type == 'class_declaration':
-                continue
-            if method_dec in file.entities:
-                res.append(file.entities[method_dec])
-        return res
-
-    def resolve_symbol(self, files: dict[Path, File], lsp: SyncLanguageServer, file_path: Path, path: Path, key: str, symbol: Node) -> list[Entity]:
-        """Dispatch symbol resolution based on the symbol category.
-
-        Routes ``base_class`` symbols to type resolution and ``call`` symbols
-        to method resolution.
-        """
-        if key == "base_class":
-            return self.resolve_type(files, lsp, file_path, path, symbol)
-        elif key == "call":
-            return self.resolve_method(files, lsp, file_path, path, symbol)
-        else:
-            raise ValueError(f"Unknown key {key}")
+        return node

api/analyzers/kotlin/analyzer.py

@@ -2,7 +2,7 @@
 from ...entities.entity import Entity
 from ...entities.file import File
 from typing import Optional
-from ..analyzer import AbstractAnalyzer
+from ..tree_sitter_base import TreeSitterAnalyzer
 
 from multilspy import SyncLanguageServer
 
@@ -12,7 +12,27 @@
 import logging
 logger = logging.getLogger('code_graph')
 
-class KotlinAnalyzer(AbstractAnalyzer):
+class KotlinAnalyzer(TreeSitterAnalyzer):
+    entity_node_types = {
+        'class_declaration': "Class",
+        'object_declaration': "Object",
+        'function_declaration': "Function",
+    }
+    type_definition_node_types = ('class_declaration', 'object_declaration')
+    callable_definition_node_types = (
+        'function_declaration',
+        'class_declaration',
+        'object_declaration',
+    )
+    callable_exclude_node_types = ('class_declaration', 'object_declaration')
+    type_resolution_keys = (
+        "implement_interface",
+        "base_class",
+        "parameters",
+        "return_type",
+    )
+    method_resolution_keys = ("call",)
+
     def __init__(self) -> None:
         super().__init__(Language(tskotlin.language()))
 
@@ -44,7 +64,7 @@ def get_entity_name(self, node: Node) -> str:
                 if child.type == 'identifier':
                     return child.text.decode('utf-8')
         raise ValueError(f"Cannot extract name from entity type: {node.type}")
-    
+
     def get_entity_docstring(self, node: Node) -> Optional[str]:
         if node.type in ['class_declaration', 'object_declaration', 'function_declaration']:
             # Check for KDoc comment (/** ... */) before the node
@@ -54,14 +74,11 @@ def get_entity_docstring(self, node: Node) -> Optional[str]:
                 if comment_text.startswith('/**'):
                     return comment_text
             return None
-        raise ValueError(f"Unknown entity type: {node.type}")        
+        raise ValueError(f"Unknown entity type: {node.type}")
 
-    def get_entity_types(self) -> list[str]:
-        return ['class_declaration', 'object_declaration', 'function_declaration']
-    
     def _get_delegation_types(self, entity: Entity) -> list[tuple]:
         """Extract type identifiers from delegation specifiers in order.
-        
+
         Returns list of (node, is_constructor_invocation) tuples.
         constructor_invocation indicates a superclass; plain user_type indicates an interface.
         """
@@ -91,25 +108,25 @@ def add_symbols(self, entity: Entity) -> None:
                     entity.add_symbol("base_class", node)
                 else:
                     entity.add_symbol("implement_interface", node)
-                    
+
         elif entity.node.type == 'object_declaration':
             types = self._get_delegation_types(entity)
             for node, _ in types:
                 entity.add_symbol("implement_interface", node)
-                    
+
         elif entity.node.type == 'function_declaration':
             # Find function calls
             captures = self._captures("(call_expression) @reference.call", entity.node)
             if 'reference.call' in captures:
                 for caller in captures['reference.call']:
                     entity.add_symbol("call", caller)
-            
+
             # Find parameters with types
             captures = self._captures("(parameter (user_type (identifier) @parameter))", entity.node)
             if 'parameter' in captures:
                 for parameter in captures['parameter']:
                     entity.add_symbol("parameters", parameter)
-            
+
             # Find return type
             captures = self._captures("(function_declaration (user_type (identifier) @return_type))", entity.node)
             if 'return_type' in captures:
@@ -120,18 +137,6 @@ def is_dependency(self, file_path: str) -> bool:
         # Check if file is in a dependency directory (e.g., build, .gradle cache)
         return "build/" in file_path or ".gradle/" in file_path or "/cache/" in file_path
 
-    def resolve_path(self, file_path: str, path: Path) -> str:
-        # For Kotlin, just return the file path as-is for now
-        return file_path
-
-    def resolve_type(self, files: dict[Path, File], lsp: SyncLanguageServer, file_path: Path, path: Path, node: Node) -> list[Entity]:
-        res = []
-        for file, resolved_node in self.resolve(files, lsp, file_path, path, node):
-            type_dec = self.find_parent(resolved_node, ['class_declaration', 'object_declaration'])
-            if type_dec in file.entities:
-                res.append(file.entities[type_dec])
-        return res
-
     def resolve_method(self, files: dict[Path, File], lsp: SyncLanguageServer, file_path: Path, path: Path, node: Node) -> list[Entity]:
         res = []
         # For call expressions, we need to extract the function name
@@ -147,11 +152,3 @@ def resolve_method(self, files: dict[Path, File], lsp: SyncLanguageServer, file_
                             res.append(file.entities[method_dec])
                     break
         return res
-    
-    def resolve_symbol(self, files: dict[Path, File], lsp: SyncLanguageServer, file_path: Path, path: Path, key: str, symbol: Node) -> list[Entity]:
-        if key in ["implement_interface", "base_class", "parameters", "return_type"]:
-            return self.resolve_type(files, lsp, file_path, path, symbol)
-        elif key in ["call"]:
-            return self.resolve_method(files, lsp, file_path, path, symbol)
-        else:
-            raise ValueError(f"Unknown key {key}")