Merge origin/staging into bench-combined; resolve conflicts

Conflict resolution (8 files):
- api/llm.py -> OURS (bench): keep the graphrag-sdk 1.x text-to-Cypher
  rewrite. Required for consistency with the merged pyproject pin
  (graphrag-sdk>=1.1.1); staging's llm.py still imports KnowledgeGraph,
  which 1.x removed, so taking staging would ImportError at load.
- api/analyzers/source_analyzer.py, analyzer.py, python/ts_resolver.py,
  api/mcp/tools/structural.py -> STAGING: canonical/superset versions
  (parallel index workers + missing-file guard, refined logging,
  per-match capture alignment + threading lock, impact_analysis limit).
- tests/analyzers/test_ts_python_resolver.py,
  tests/mcp/fixtures/expected.yaml, tests/mcp/test_impact_analysis.py
  -> STAGING: refined fixtures and added regression tests.

Align MCP surface to staging (drop the deliberately-removed `ask` tool):
- Revert api/mcp/tools/__init__.py to structural-only registration.
- Delete api/mcp/tools/ask.py, api/mcp/graphrag_init.py,
  api/mcp/code_prompts.py and their tests. The ask tool was dropped from
  staging via #702 and is broken under graphrag-sdk 1.x (needs the 0.8
  KnowledgeGraph API and api.llm.define_ontology, both gone in the
  bench rewrite).

Tests: tests/mcp + tests/analyzers (79) and bench/swebench suites pass
(bench_runner needs the mini-swe-agent extra, installed in CI).

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

Author: DvirDukhan

.github/workflows/release-image.yml

@@ -23,7 +23,7 @@ jobs:
           fi
 
       - name: Login to DockerHub
-        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4
+        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}

api/analyzers/analyzer.py

@@ -64,12 +64,13 @@ def resolve_path(self, file_path: str, path: Path) -> str:
     def resolve(self, files: dict[Path, File], lsp: SyncLanguageServer, file_path: Path, path: Path, node: Node) -> list[tuple[File, Node]]:
         try:
             locations = lsp.request_definition(str(file_path), node.start_point.row, node.start_point.column)
-            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 as e:
+            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:
             import logging
             logging.getLogger(__name__).warning(
-                "resolve() failed for %s @%d:%d: %s",
-                file_path, node.start_point.row, node.start_point.column, e,
+                "resolve() failed for %s @%d:%d",
+                file_path, node.start_point.row, node.start_point.column,
+                exc_info=True,
             )
             return []
 
@@ -84,6 +85,39 @@ def needs_lsp(self) -> bool:
         """
         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/java/analyzer.py

@@ -23,7 +23,13 @@ def add_dependencies(self, path: Path, files: list[Path]):
         # if not Path("java-decompiler-engine-243.23654.153.jar").is_file():
         #     subprocess.run(["wget", "https://www.jetbrains.com/intellij-repository/releases/com/jetbrains/intellij/java/java-decompiler-engine/243.23654.153/java-decompiler-engine-243.23654.153.jar"])
         subprocess.run(["rm", "-rf", f"{path}/temp_deps"])
-        pom = ElementTree.parse(str(path) + '/pom.xml')
+        pom_path = Path(path) / 'pom.xml'
+        if not pom_path.is_file():
+            # Non-Maven Java sources (e.g. Gradle, or polyglot repos with stray
+            # .java files): no pom.xml means no Maven dependencies to resolve.
+            logger.info("no pom.xml at %s; skipping Maven dependency resolution", path)
+            return
+        pom = ElementTree.parse(str(pom_path))
         for dependency in pom.findall('.//{http://maven.apache.org/POM/4.0.0}dependency'):
             groupId = dependency.find('{http://maven.apache.org/POM/4.0.0}groupId').text.replace('.', '/')
             artifactId = dependency.find('{http://maven.apache.org/POM/4.0.0}artifactId').text

api/analyzers/python/analyzer.py

@@ -136,6 +136,116 @@ def add_symbols(self, entity: Entity) -> None:
     def is_dependency(self, file_path: str) -> bool:
         return "venv" in file_path
 
+    def _module_parts(self, file_path: Path, root: Path) -> Optional[list[str]]:
+        """Dotted module path components for ``file_path`` relative to ``root``."""
+        try:
+            rel = file_path.relative_to(root)
+        except ValueError:
+            return None
+        parts = list(rel.with_suffix('').parts)
+        if parts and parts[-1] == '__init__':
+            parts = parts[:-1]
+        return parts
+
+    def build_import_index(self, files: dict[Path, File], root: Path) -> object:
+        """Index in-repo files by dotted module name.
+
+        Two maps: ``exact`` keyed by the full dotted path from ``root`` and
+        ``suffix`` keyed by every trailing sub-path (first file wins). The
+        suffix map tolerates ``src/``/``lib/`` layouts where the import name
+        (``matplotlib.axes``) differs from the path-from-root
+        (``lib.matplotlib.axes``).
+
+        Only Python files are indexed; ``files`` carries every analyzed
+        source file, and a Python ``import pkg.mod`` must not resolve to a
+        same-named non-Python file such as ``pkg/mod.java``.
+        """
+        exact: dict[str, File] = {}
+        suffix: dict[str, File] = {}
+        for fpath, file in files.items():
+            if fpath.suffix != '.py':
+                continue
+            if self.is_dependency(str(fpath)):
+                continue
+            parts = self._module_parts(fpath, root)
+            if not parts:
+                continue
+            exact.setdefault('.'.join(parts), file)
+            for i in range(len(parts)):
+                suffix.setdefault('.'.join(parts[i:]), file)
+        return {'exact': exact, 'suffix': suffix}
+
+    def _resolve_dotted(self, dotted: str, index: dict) -> Optional[File]:
+        if not dotted:
+            return None
+        f = index['exact'].get(dotted) or index['suffix'].get(dotted)
+        if f is None and '.' in dotted:
+            # imported name may be a symbol inside a module; drop the last part.
+            parent = dotted.rsplit('.', 1)[0]
+            f = index['exact'].get(parent) or index['suffix'].get(parent)
+        return f
+
+    def _import_requests(self, file: File) -> list[tuple[str, int]]:
+        """Extract (dotted, level) resolution requests from import statements."""
+        requests: list[tuple[str, int]] = []
+        captures = self._captures(
+            "(import_statement) @i (import_from_statement) @f",
+            file.tree.root_node,
+        )
+        for node in captures.get('i', []):
+            for child in node.named_children:
+                target = child
+                if child.type == 'aliased_import':
+                    target = child.child_by_field_name('name')
+                if target is not None and target.type == 'dotted_name':
+                    requests.append((target.text.decode('utf-8'), 0))
+        for node in captures.get('f', []):
+            module = node.child_by_field_name('module_name')
+            level = 0
+            base = ''
+            if module is not None:
+                if module.type == 'relative_import':
+                    prefix = next((c for c in module.children if c.type == 'import_prefix'), None)
+                    level = len(prefix.text.decode('utf-8')) if prefix is not None else 1
+                    dotted_part = next((c for c in module.named_children if c.type == 'dotted_name'), None)
+                    base = dotted_part.text.decode('utf-8') if dotted_part is not None else ''
+                else:
+                    base = module.text.decode('utf-8')
+            requests.append((base, level))
+            for name_node in node.children_by_field_name('name'):
+                leaf = name_node
+                if name_node.type == 'aliased_import':
+                    leaf = name_node.child_by_field_name('name')
+                if leaf is not None:
+                    name_txt = leaf.text.decode('utf-8')
+                    requests.append((f"{base}.{name_txt}" if base else name_txt, level))
+        return requests
+
+    def resolve_imports(self, file: File, root: Path, index: object) -> list[File]:
+        if not index:
+            return []
+        package_parts = self._module_parts(file.path, root)
+        if package_parts is None:
+            return []
+        # Package of the importing file = its parent dotted path.
+        package_parts = package_parts[:-1] if package_parts else []
+        seen: set[Path] = set()
+        targets: list[File] = []
+        for dotted, level in self._import_requests(file):
+            if level:
+                base = package_parts[: len(package_parts) - (level - 1)] if level > 1 else list(package_parts)
+                full = '.'.join([*base, dotted]) if dotted else '.'.join(base)
+            else:
+                full = dotted
+            resolved = self._resolve_dotted(full, index)
+            if resolved is None or resolved.path == file.path or resolved.path in seen:
+                continue
+            if self.is_dependency(str(resolved.path)):
+                continue
+            seen.add(resolved.path)
+            targets.append(resolved)
+        return targets
+
     def _extract_type_target(self, node: Node) -> Optional[Node]:
         if node.type == 'attribute':
             return node.child_by_field_name('attribute')