sourcecode 0.2.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

sourcecode/graph_analyzer.py

@@ -0,0 +1,759 @@
+"""Analisis estructural offline para modulos, imports y relaciones simples."""
+from __future__ import annotations
+
+import ast
+import re
+from dataclasses import replace
+from pathlib import Path, PurePosixPath
+from typing import Any, Optional
+
+from sourcecode.schema import GraphEdge, GraphNode, ModuleGraph, ModuleGraphSummary
+from sourcecode.tree_utils import flatten_file_tree
+
+
+class GraphAnalyzer:
+    """Construye un grafo estructural parcial y seguro del proyecto."""
+
+    _PYTHON_EXTENSIONS = {".py"}
+    _NODE_EXTENSIONS = {".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"}
+    _GO_EXTENSIONS = {".go"}
+    _JVM_EXTENSIONS = {".java", ".kt", ".scala"}
+    _SUPPORTED_EXTENSIONS = _PYTHON_EXTENSIONS | _NODE_EXTENSIONS | _GO_EXTENSIONS | _JVM_EXTENSIONS
+
+    def __init__(
+        self,
+        *,
+        max_files: int = 200,
+        max_file_size: int = 200_000,
+        max_nodes: int = 1_000,
+        max_edges: int = 2_000,
+    ) -> None:
+        self.max_files = max_files
+        self.max_file_size = max_file_size
+        self.max_nodes = max_nodes
+        self.max_edges = max_edges
+
+    def analyze(
+        self,
+        root: Path,
+        file_tree: dict[str, Any],
+        *,
+        workspace: str | None = None,
+    ) -> ModuleGraph:
+        source_files = [
+            path
+            for path in flatten_file_tree(file_tree)
+            if Path(path).suffix in self._SUPPORTED_EXTENSIONS and (root / path).is_file()
+        ]
+        limitations: list[str] = []
+        if len(source_files) > self.max_files:
+            limitations.append(
+                f"max_files_reached:{len(source_files)}>{self.max_files}"
+            )
+            source_files = source_files[: self.max_files]
+
+        nodes: list[GraphNode] = []
+        edges: list[GraphEdge] = []
+        node_ids: set[str] = set()
+        edge_keys: set[tuple[str, str, str, str]] = set()
+
+        python_modules = self._build_python_module_map(source_files)
+        node_modules = {path: path for path in source_files if Path(path).suffix in self._NODE_EXTENSIONS}
+        go_imports = self._build_go_import_map(root, source_files)
+        jvm_types = self._build_jvm_type_map(root, source_files)
+
+        for relative_path in source_files:
+            absolute_path = root / relative_path
+            try:
+                if absolute_path.stat().st_size > self.max_file_size:
+                    limitations.append(f"file_too_large:{relative_path}")
+                    continue
+                content = absolute_path.read_text(encoding="utf-8", errors="replace")
+            except OSError:
+                limitations.append(f"read_error:{relative_path}")
+                continue
+
+            suffix = absolute_path.suffix
+            module_node = GraphNode(
+                id=f"module:{relative_path}",
+                kind="module",
+                language=self._language_for_suffix(suffix),
+                path=relative_path,
+                display_name=relative_path,
+                workspace=workspace,
+            )
+            self._append_node(nodes, node_ids, module_node)
+
+            file_nodes: list[GraphNode] = []
+            file_edges: list[GraphEdge] = []
+            file_limitations: list[str] = []
+
+            if suffix in self._PYTHON_EXTENSIONS:
+                file_nodes, file_edges, file_limitations = self._analyze_python_file(
+                    relative_path, content, python_modules, workspace
+                )
+            elif suffix in self._NODE_EXTENSIONS:
+                file_nodes, file_edges, file_limitations = self._analyze_node_file(
+                    relative_path, content, node_modules, workspace
+                )
+            elif suffix in self._GO_EXTENSIONS:
+                file_nodes, file_edges, file_limitations = self._analyze_go_file(
+                    relative_path, content, go_imports, workspace
+                )
+            elif suffix in self._JVM_EXTENSIONS:
+                file_nodes, file_edges, file_limitations = self._analyze_jvm_file(
+                    relative_path, content, jvm_types, workspace
+                )
+
+            limitations.extend(file_limitations)
+            for node in file_nodes:
+                self._append_node(nodes, node_ids, node)
+            for edge in file_edges:
+                self._append_edge(edges, edge_keys, edge)
+            if len(nodes) >= self.max_nodes or len(edges) >= self.max_edges:
+                limitations.append("graph_budget_reached")
+                break
+
+        if len(nodes) > self.max_nodes:
+            nodes = nodes[: self.max_nodes]
+        if len(edges) > self.max_edges:
+            edges = edges[: self.max_edges]
+
+        summary = ModuleGraphSummary(
+            requested=True,
+            node_count=len(nodes),
+            edge_count=len(edges),
+            languages=sorted({node.language for node in nodes}),
+            methods=sorted({edge.method for edge in edges}),
+            limitations=self._unique(limitations),
+        )
+        return ModuleGraph(nodes=nodes, edges=edges, summary=summary)
+
+    def merge_graphs(self, graphs: list[ModuleGraph]) -> ModuleGraph:
+        nodes: list[GraphNode] = []
+        edges: list[GraphEdge] = []
+        limitations: list[str] = []
+        node_ids: set[str] = set()
+        edge_keys: set[tuple[str, str, str, str]] = set()
+        for graph in graphs:
+            for node in graph.nodes:
+                self._append_node(nodes, node_ids, node)
+            for edge in graph.edges:
+                self._append_edge(edges, edge_keys, edge)
+            limitations.extend(graph.summary.limitations)
+        return ModuleGraph(
+            nodes=nodes,
+            edges=edges,
+            summary=ModuleGraphSummary(
+                requested=bool(graphs),
+                node_count=len(nodes),
+                edge_count=len(edges),
+                languages=sorted({node.language for node in nodes}),
+                methods=sorted({edge.method for edge in edges}),
+                limitations=self._unique(limitations),
+            ),
+        )
+
+    def prefix_graph(self, graph: ModuleGraph, prefix: str, workspace: str) -> ModuleGraph:
+        """Reescribe ids y paths de un grafo de workspace al espacio de paths del repo."""
+        node_id_map: dict[str, str] = {}
+        prefixed_nodes: list[GraphNode] = []
+        clean_prefix = prefix.strip("/")
+        for node in graph.nodes:
+            prefixed_path = f"{clean_prefix}/{node.path}".strip("/")
+            new_id = self._node_id(node.kind, prefixed_path, node.symbol)
+            node_id_map[node.id] = new_id
+            prefixed_nodes.append(
+                replace(
+                    node,
+                    id=new_id,
+                    path=prefixed_path,
+                    workspace=workspace,
+                )
+            )
+        prefixed_edges: list[GraphEdge] = []
+        for edge in graph.edges:
+            prefixed_edges.append(
+                replace(
+                    edge,
+                    source=node_id_map.get(edge.source, edge.source),
+                    target=node_id_map.get(edge.target, edge.target),
+                )
+            )
+        return ModuleGraph(
+            nodes=prefixed_nodes,
+            edges=prefixed_edges,
+            summary=replace(graph.summary),
+        )
+
+    def _analyze_python_file(
+        self,
+        relative_path: str,
+        content: str,
+        module_map: dict[str, str],
+        workspace: str | None,
+    ) -> tuple[list[GraphNode], list[GraphEdge], list[str]]:
+        limitations: list[str] = []
+        try:
+            tree = ast.parse(content, filename=relative_path)
+        except SyntaxError:
+            return [], [], [f"python_parse_error:{relative_path}"]
+
+        module_node_id = f"module:{relative_path}"
+        current_module = module_map.get(relative_path)
+        nodes: list[GraphNode] = []
+        edges: list[GraphEdge] = []
+        function_node_ids: dict[str, str] = {}
+        class_node_ids: dict[str, str] = {}
+        imported_function_node_ids: dict[str, str] = {}
+        imported_class_node_ids: dict[str, str] = {}
+
+        for node in tree.body:
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                function_node_id = f"function:{relative_path}:{node.name}"
+                function_node_ids[node.name] = function_node_id
+                nodes.append(
+                    GraphNode(
+                        id=function_node_id,
+                        kind="function",
+                        language="python",
+                        path=relative_path,
+                        symbol=node.name,
+                        display_name=node.name,
+                        workspace=workspace,
+                    )
+                )
+                edges.append(
+                    GraphEdge(
+                        source=module_node_id,
+                        target=function_node_id,
+                        kind="contains",
+                        confidence="high",
+                        method="ast",
+                    )
+                )
+            elif isinstance(node, ast.ClassDef):
+                class_node_id = f"class:{relative_path}:{node.name}"
+                class_node_ids[node.name] = class_node_id
+                nodes.append(
+                    GraphNode(
+                        id=class_node_id,
+                        kind="class",
+                        language="python",
+                        path=relative_path,
+                        symbol=node.name,
+                        display_name=node.name,
+                        workspace=workspace,
+                    )
+                )
+                edges.append(
+                    GraphEdge(
+                        source=module_node_id,
+                        target=class_node_id,
+                        kind="contains",
+                        confidence="high",
+                        method="ast",
+                    )
+                )
+
+        for ast_node in ast.walk(tree):
+            if isinstance(ast_node, ast.Import):
+                for alias in ast_node.names:
+                    target_path = self._resolve_python_import(alias.name, module_map)
+                    if target_path is None:
+                        continue
+                    edges.append(
+                        GraphEdge(
+                            source=module_node_id,
+                            target=f"module:{target_path}",
+                            kind="imports",
+                            confidence="high",
+                            method="ast",
+                        )
+                    )
+            elif isinstance(ast_node, ast.ImportFrom):
+                target_path = self._resolve_python_from_import(
+                    ast_node, current_module, module_map
+                )
+                if target_path is None:
+                    continue
+                edges.append(
+                    GraphEdge(
+                        source=module_node_id,
+                        target=f"module:{target_path}",
+                        kind="imports",
+                        confidence="high",
+                        method="ast",
+                    )
+                )
+                for alias in ast_node.names:
+                    local_name = alias.asname or alias.name
+                    imported_function_node_ids[local_name] = (
+                        f"function:{target_path}:{alias.name}"
+                    )
+                    imported_class_node_ids[local_name] = (
+                        f"class:{target_path}:{alias.name}"
+                    )
+
+        for top_level in tree.body:
+            if isinstance(top_level, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                source_id = function_node_ids.get(top_level.name)
+                if source_id is None:
+                    continue
+                for nested in ast.walk(top_level):
+                    if isinstance(nested, ast.Call) and isinstance(nested.func, ast.Name):
+                        target_id = function_node_ids.get(nested.func.id) or imported_function_node_ids.get(
+                            nested.func.id
+                        )
+                        if target_id is not None and target_id != source_id:
+                            edges.append(
+                                GraphEdge(
+                                    source=source_id,
+                                    target=target_id,
+                                    kind="calls",
+                                    confidence="medium",
+                                    method="ast",
+                                )
+                            )
+            elif isinstance(top_level, ast.ClassDef):
+                source_id = class_node_ids.get(top_level.name)
+                if source_id is None:
+                    continue
+                for base in top_level.bases:
+                    if isinstance(base, ast.Name):
+                        target_id = class_node_ids.get(base.id) or imported_class_node_ids.get(
+                            base.id
+                        )
+                        if target_id is not None:
+                            edges.append(
+                                GraphEdge(
+                                    source=source_id,
+                                    target=target_id,
+                                    kind="extends",
+                                    confidence="medium",
+                                    method="ast",
+                                )
+                            )
+        return nodes, edges, limitations
+
+    def _analyze_node_file(
+        self,
+        relative_path: str,
+        content: str,
+        module_map: dict[str, str],
+        workspace: str | None,
+    ) -> tuple[list[GraphNode], list[GraphEdge], list[str]]:
+        module_node_id = f"module:{relative_path}"
+        nodes: list[GraphNode] = []
+        edges: list[GraphEdge] = []
+        limitations: list[str] = []
+
+        function_pattern = re.compile(
+            r"^\s*(?:export\s+)?function\s+([A-Za-z_][A-Za-z0-9_]*)",
+            re.MULTILINE,
+        )
+        class_pattern = re.compile(
+            r"^\s*(?:export\s+)?class\s+([A-Za-z_][A-Za-z0-9_]*)(?:\s+extends\s+([A-Za-z_][A-Za-z0-9_]*))?",
+            re.MULTILINE,
+        )
+        function_node_ids: dict[str, str] = {}
+        class_node_ids: dict[str, str] = {}
+
+        for match in function_pattern.finditer(content):
+            name = match.group(1)
+            node_id = f"function:{relative_path}:{name}"
+            function_node_ids[name] = node_id
+            nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind="function",
+                    language="nodejs",
+                    path=relative_path,
+                    symbol=name,
+                    display_name=name,
+                    workspace=workspace,
+                )
+            )
+            edges.append(
+                GraphEdge(
+                    source=module_node_id,
+                    target=node_id,
+                    kind="contains",
+                    confidence="medium",
+                    method="heuristic",
+                )
+            )
+
+        for match in class_pattern.finditer(content):
+            name = match.group(1)
+            base = match.group(2)
+            node_id = f"class:{relative_path}:{name}"
+            class_node_ids[name] = node_id
+            nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind="class",
+                    language="nodejs",
+                    path=relative_path,
+                    symbol=name,
+                    display_name=name,
+                    workspace=workspace,
+                )
+            )
+            edges.append(
+                GraphEdge(
+                    source=module_node_id,
+                    target=node_id,
+                    kind="contains",
+                    confidence="medium",
+                    method="heuristic",
+                )
+            )
+            if base and base in class_node_ids:
+                edges.append(
+                    GraphEdge(
+                        source=node_id,
+                        target=class_node_ids[base],
+                        kind="extends",
+                        confidence="low",
+                        method="heuristic",
+                    )
+                )
+
+        patterns = [
+            re.compile(r"""import\s+(?:[^'"]+?\s+from\s+)?['"]([^'"]+)['"]"""),
+            re.compile(r"""require\(\s*['"]([^'"]+)['"]\s*\)"""),
+        ]
+        found_specs: set[str] = set()
+        for pattern in patterns:
+            for match in pattern.finditer(content):
+                spec = match.group(1)
+                if spec in found_specs:
+                    continue
+                found_specs.add(spec)
+                if spec.startswith("."):
+                    target_path = self._resolve_node_import(relative_path, spec, module_map)
+                    if target_path is None:
+                        limitations.append(f"node_unresolved:{relative_path}:{spec}")
+                        continue
+                    edges.append(
+                        GraphEdge(
+                            source=module_node_id,
+                            target=f"module:{target_path}",
+                            kind="imports",
+                            confidence="medium",
+                            method="heuristic",
+                        )
+                    )
+                else:
+                    limitations.append(f"node_external:{relative_path}:{spec}")
+
+        return nodes, edges, limitations
+
+    def _analyze_go_file(
+        self,
+        relative_path: str,
+        content: str,
+        import_map: dict[str, str],
+        workspace: str | None,
+    ) -> tuple[list[GraphNode], list[GraphEdge], list[str]]:
+        module_node_id = f"module:{relative_path}"
+        nodes: list[GraphNode] = []
+        edges: list[GraphEdge] = []
+        limitations: list[str] = []
+
+        for match in re.finditer(r"(?m)^func\s+([A-ZA-Za-z_][A-Za-z0-9_]*)\s*\(", content):
+            name = match.group(1)
+            node_id = f"function:{relative_path}:{name}"
+            nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind="function",
+                    language="go",
+                    path=relative_path,
+                    symbol=name,
+                    display_name=name,
+                    workspace=workspace,
+                )
+            )
+            edges.append(
+                GraphEdge(
+                    source=module_node_id,
+                    target=node_id,
+                    kind="contains",
+                    confidence="medium",
+                    method="heuristic",
+                )
+            )
+
+        import_specs = re.findall(r'"([^"]+)"', self._extract_go_import_block(content))
+        for spec in import_specs:
+            target_path = import_map.get(spec)
+            if target_path is None:
+                continue
+            edges.append(
+                GraphEdge(
+                    source=module_node_id,
+                    target=f"module:{target_path}",
+                    kind="imports",
+                    confidence="medium",
+                    method="heuristic",
+                )
+            )
+        return nodes, edges, limitations
+
+    def _analyze_jvm_file(
+        self,
+        relative_path: str,
+        content: str,
+        type_map: dict[str, tuple[str, str]],
+        workspace: str | None,
+    ) -> tuple[list[GraphNode], list[GraphEdge], list[str]]:
+        module_node_id = f"module:{relative_path}"
+        language = self._language_for_suffix(Path(relative_path).suffix)
+        nodes: list[GraphNode] = []
+        edges: list[GraphEdge] = []
+        limitations: list[str] = []
+        imported_type_map = {
+            imported.split(".")[-1]: imported
+            for imported in re.findall(r"(?m)^\s*import\s+([A-Za-z0-9_.]+)", content)
+        }
+
+        class_pattern = re.compile(
+            r"(?m)^\s*(?:public\s+|private\s+|protected\s+|internal\s+)?"
+            r"(?:class|interface|object|trait)\s+([A-Za-z_][A-Za-z0-9_]*)"
+            r"(?:\s+extends\s+([A-Za-z_][A-Za-z0-9_.]*))?"
+        )
+        local_class_ids: dict[str, str] = {}
+        for match in class_pattern.finditer(content):
+            name = match.group(1)
+            base = match.group(2)
+            node_id = f"class:{relative_path}:{name}"
+            local_class_ids[name] = node_id
+            nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind="class",
+                    language=language,
+                    path=relative_path,
+                    symbol=name,
+                    display_name=name,
+                    workspace=workspace,
+                )
+            )
+            edges.append(
+                GraphEdge(
+                    source=module_node_id,
+                    target=node_id,
+                    kind="contains",
+                    confidence="medium",
+                    method="heuristic",
+                )
+            )
+            if base:
+                base_short = base.split(".")[-1]
+                if base_short in local_class_ids:
+                    edges.append(
+                        GraphEdge(
+                            source=node_id,
+                            target=local_class_ids[base_short],
+                            kind="extends",
+                            confidence="low",
+                            method="heuristic",
+                        )
+                    )
+                else:
+                    imported_base = imported_type_map.get(base_short)
+                    fqcn = imported_base or base
+                    mapping = type_map.get(fqcn)
+                    if mapping is None:
+                        continue
+                    base_path, _base_name = mapping
+                    edges.append(
+                        GraphEdge(
+                            source=node_id,
+                            target=f"class:{base_path}:{base_short}",
+                            kind="extends",
+                            confidence="low",
+                            method="heuristic",
+                        )
+                    )
+
+        for imported in imported_type_map.values():
+            mapping = type_map.get(imported)
+            if mapping is None:
+                limitations.append(f"jvm_unresolved:{relative_path}:{imported}")
+                continue
+            target_path, _symbol = mapping
+            edges.append(
+                GraphEdge(
+                    source=module_node_id,
+                    target=f"module:{target_path}",
+                    kind="imports",
+                    confidence="medium",
+                    method="heuristic",
+                )
+            )
+        return nodes, edges, limitations
+
+    def _build_python_module_map(self, source_files: list[str]) -> dict[str, str]:
+        module_map: dict[str, str] = {}
+        for relative_path in source_files:
+            path = PurePosixPath(relative_path)
+            if path.suffix not in self._PYTHON_EXTENSIONS:
+                continue
+            if path.name == "__init__.py":
+                module_name = ".".join(path.parts[:-1])
+            else:
+                module_name = ".".join(path.with_suffix("").parts)
+            if module_name:
+                module_map[relative_path] = module_name
+        return module_map
+
+    def _build_go_import_map(self, root: Path, source_files: list[str]) -> dict[str, str]:
+        go_mod = root / "go.mod"
+        if not go_mod.exists():
+            return {}
+        module_name = ""
+        for line in go_mod.read_text(encoding="utf-8", errors="replace").splitlines():
+            stripped = line.strip()
+            if stripped.startswith("module "):
+                module_name = stripped.removeprefix("module ").strip()
+                break
+        if not module_name:
+            return {}
+        mapping: dict[str, str] = {}
+        for relative_path in source_files:
+            path = PurePosixPath(relative_path)
+            if path.suffix not in self._GO_EXTENSIONS:
+                continue
+            directory = "." if len(path.parts) == 1 else "/".join(path.parts[:-1])
+            import_path = module_name if directory == "." else f"{module_name}/{directory}"
+            mapping[import_path] = relative_path
+        return mapping
+
+    def _build_jvm_type_map(self, root: Path, source_files: list[str]) -> dict[str, tuple[str, str]]:
+        mapping: dict[str, tuple[str, str]] = {}
+        package_pattern = re.compile(r"(?m)^\s*package\s+([A-Za-z0-9_.]+)")
+        type_pattern = re.compile(
+            r"(?m)^\s*(?:public\s+|private\s+|protected\s+|internal\s+)?"
+            r"(?:class|interface|object|trait)\s+([A-Za-z_][A-Za-z0-9_]*)"
+        )
+        for relative_path in source_files:
+            if Path(relative_path).suffix not in self._JVM_EXTENSIONS:
+                continue
+            try:
+                content = (root / relative_path).read_text(encoding="utf-8", errors="replace")
+            except OSError:
+                continue
+            package_match = package_pattern.search(content)
+            type_match = type_pattern.search(content)
+            if type_match is None:
+                continue
+            package_name = package_match.group(1) if package_match else ""
+            symbol = type_match.group(1)
+            fqcn = f"{package_name}.{symbol}" if package_name else symbol
+            mapping[fqcn] = (relative_path, symbol)
+        return mapping
+
+    def _resolve_python_import(
+        self, module_name: str, module_map: dict[str, str]
+    ) -> Optional[str]:
+        for path, candidate in module_map.items():
+            if candidate == module_name:
+                return path
+        return None
+
+    def _resolve_python_from_import(
+        self,
+        node: ast.ImportFrom,
+        current_module: str | None,
+        module_map: dict[str, str],
+    ) -> Optional[str]:
+        if node.level and current_module:
+            package_parts = current_module.split(".")
+            base_parts = package_parts[:-1]
+            if node.level > 1:
+                base_parts = base_parts[: max(0, len(base_parts) - (node.level - 1))]
+            target_module = ".".join(base_parts + ([node.module] if node.module else []))
+        else:
+            target_module = node.module or ""
+        if not target_module:
+            return None
+        return self._resolve_python_import(target_module, module_map)
+
+    def _resolve_node_import(
+        self, source_path: str, spec: str, module_map: dict[str, str]
+    ) -> Optional[str]:
+        base_dir = PurePosixPath(source_path).parent
+        spec_path = PurePosixPath(spec)
+        candidate_base = (base_dir / spec_path).as_posix()
+        candidates = [
+            candidate_base,
+            f"{candidate_base}.js",
+            f"{candidate_base}.jsx",
+            f"{candidate_base}.ts",
+            f"{candidate_base}.tsx",
+            f"{candidate_base}/index.js",
+            f"{candidate_base}/index.ts",
+            f"{candidate_base}/index.tsx",
+        ]
+        for candidate in candidates:
+            normalized = PurePosixPath(candidate).as_posix()
+            if normalized in module_map:
+                return normalized
+        return None
+
+    def _extract_go_import_block(self, content: str) -> str:
+        block_match = re.search(r"import\s*\((.*?)\)", content, re.DOTALL)
+        if block_match is not None:
+            return block_match.group(1)
+        single_imports = re.findall(r'(?m)^\s*import\s+"([^"]+)"', content)
+        return "\n".join(f'"{item}"' for item in single_imports)
+
+    def _append_node(self, nodes: list[GraphNode], node_ids: set[str], node: GraphNode) -> None:
+        if len(nodes) >= self.max_nodes or node.id in node_ids:
+            return
+        node_ids.add(node.id)
+        nodes.append(node)
+
+    def _append_edge(
+        self,
+        edges: list[GraphEdge],
+        edge_keys: set[tuple[str, str, str, str]],
+        edge: GraphEdge,
+    ) -> None:
+        if len(edges) >= self.max_edges:
+            return
+        key = (edge.source, edge.target, edge.kind, edge.method)
+        if key in edge_keys:
+            return
+        edge_keys.add(key)
+        edges.append(edge)
+
+    def _language_for_suffix(self, suffix: str) -> str:
+        if suffix in self._PYTHON_EXTENSIONS:
+            return "python"
+        if suffix in self._NODE_EXTENSIONS:
+            return "nodejs"
+        if suffix in self._GO_EXTENSIONS:
+            return "go"
+        if suffix == ".java":
+            return "java"
+        if suffix == ".kt":
+            return "kotlin"
+        if suffix == ".scala":
+            return "scala"
+        return "unknown"
+
+    def _node_id(self, kind: str, path: str, symbol: str | None = None) -> str:
+        if symbol:
+            return f"{kind}:{path}:{symbol}"
+        return f"{kind}:{path}"
+
+    def _unique(self, values: list[str]) -> list[str]:
+        result: list[str] = []
+        for value in values:
+            if value not in result:
+                result.append(value)
+        return result