codegraphcontext-rust 0.5.5__cp311-cp311-win_amd64.whl

codegraphcontext/tools/indexing/pipeline.py

@@ -0,0 +1,171 @@
+"""Orchestrates full-repo indexing (Tree-sitter path)."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional
+
+from ...core.jobs import JobManager, JobStatus
+from ...utils.debug_log import debug_log, error_logger, info_logger
+from .discovery import discover_files_to_index
+from .persistence.writer import GraphWriter
+from .pre_scan import pre_scan_for_imports
+from .resolution.calls import build_function_call_groups
+from .resolution.inheritance import build_inheritance_and_csharp_files
+
+# Try to load Rust engine for accelerated parsing
+try:
+    from .engine import (
+        RUST_AVAILABLE,
+        _RUST_SUPPORTED_LANGS,
+        _rust_parse_files_parallel,
+        _rust_pre_scan,
+        _rust_parse_and_prescan,
+        _rust_resolve_calls,
+        _rust_resolve_inheritance,
+    )
+except ImportError:
+    RUST_AVAILABLE = False
+
+
+async def run_tree_sitter_index_async(
+    path: Path,
+    is_dependency: bool,
+    job_id: Optional[str],
+    cgcignore_path: Optional[str],
+    writer: GraphWriter,
+    job_manager: JobManager,
+    parsers: Dict[str, str],
+    get_parser: Callable[[str], Any],
+    parse_file: Callable[[Path, Path, bool], Dict[str, Any]],
+    add_minimal_file_node: Callable[[Path, Path, bool], None],
+) -> None:
+    """Parse all discovered files, write symbols, then inheritance + CALLS.
+
+    When the Rust engine is available, files with supported languages are
+    parsed in parallel via Rust for significant speedup. Unsupported
+    languages (e.g. Kotlin, Perl) fall back to the Python parser.
+    """
+    if job_id:
+        job_manager.update_job(job_id, status=JobStatus.RUNNING)
+
+    writer.add_repository_to_graph(path, is_dependency)
+    repo_name = path.name
+
+    files, _ignore_root = discover_files_to_index(path, cgcignore_path)
+
+    if job_id:
+        job_manager.update_job(job_id, total_files=len(files))
+
+    all_file_data: List[Dict[str, Any]] = []
+    resolved_repo_path_str = str(path.resolve()) if path.is_dir() else str(path.parent.resolve())
+    repo_path_resolved = path.resolve() if path.is_dir() else path.parent.resolve()
+
+    # --- Combined pre-scan + parsing phase ---
+    if RUST_AVAILABLE:
+        # Split files into Rust-supported and fallback
+        rust_files = []
+        fallback_files = []
+        for file in files:
+            if not file.is_file():
+                continue
+            lang = parsers.get(file.suffix)
+            if lang and lang in _RUST_SUPPORTED_LANGS and file.suffix != ".ipynb":
+                rust_files.append((file, lang))
+            else:
+                fallback_files.append(file)
+
+        # Combined parse + pre-scan in one parallel pass (saves ~12% time)
+        imports_map = {}
+        if rust_files:
+            info_logger(f"Rust combined parse+prescan for {len(rust_files)} files...")
+            t_parse = time.time()
+            specs = [(str(f), lang, is_dependency) for f, lang in rust_files]
+            rust_results, imports_map = _rust_parse_and_prescan(specs)
+            info_logger(f"Rust parse+prescan done in {time.time() - t_parse:.1f}s "
+                        f"({len(imports_map)} symbols)")
+
+            for file_data in rust_results:
+                if "error" not in file_data:
+                    file_data["repo_path"] = str(repo_path_resolved)
+                    writer.add_file_to_graph(file_data, repo_name, imports_map, repo_path_str=resolved_repo_path_str)
+                    all_file_data.append(file_data)
+
+            if job_id:
+                job_manager.update_job(job_id, processed_files=len(rust_files))
+
+        # Fallback for unsupported files (.ipynb, Perl, etc.)
+        processed_count = len(rust_files)
+        for file in fallback_files:
+            if job_id:
+                job_manager.update_job(job_id, current_file=str(file))
+            file_data = parse_file(repo_path_resolved, file, is_dependency)
+            if "error" not in file_data:
+                writer.add_file_to_graph(file_data, repo_name, imports_map, repo_path_str=resolved_repo_path_str)
+                all_file_data.append(file_data)
+            elif not file_data.get("unsupported"):
+                add_minimal_file_node(file, repo_path_resolved, is_dependency)
+            processed_count += 1
+
+            if job_id:
+                job_manager.update_job(job_id, processed_files=processed_count)
+            if processed_count % 50 == 0:
+                await asyncio.sleep(0)
+    else:
+        # Original Python-only path: separate pre-scan
+        debug_log("Starting pre-scan to build imports map...")
+        imports_map = pre_scan_for_imports(files, parsers.keys(), get_parser)
+        debug_log(f"Pre-scan complete. Found {len(imports_map)} definitions.")
+        processed_count = 0
+        for file in files:
+            if not file.is_file():
+                continue
+            if job_id:
+                job_manager.update_job(job_id, current_file=str(file))
+            repo_path = path.resolve() if path.is_dir() else file.parent.resolve()
+            file_data = parse_file(repo_path, file, is_dependency)
+            if "error" not in file_data:
+                writer.add_file_to_graph(file_data, repo_name, imports_map, repo_path_str=resolved_repo_path_str)
+                all_file_data.append(file_data)
+            elif not file_data.get("unsupported"):
+                add_minimal_file_node(file, repo_path, is_dependency)
+            processed_count += 1
+
+            if job_id:
+                job_manager.update_job(job_id, processed_files=processed_count)
+            if processed_count % 50 == 0:
+                await asyncio.sleep(0)
+
+    info_logger(
+        f"File processing complete. {len(all_file_data)} files parsed. "
+        f"Starting post-processing phase (inheritance + function calls)..."
+    )
+
+    # --- Post-processing phase ---
+    t0 = time.time()
+
+    if RUST_AVAILABLE:
+        info_logger(f"[INHERITS] Rust-accelerated inheritance resolution ({len(all_file_data)} files)...")
+        inheritance_batch, csharp_files = _rust_resolve_inheritance(all_file_data, imports_map)
+    else:
+        info_logger(f"[INHERITS] Resolving inheritance links across {len(all_file_data)} files...")
+        inheritance_batch, csharp_files = build_inheritance_and_csharp_files(all_file_data, imports_map)
+    writer.write_inheritance_links(inheritance_batch, csharp_files, imports_map)
+    t1 = time.time()
+    info_logger(f"Inheritance links created in {t1 - t0:.1f}s. Starting function calls...")
+
+    if RUST_AVAILABLE:
+        from ...cli.config_manager import get_config_value
+        skip_external = (get_config_value("SKIP_EXTERNAL_RESOLUTION") or "false").lower() == "true"
+        groups = _rust_resolve_calls(all_file_data, imports_map, skip_external)
+    else:
+        groups = build_function_call_groups(all_file_data, imports_map, None)
+    writer.write_function_call_groups(*groups)
+    t2 = time.time()
+    info_logger(f"Function calls created in {t2 - t1:.1f}s. Total post-processing: {t2 - t0:.1f}s")
+
+    if job_id:
+        job_manager.update_job(job_id, status=JobStatus.COMPLETED, end_time=datetime.now())

codegraphcontext/tools/indexing/pre_scan.py

@@ -0,0 +1,105 @@
+"""Build global imports_map via language-specific pre-scan (registry dispatch)."""
+
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional
+
+# (extension -> callable(files, get_parser_for_ext) -> dict updates)
+_PreScanFn = Callable[[List[Path], Callable[[str], Any]], dict]
+
+
+def _register_prescans() -> Dict[str, _PreScanFn]:
+    from ..languages import python as python_lang_module
+    from ..languages import javascript as js_lang_module
+    from ..languages import go as go_lang_module
+    from ..languages import typescript as ts_lang_module
+    from ..languages import typescriptjsx as tsx_lang_module
+    from ..languages import cpp as cpp_lang_module
+    from ..languages import rust as rust_lang_module
+    from ..languages import c as c_lang_module
+    from ..languages import java as java_lang_module
+    from ..languages import ruby as ruby_lang_module
+    from ..languages import csharp as csharp_lang_module
+    from ..languages import kotlin as kotlin_lang_module
+    from ..languages import scala as scala_lang_module
+    from ..languages import swift as swift_lang_module
+    from ..languages import dart as dart_lang_module
+    from ..languages import perl as perl_lang_module
+    from ..languages import php as php_lang_module
+    from ..languages import haskell as haskell_lang_module
+    from ..languages import elixir as elixir_lang_module
+
+    def make_py(ext: str) -> _PreScanFn:
+        def scan(files: List[Path], gp: Callable[[str], Any]) -> dict:
+            return python_lang_module.pre_scan_python(files, gp(ext))
+
+        return scan
+
+    def make_js(ext: str) -> _PreScanFn:
+        def scan(files: List[Path], gp: Callable[[str], Any]) -> dict:
+            return js_lang_module.pre_scan_javascript(files, gp(ext))
+
+        return scan
+
+    return {
+        ".py": make_py(".py"),
+        ".ipynb": make_py(".ipynb"),
+        ".js": make_js(".js"),
+        ".jsx": make_js(".jsx"),
+        ".mjs": make_js(".mjs"),
+        ".cjs": make_js(".cjs"),
+        ".go": lambda files, gp: go_lang_module.pre_scan_go(files, gp(".go")),
+        ".ts": lambda files, gp: ts_lang_module.pre_scan_typescript(files, gp(".ts")),
+        ".tsx": lambda files, gp: tsx_lang_module.pre_scan_typescript(files, gp(".tsx")),
+        ".cpp": lambda files, gp: cpp_lang_module.pre_scan_cpp(files, gp(".cpp")),
+        ".h": lambda files, gp: cpp_lang_module.pre_scan_cpp(files, gp(".h")),
+        ".hpp": lambda files, gp: cpp_lang_module.pre_scan_cpp(files, gp(".hpp")),
+        ".hh": lambda files, gp: cpp_lang_module.pre_scan_cpp(files, gp(".hh")),
+        ".rs": lambda files, gp: rust_lang_module.pre_scan_rust(files, gp(".rs")),
+        ".c": lambda files, gp: c_lang_module.pre_scan_c(files, gp(".c")),
+        ".java": lambda files, gp: java_lang_module.pre_scan_java(files, gp(".java")),
+        ".rb": lambda files, gp: ruby_lang_module.pre_scan_ruby(files, gp(".rb")),
+        ".cs": lambda files, gp: csharp_lang_module.pre_scan_csharp(files, gp(".cs")),
+        ".kt": lambda files, gp: kotlin_lang_module.pre_scan_kotlin(files, gp(".kt")),
+        ".scala": lambda files, gp: scala_lang_module.pre_scan_scala(files, gp(".scala")),
+        ".sc": lambda files, gp: scala_lang_module.pre_scan_scala(files, gp(".sc")),
+        ".swift": lambda files, gp: swift_lang_module.pre_scan_swift(files, gp(".swift")),
+        ".dart": lambda files, gp: dart_lang_module.pre_scan_dart(files, gp(".dart")),
+        ".pl": lambda files, gp: perl_lang_module.pre_scan_perl(files, gp(".pl")),
+        ".pm": lambda files, gp: perl_lang_module.pre_scan_perl(files, gp(".pm")),
+        ".php": lambda files, gp: php_lang_module.pre_scan_php(files, gp(".php")),
+        ".hs": lambda files, gp: haskell_lang_module.pre_scan_haskell(files, gp(".hs")),
+        ".ex": lambda files, gp: elixir_lang_module.pre_scan_elixir(files, gp(".ex")),
+        ".exs": lambda files, gp: elixir_lang_module.pre_scan_elixir(files, gp(".exs")),
+    }
+
+
+_PRESCAN_REGISTRY: Optional[Dict[str, _PreScanFn]] = None
+
+
+def _get_registry() -> Dict[str, _PreScanFn]:
+    global _PRESCAN_REGISTRY
+    if _PRESCAN_REGISTRY is None:
+        _PRESCAN_REGISTRY = _register_prescans()
+    return _PRESCAN_REGISTRY
+
+
+def pre_scan_for_imports(
+    files: List[Path],
+    parsers_keys: Any,
+    get_parser: Callable[[str], Any],
+) -> dict:
+    """Dispatch pre-scan by file extension; *parsers_keys* is the set of supported extensions (e.g. graph_builder.parsers.keys())."""
+    imports_map: dict = {}
+    files_by_ext: Dict[str, List[Path]] = {}
+    for file in files:
+        if file.suffix in parsers_keys:
+            ext = file.suffix
+            files_by_ext.setdefault(ext, []).append(file)
+
+    registry = _get_registry()
+    for ext, file_list in files_by_ext.items():
+        scanner = registry.get(ext)
+        if scanner:
+            imports_map.update(scanner(file_list, get_parser))
+
+    return imports_map

codegraphcontext/tools/indexing/resolution/__init__.py

@@ -0,0 +1,8 @@
+from .calls import build_function_call_groups, resolve_function_call
+from .inheritance import build_inheritance_and_csharp_files
+
+__all__ = [
+    "build_function_call_groups",
+    "resolve_function_call",
+    "build_inheritance_and_csharp_files",
+]

codegraphcontext/tools/indexing/resolution/calls.py

@@ -0,0 +1,253 @@
+"""Heuristic resolution of function calls into CALLS edge payloads (no DB I/O)."""
+
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+from ....cli.config_manager import get_config_value
+from ....utils.debug_log import info_logger
+
+
+def resolve_function_call(
+    call: Dict[str, Any],
+    caller_file_path: str,
+    local_names: set,
+    local_imports: dict,
+    imports_map: dict,
+    skip_external: bool,
+) -> Optional[Dict[str, Any]]:
+    """Resolve a single function call to its target. Returns call params dict or None if skipped."""
+    called_name = call["name"]
+    if called_name in __builtins__:
+        return None
+
+    resolved_path = None
+    full_call = call.get("full_name", called_name)
+    base_obj = full_call.split(".")[0] if "." in full_call else None
+
+    is_chained_call = full_call.count(".") > 1 if "." in full_call else False
+
+    if is_chained_call and base_obj in ("self", "this", "super", "super()", "cls", "@"):
+        lookup_name = called_name
+    else:
+        lookup_name = base_obj if base_obj else called_name
+
+    if base_obj in ("self", "this", "super", "super()", "cls", "@") and not is_chained_call:
+        resolved_path = caller_file_path
+    elif lookup_name in local_names:
+        resolved_path = caller_file_path
+    elif call.get("inferred_obj_type"):
+        obj_type = call["inferred_obj_type"]
+        possible_paths = imports_map.get(obj_type, [])
+        if len(possible_paths) > 0:
+            resolved_path = possible_paths[0]
+
+    if not resolved_path:
+        possible_paths = imports_map.get(lookup_name, [])
+        if len(possible_paths) == 1:
+            resolved_path = possible_paths[0]
+        elif len(possible_paths) > 1:
+            if lookup_name in local_imports:
+                full_import_name = local_imports[lookup_name]
+                if full_import_name in imports_map:
+                    direct_paths = imports_map[full_import_name]
+                    if direct_paths and len(direct_paths) == 1:
+                        resolved_path = direct_paths[0]
+                if not resolved_path:
+                    for path in possible_paths:
+                        if full_import_name.replace(".", "/") in path:
+                            resolved_path = path
+                            break
+
+    if not resolved_path:
+        is_unresolved_external = True
+    else:
+        is_unresolved_external = False
+
+    if not resolved_path:
+        possible_paths = imports_map.get(lookup_name, [])
+        if len(possible_paths) > 0:
+            if lookup_name in local_imports:
+                pass
+            else:
+                pass
+    if not resolved_path:
+        if called_name in local_names:
+            resolved_path = caller_file_path
+            is_unresolved_external = False
+        elif called_name in imports_map and imports_map[called_name]:
+            candidates = imports_map[called_name]
+            for path in candidates:
+                for imp_name in local_imports.values():
+                    if imp_name.replace(".", "/") in path:
+                        resolved_path = path
+                        is_unresolved_external = False
+                        break
+                if resolved_path:
+                    break
+            if not resolved_path:
+                resolved_path = candidates[0]
+        else:
+            resolved_path = caller_file_path
+
+    if skip_external and is_unresolved_external:
+        return None
+
+    caller_context = call.get("context")
+    if caller_context and len(caller_context) == 3 and caller_context[0] is not None:
+        caller_name, _, caller_line_number = caller_context
+        return {
+            "type": "function",
+            "caller_name": caller_name,
+            "caller_file_path": caller_file_path,
+            "caller_line_number": caller_line_number,
+            "called_name": called_name,
+            "called_file_path": resolved_path,
+            "line_number": call["line_number"],
+            "args": call.get("args", []),
+            "full_call_name": call.get("full_name", called_name),
+        }
+    return {
+        "type": "file",
+        "caller_file_path": caller_file_path,
+        "called_name": called_name,
+        "called_file_path": resolved_path,
+        "line_number": call["line_number"],
+        "args": call.get("args", []),
+        "full_call_name": call.get("full_name", called_name),
+    }
+
+
+def build_function_call_groups(
+    all_file_data: List[Dict[str, Any]],
+    imports_map: dict,
+    file_class_lookup: Optional[Dict[str, set]] = None,
+) -> Tuple[
+    List[Dict],
+    List[Dict],
+    List[Dict],
+    List[Dict],
+    List[Dict],
+    List[Dict],
+]:
+    """Phase 1 of CALLS linking: resolve and bucket by (caller_label, called_label) pair."""
+    skip_external = (get_config_value("SKIP_EXTERNAL_RESOLUTION") or "false").lower() == "true"
+
+    if file_class_lookup is None:
+        file_class_lookup = {}
+    for fd in all_file_data:
+        fp = str(Path(fd["path"]).resolve())
+        file_class_lookup[fp] = {c["name"] for c in fd.get("classes", [])}
+
+    info_logger(f"[CALLS] Resolving function calls across {len(all_file_data)} files...")
+    fn_to_fn: List[Dict] = []
+    fn_to_cls: List[Dict] = []
+    cls_to_fn: List[Dict] = []
+    cls_to_cls: List[Dict] = []
+    file_to_fn: List[Dict] = []
+    file_to_cls: List[Dict] = []
+
+    # Pre-build per-language-extension filtered imports_map views.
+    # When a caller is Java, we only want to resolve against Java files —
+    # this prevents false-positive CALLS edges from names that coincidentally
+    # exist in another language's file (e.g. Java `add()` -> JS `add`).
+    _lang_imports_cache: Dict[str, dict] = {}
+
+    def _get_lang_imports(caller_lang: str) -> dict:
+        if caller_lang not in _lang_imports_cache:
+            # Map language name to typical file extensions
+            _LANG_EXTS: Dict[str, set] = {
+                "java":       {".java"},
+                "python":     {".py", ".ipynb"},
+                "javascript": {".js", ".jsx", ".mjs", ".cjs"},
+                "typescript": {".ts", ".tsx"},
+                "go":         {".go"},
+                "rust":       {".rs"},
+                "cpp":        {".cpp", ".h", ".hpp", ".hh"},
+                "c":          {".c"},
+                "c_sharp":    {".cs"},
+                "kotlin":     {".kt"},
+                "scala":      {".scala", ".sc"},
+                "ruby":       {".rb"},
+                "swift":      {".swift"},
+                "php":        {".php"},
+                "dart":       {".dart"},
+                "perl":       {".pl", ".pm"},
+                "haskell":    {".hs"},
+                "elixir":     {".ex", ".exs"},
+            }
+            exts = _LANG_EXTS.get(caller_lang)
+            if not exts:
+                # Unknown language — use full imports_map unchanged
+                _lang_imports_cache[caller_lang] = imports_map
+            else:
+                filtered: dict = {}
+                for name, paths in imports_map.items():
+                    same_lang = [p for p in paths if Path(p).suffix in exts]
+                    if same_lang:
+                        filtered[name] = same_lang
+                    elif paths:
+                        # Keep non-file entries (e.g. package names with no extension)
+                        if not any(Path(p).suffix for p in paths):
+                            filtered[name] = paths
+                _lang_imports_cache[caller_lang] = filtered
+        return _lang_imports_cache[caller_lang]
+
+    for idx, file_data in enumerate(all_file_data):
+        caller_file_path = str(Path(file_data["path"]).resolve())
+        func_names = {f["name"] for f in file_data.get("functions", [])}
+        class_names = {c["name"] for c in file_data.get("classes", [])}
+        local_names = func_names | class_names
+        local_imports = {
+            imp.get("alias") or imp["name"].split(".")[-1]: imp["name"]
+            for imp in file_data.get("imports", [])
+        }
+
+        caller_lang = file_data.get("lang", "")
+        effective_imports_map = _get_lang_imports(caller_lang) if caller_lang else imports_map
+
+        for call in file_data.get("function_calls", []):
+            resolved = resolve_function_call(
+                call, caller_file_path, local_names, local_imports, effective_imports_map, skip_external
+            )
+            if not resolved:
+                continue
+
+            called_path = resolved.get("called_file_path", "")
+            called_name = resolved["called_name"]
+            called_is_class = called_name in file_class_lookup.get(called_path, set())
+
+            if resolved["type"] == "file":
+                if called_is_class:
+                    file_to_cls.append(resolved)
+                else:
+                    file_to_fn.append(resolved)
+            else:
+                caller_name = resolved["caller_name"]
+                caller_is_class = caller_name in class_names
+                if caller_is_class:
+                    (cls_to_cls if called_is_class else cls_to_fn).append(resolved)
+                else:
+                    (fn_to_cls if called_is_class else fn_to_fn).append(resolved)
+
+        if (idx + 1) % 1000 == 0:
+            total = len(fn_to_fn) + len(fn_to_cls) + len(cls_to_fn) + len(cls_to_cls)
+            file_total = len(file_to_fn) + len(file_to_cls)
+            info_logger(
+                f"[CALLS] Resolved {idx + 1}/{len(all_file_data)} files... "
+                f"({total} fn/cls calls, {file_total} file calls)"
+            )
+
+    total_all = (
+        len(fn_to_fn)
+        + len(fn_to_cls)
+        + len(cls_to_fn)
+        + len(cls_to_cls)
+        + len(file_to_fn)
+        + len(file_to_cls)
+    )
+    info_logger(
+        f"[CALLS] Resolution complete: fn→fn={len(fn_to_fn)}, fn→cls={len(fn_to_cls)}, "
+        f"cls→fn={len(cls_to_fn)}, cls→cls={len(cls_to_cls)}, "
+        f"file→fn={len(file_to_fn)}, file→cls={len(file_to_cls)}. Total={total_all}"
+    )
+    return fn_to_fn, fn_to_cls, cls_to_fn, cls_to_cls, file_to_fn, file_to_cls

codegraphcontext/tools/indexing/resolution/inheritance.py

@@ -0,0 +1,91 @@
+"""Resolve class inheritance into INHERITS row payloads (no DB I/O for non-C# batch)."""
+
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+
+def resolve_inheritance_link(
+    class_item: Dict[str, Any],
+    base_class_str: str,
+    caller_file_path: str,
+    local_class_names: set,
+    local_imports: dict,
+    imports_map: dict,
+) -> Optional[Dict[str, Any]]:
+    """Resolve a single inheritance link. Returns row dict or None."""
+    if base_class_str == "object":
+        return None
+
+    resolved_path = None
+    target_class_name = base_class_str.split(".")[-1]
+
+    if "." in base_class_str:
+        lookup_name = base_class_str.split(".")[0]
+        if lookup_name in local_imports:
+            full_import_name = local_imports[lookup_name]
+            possible_paths = imports_map.get(target_class_name, [])
+            for path in possible_paths:
+                if full_import_name.replace(".", "/") in path:
+                    resolved_path = path
+                    break
+    else:
+        lookup_name = base_class_str
+        if lookup_name in local_class_names:
+            resolved_path = caller_file_path
+        elif lookup_name in local_imports:
+            full_import_name = local_imports[lookup_name]
+            possible_paths = imports_map.get(target_class_name, [])
+            for path in possible_paths:
+                if full_import_name.replace(".", "/") in path:
+                    resolved_path = path
+                    break
+        elif lookup_name in imports_map:
+            possible_paths = imports_map[lookup_name]
+            if len(possible_paths) == 1:
+                resolved_path = possible_paths[0]
+
+    if resolved_path:
+        return {
+            "child_name": class_item["name"],
+            "path": caller_file_path,
+            "parent_name": target_class_name,
+            "resolved_parent_file_path": resolved_path,
+        }
+    return None
+
+
+def build_inheritance_and_csharp_files(
+    all_file_data: List[Dict[str, Any]], imports_map: dict
+) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]]]:
+    """Returns (inheritance_batch_rows, csharp_file_data_list)."""
+    inheritance_batch: List[Dict[str, Any]] = []
+    csharp_files: List[Dict[str, Any]] = []
+
+    for file_data in all_file_data:
+        if file_data.get("lang") == "c_sharp":
+            csharp_files.append(file_data)
+            continue
+
+        caller_file_path = str(Path(file_data["path"]).resolve())
+        local_class_names = {c["name"] for c in file_data.get("classes", [])}
+        local_imports = {
+            imp.get("alias") or imp["name"].split(".")[-1]: imp["name"]
+            for imp in file_data.get("imports", [])
+        }
+
+        for class_item in file_data.get("classes", []):
+            if not class_item.get("bases"):
+                continue
+            for base_class_str in class_item["bases"]:
+                resolved = resolve_inheritance_link(
+                    class_item,
+                    base_class_str,
+                    caller_file_path,
+                    local_class_names,
+                    local_imports,
+                    imports_map,
+                )
+                if resolved:
+                    inheritance_batch.append(resolved)
+
+    return inheritance_batch, csharp_files

codegraphcontext/tools/indexing/sanitize.py

@@ -0,0 +1,41 @@
+"""Property coercion for graph backends (shared helpers for dialects / writers)."""
+
+from typing import Any, Dict
+
+# Neo4j RANGE indexes have an ~8 kB key-size limit. Long C++ template function names
+# can exceed this. Cap string properties at 4096 chars.
+MAX_STR_LEN = 4096
+
+
+def sanitize_props(props: Dict[str, Any]) -> Dict[str, Any]:
+    """Return a copy of *props* with values coerced to database-safe types.
+
+    FalkorDB and KùzuDB only accept node properties that are primitives
+    (str, int, float, bool, None) or flat lists of primitives. Complex
+    values are serialized to JSON. Strings are truncated to MAX_STR_LEN.
+    """
+    import json
+
+    MAX = MAX_STR_LEN
+
+    def _is_primitive(v):
+        return isinstance(v, (str, int, float, bool)) or v is None
+
+    def _is_flat_list(v):
+        return isinstance(v, list) and all(_is_primitive(item) for item in v)
+
+    def _coerce(v):
+        if isinstance(v, str):
+            return v[:MAX] if len(v) > MAX else v
+        if _is_primitive(v):
+            return v
+        if _is_flat_list(v):
+            return [s[:MAX] if isinstance(s, str) and len(s) > MAX else s for s in v]
+        try:
+            serialized = json.dumps(v, default=str)
+            return serialized[:MAX] if len(serialized) > MAX else serialized
+        except Exception:
+            s = str(v)
+            return s[:MAX] if len(s) > MAX else s
+
+    return {k: _coerce(v) for k, v in props.items()}