codegraphcontext-rust 0.5.5__cp310-cp310-win_amd64.whl

codegraphcontext/tools/indexing/schema.py

@@ -0,0 +1,79 @@
+"""Create constraints and indexes for graph backends (Neo4j / Falkor-style Cypher)."""
+
+from typing import Any
+
+from ...utils.debug_log import info_logger, warning_logger
+
+
+def create_graph_schema(driver: Any, db_manager: Any) -> None:
+    """Create constraints and indexes. *driver* must support .session() context manager."""
+    with driver.session() as session:
+        try:
+            session.run(
+                "CREATE CONSTRAINT repository_path IF NOT EXISTS FOR (r:Repository) REQUIRE r.path IS UNIQUE"
+            )
+            session.run("CREATE CONSTRAINT path IF NOT EXISTS FOR (f:File) REQUIRE f.path IS UNIQUE")
+            session.run(
+                "CREATE CONSTRAINT directory_path IF NOT EXISTS FOR (d:Directory) REQUIRE d.path IS UNIQUE"
+            )
+            session.run(
+                "CREATE CONSTRAINT function_unique IF NOT EXISTS FOR (f:Function) REQUIRE (f.name, f.path, f.line_number) IS UNIQUE"
+            )
+            session.run(
+                "CREATE CONSTRAINT class_unique IF NOT EXISTS FOR (c:Class) REQUIRE (c.name, c.path, c.line_number) IS UNIQUE"
+            )
+            session.run(
+                "CREATE CONSTRAINT trait_unique IF NOT EXISTS FOR (t:Trait) REQUIRE (t.name, t.path, t.line_number) IS UNIQUE"
+            )
+            session.run(
+                "CREATE CONSTRAINT interface_unique IF NOT EXISTS FOR (i:Interface) REQUIRE (i.name, i.path, i.line_number) IS UNIQUE"
+            )
+            session.run(
+                "CREATE CONSTRAINT macro_unique IF NOT EXISTS FOR (m:Macro) REQUIRE (m.name, m.path, m.line_number) IS UNIQUE"
+            )
+            session.run(
+                "CREATE CONSTRAINT variable_unique IF NOT EXISTS FOR (v:Variable) REQUIRE (v.name, v.path, v.line_number) IS UNIQUE"
+            )
+            session.run("CREATE CONSTRAINT module_name IF NOT EXISTS FOR (m:Module) REQUIRE m.name IS UNIQUE")
+            session.run(
+                "CREATE CONSTRAINT struct_cpp IF NOT EXISTS FOR (cstruct: Struct) REQUIRE (cstruct.name, cstruct.path, cstruct.line_number) IS UNIQUE"
+            )
+            session.run(
+                "CREATE CONSTRAINT enum_cpp IF NOT EXISTS FOR (cenum: Enum) REQUIRE (cenum.name, cenum.path, cenum.line_number) IS UNIQUE"
+            )
+            session.run(
+                "CREATE CONSTRAINT union_cpp IF NOT EXISTS FOR (cunion: Union) REQUIRE (cunion.name, cunion.path, cunion.line_number) IS UNIQUE"
+            )
+            session.run(
+                "CREATE CONSTRAINT annotation_unique IF NOT EXISTS FOR (a:Annotation) REQUIRE (a.name, a.path, a.line_number) IS UNIQUE"
+            )
+            session.run(
+                "CREATE CONSTRAINT record_unique IF NOT EXISTS FOR (r:Record) REQUIRE (r.name, r.path, r.line_number) IS UNIQUE"
+            )
+            session.run(
+                "CREATE CONSTRAINT property_unique IF NOT EXISTS FOR (p:Property) REQUIRE (p.name, p.path, p.line_number) IS UNIQUE"
+            )
+
+            session.run("CREATE INDEX function_lang IF NOT EXISTS FOR (f:Function) ON (f.lang)")
+            session.run("CREATE INDEX class_lang IF NOT EXISTS FOR (c:Class) ON (c.lang)")
+            session.run("CREATE INDEX annotation_lang IF NOT EXISTS FOR (a:Annotation) ON (a.lang)")
+
+            is_falkordb = getattr(db_manager, "get_backend_type", lambda: "neo4j")() != "neo4j"
+            if is_falkordb:
+                for label in ["Function", "Class"]:
+                    try:
+                        session.run(
+                            f"CALL db.idx.fulltext.createNodeIndex('{label}', 'name', 'source', 'docstring')"
+                        )
+                    except Exception:
+                        pass
+            else:
+                session.run("""
+                    CREATE FULLTEXT INDEX code_search_index IF NOT EXISTS
+                    FOR (n:Function|Class|Variable)
+                    ON EACH [n.name, n.source, n.docstring]
+                """)
+
+            info_logger("Database schema verified/created successfully")
+        except Exception as e:
+            warning_logger(f"Schema creation warning: {e}")

codegraphcontext/tools/indexing/schema_contract.py

@@ -0,0 +1,44 @@
+"""
+Semantic graph contract: labels, relationship types, and merge keys used by indexing.
+
+Backends must produce nodes/relationships consistent with this contract so MCP
+and query tools remain stable. This module is documentation + test hooks only.
+"""
+
+# Node labels written by the indexing pipeline (excluding dynamic query-only uses)
+NODE_LABELS = frozenset({
+    "Repository",
+    "Directory",
+    "File",
+    "Function",
+    "Class",
+    "Trait",
+    "Variable",
+    "Interface",
+    "Macro",
+    "Struct",
+    "Enum",
+    "Union",
+    "Record",
+    "Property",
+    "Annotation",
+    "Module",
+    "Parameter",
+})
+
+RELATIONSHIP_TYPES = frozenset({
+    "CONTAINS",
+    "CALLS",
+    "IMPORTS",
+    "INHERITS",
+    "HAS_PARAMETER",
+    "INCLUDES",
+    "IMPLEMENTS",
+})
+
+# Identity properties used in MERGE for code entities (path = absolute file path)
+FUNCTION_MERGE_KEYS = ("name", "path", "line_number")
+CLASS_MERGE_KEYS = ("name", "path", "line_number")
+FILE_MERGE_KEYS = ("path",)
+REPOSITORY_MERGE_KEYS = ("path",)
+DIRECTORY_MERGE_KEYS = ("path",)

codegraphcontext/tools/indexing/scip_pipeline.py

@@ -0,0 +1,140 @@
+"""SCIP-based indexing orchestration."""
+
+from __future__ import annotations
+
+import asyncio
+import tempfile
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Callable, Dict, Optional
+
+from ...core.jobs import JobManager, JobStatus
+from ...utils.debug_log import debug_log, error_logger, info_logger, warning_logger
+from ...utils.path_ignore import file_path_has_ignore_dir_segment
+from .persistence.writer import GraphWriter
+from .pre_scan import pre_scan_for_imports
+from .resolution.inheritance import build_inheritance_and_csharp_files
+
+
+def name_from_symbol(symbol: str) -> str:
+    import re
+
+    s = symbol.rstrip(".#")
+    s = re.sub(r"\(\)\.?$", "", s)
+    parts = re.split(r"[/#]", s)
+    last = parts[-1] if parts else symbol
+    return last or symbol
+
+
+async def run_scip_index_async(
+    path: Path,
+    is_dependency: bool,
+    job_id: Optional[str],
+    lang: str,
+    writer: GraphWriter,
+    job_manager: JobManager,
+    parsers_keys: Any,
+    get_parser: Callable[[str], Any],
+    scip_indexer_mod: Any,
+) -> None:
+    """Run SCIP CLI, write graph, supplement with Tree-sitter, write SCIP CALLS edges."""
+    ScipIndexer = scip_indexer_mod.ScipIndexer
+    ScipIndexParser = scip_indexer_mod.ScipIndexParser
+
+    if job_id:
+        job_manager.update_job(job_id, status=JobStatus.RUNNING)
+
+    writer.add_repository_to_graph(path, is_dependency)
+    repo_name = path.name
+
+    try:
+        with tempfile.TemporaryDirectory(prefix="cgc_scip_") as tmpdir:
+            scip_file = ScipIndexer().run(path, lang, Path(tmpdir))
+
+            if not scip_file:
+                warning_logger(
+                    f"SCIP indexer produced no output for {path}. "
+                    "Falling back to Tree-sitter."
+                )
+                raise RuntimeError("SCIP produced no index — triggering Tree-sitter fallback")
+
+            scip_data = ScipIndexParser().parse(scip_file, path)
+
+        if not scip_data:
+            raise RuntimeError("SCIP parse returned empty result")
+
+        files_data = scip_data.get("files", {})
+        file_paths = [Path(p) for p in files_data.keys() if Path(p).exists()]
+
+        imports_map = pre_scan_for_imports(file_paths, parsers_keys, get_parser)
+
+        if job_id:
+            job_manager.update_job(job_id, total_files=len(files_data))
+
+        processed = 0
+        index_root = path.resolve()
+        for abs_path_str, file_data in files_data.items():
+            file_path = Path(abs_path_str)
+            if file_path.is_file() and file_path_has_ignore_dir_segment(file_path, index_root):
+                continue
+            file_data["repo_path"] = str(index_root)
+            if job_id:
+                job_manager.update_job(job_id, current_file=abs_path_str)
+
+            ts_parser = get_parser(file_path.suffix)
+            if file_path.exists() and ts_parser:
+                try:
+                    ts_data = ts_parser.parse(file_path, is_dependency, index_source=True)
+                    if "error" not in ts_data:
+                        ts_funcs = {f["name"]: f for f in ts_data.get("functions", [])}
+                        for f in file_data.get("functions", []):
+                            ts_f = ts_funcs.get(f["name"])
+                            if ts_f:
+                                f.update(
+                                    {
+                                        "source": ts_f.get("source"),
+                                        "cyclomatic_complexity": ts_f.get("cyclomatic_complexity", 1),
+                                        "decorators": ts_f.get("decorators", []),
+                                    }
+                                )
+
+                        ts_classes = {c["name"]: c for c in ts_data.get("classes", [])}
+                        for c in file_data.get("classes", []):
+                            ts_c = ts_classes.get(c["name"])
+                            if ts_c:
+                                c["bases"] = ts_c.get("bases", [])
+
+                        file_data["imports"] = ts_data.get("imports", [])
+                        file_data["variables"] = ts_data.get("variables", [])
+                except Exception as e:
+                    debug_log(f"Tree-sitter supplement failed for {abs_path_str}: {e}")
+
+            writer.add_file_to_graph(file_data, repo_name, imports_map)
+
+            processed += 1
+            if job_id:
+                job_manager.update_job(job_id, processed_files=processed)
+            if processed % 50 == 0:
+                await asyncio.sleep(0)
+
+        info_logger(
+            f"[INHERITS] Resolving inheritance links across {len(files_data)} files..."
+        )
+        inheritance_batch, csharp_files = build_inheritance_and_csharp_files(
+            list(files_data.values()), imports_map
+        )
+        writer.write_inheritance_links(inheritance_batch, csharp_files, imports_map)
+
+        writer.write_scip_call_edges(files_data, name_from_symbol)
+
+        if job_id:
+            job_manager.update_job(job_id, status=JobStatus.COMPLETED, end_time=datetime.now())
+
+    except RuntimeError:
+        raise
+    except Exception as e:
+        error_logger(f"SCIP indexing failed for {path}: {e}")
+        if job_id:
+            job_manager.update_job(
+                job_id, status=JobStatus.FAILED, end_time=datetime.now(), errors=[str(e)]
+            )