feat(analyzers): tree-sitter Python symbol resolver (T18 #689)

Replace jedi-based resolution with a pure tree-sitter static resolver
behind CODE_GRAPH_PY_RESOLVER=tree_sitter. Default remains jedi for
backwards compatibility.

Benchmark on pytest-dev/pytest-6202 (204 files):
  - jedi:        247.1s wall, CALLS=1976, EXTENDS=71
  - tree-sitter:   6.9s wall, CALLS=4833, EXTENDS=83
  ~36x speedup, broader call recall (jedi returns None ~80% of the time).

Mechanism:
  - TreeSitterPythonResolver builds a project-wide symbol table
    (top-level funcs/classes/assigns, class methods, import maps)
    keyed by id(files) for lazy construction.
  - Resolution: head lookup (local module -> import map ->
    cross-project bare-name fallback) + tail walk through attributes
    and class methods.
  - Handles relative imports, aliased imports, import-of-package,
    Optional[T]/generic_type subscript unwrapping.
  - AbstractAnalyzer.needs_lsp() hook + PythonAnalyzer override let
    source_analyzer skip LSP startup and venv setup entirely when
    the static resolver is active. This is where the wall-time win
    actually lives (jedi warm-up was ~240s of the 247s baseline).

Closes #689.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: DvirDukhan

api/analyzers/analyzer.py

@@ -58,6 +58,17 @@ 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
 
     @abstractmethod
     def add_dependencies(self, path: Path, files: list[Path]):

api/analyzers/python/analyzer.py

@@ -5,15 +5,24 @@
 import tomllib
 from typing import Optional
 
+from multilspy import SyncLanguageServer
+
 from ...entities.entity import Entity
+from ...entities.file import File
 from ..tree_sitter_base import TreeSitterAnalyzer
+from .ts_resolver import TreeSitterPythonResolver
 
 import tree_sitter_python as tspython
 from tree_sitter import Language, Node
 
 import logging
 logger = logging.getLogger('code_graph')
 
+
+_RESOLVER_ENV = "CODE_GRAPH_PY_RESOLVER"
+_RESOLVER_TREE_SITTER = "tree_sitter"
+
+
 class PythonAnalyzer(TreeSitterAnalyzer):
     entity_node_types = {
         'class_definition': "Class",
@@ -26,8 +35,48 @@ class PythonAnalyzer(TreeSitterAnalyzer):
 
     def __init__(self) -> None:
         super().__init__(Language(tspython.language()))
+        # Resolver selection: 'tree_sitter' opts into the static project-wide
+        # resolver (issue #689). Default is the historical jedi/LSP path so
+        # behaviour is unchanged until explicitly enabled.
+        resolver_choice = os.environ.get(_RESOLVER_ENV, "").strip().lower()
+        if resolver_choice == _RESOLVER_TREE_SITTER:
+            self._ts_resolver: Optional[TreeSitterPythonResolver] = (
+                TreeSitterPythonResolver(self.language)
+            )
+            logger.info("PythonAnalyzer: tree-sitter static resolver enabled")
+        else:
+            self._ts_resolver = None
+
+    def resolve(
+        self,
+        files: dict[Path, File],
+        lsp: SyncLanguageServer,
+        file_path: Path,
+        path: Path,
+        node: Node,
+    ) -> list[tuple[File, Node]]:
+        """Resolve a name node to ``(File, def_node)`` pairs.
+
+        When ``CODE_GRAPH_PY_RESOLVER=tree_sitter`` is set, bypass the LSP
+        and use the project-wide static resolver. Otherwise fall through to
+        the default jedi-backed implementation in ``AbstractAnalyzer``.
+        """
+        if self._ts_resolver is not None:
+            return self._ts_resolver.resolve(files, file_path, path, node)
+        return super().resolve(files, lsp, file_path, path, node)
+
+    def needs_lsp(self) -> bool:
+        # When the tree-sitter resolver is active we don't touch the LSP, so
+        # the orchestrator can skip starting one.
+        return self._ts_resolver is None
 
     def add_dependencies(self, path: Path, files: list[Path]):
+        # When the tree-sitter resolver is active, we resolve statically
+        # against the in-project files only — installing the project's
+        # transitive Python deps just to feed jedi adds 10s–10min of
+        # zero-value pip work. Short-circuit it.
+        if self._ts_resolver is not None:
+            return
         if Path(f"{path}/venv").is_dir():
             return
         subprocess.run(["python3", "-m", "venv", "venv"], cwd=str(path))