codegraphcontext 0.3.7__tar.gz → 0.3.8__tar.gz

{codegraphcontext-0.3.7/src/codegraphcontext.egg-info → codegraphcontext-0.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.3.7
+Version: 0.3.8
 Summary: An MCP server that indexes local code into a graph database to provide context to AI assistants.
 Author-email: Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 License: MIT License
@@ -51,6 +51,7 @@ Requires-Dist: nbformat
 Requires-Dist: nbconvert>=7.16.6
 Requires-Dist: pathspec>=0.12.1
 Requires-Dist: falkordb>=0.1.0
+Requires-Dist: requests>=2.28.0
 Requires-Dist: falkordblite>=0.1.0; sys_platform != "win32" and python_version >= "3.12"
 Requires-Dist: fastapi>=0.100.0
 Requires-Dist: uvicorn>=0.22.0
@@ -162,7 +163,7 @@ A powerful **MCP server** and **CLI toolkit** that indexes local code into a gra
 ---
 
 ## Project Details
-- **Version:** 0.3.7
+- **Version:** 0.3.8
 - **Authors:** Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 - **License:** MIT License (See [LICENSE](LICENSE) for details)
 - **Website:** [CodeGraphContext](http://codegraphcontext.vercel.app/)
@@ -271,7 +272,7 @@ pip install codegraphcontext
 
 ### If 'cgc' command isn't found, run our one-line fix:
 ```
-curl -sSL [https://raw.githubusercontent.com/CodeGraphContext/CodeGraphContext/main/scripts/post_install_fix.sh](https://raw.githubusercontent.com/CodeGraphContext/CodeGraphContext/main/scripts/post_install_fix.sh) | bash
+curl -sSL https://raw.githubusercontent.com/CodeGraphContext/CodeGraphContext/main/scripts/post_install_fix.sh | bash
 ```
 
 ---

{codegraphcontext-0.3.7 → codegraphcontext-0.3.8}/README.md

@@ -96,7 +96,7 @@ A powerful **MCP server** and **CLI toolkit** that indexes local code into a gra
 ---
 
 ## Project Details
-- **Version:** 0.3.7
+- **Version:** 0.3.8
 - **Authors:** Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 - **License:** MIT License (See [LICENSE](LICENSE) for details)
 - **Website:** [CodeGraphContext](http://codegraphcontext.vercel.app/)
@@ -205,7 +205,7 @@ pip install codegraphcontext
 
 ### If 'cgc' command isn't found, run our one-line fix:
 ```
-curl -sSL [https://raw.githubusercontent.com/CodeGraphContext/CodeGraphContext/main/scripts/post_install_fix.sh](https://raw.githubusercontent.com/CodeGraphContext/CodeGraphContext/main/scripts/post_install_fix.sh) | bash
+curl -sSL https://raw.githubusercontent.com/CodeGraphContext/CodeGraphContext/main/scripts/post_install_fix.sh | bash
 ```
 
 ---

{codegraphcontext-0.3.7 → codegraphcontext-0.3.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codegraphcontext"
-version = "0.3.7"
+version = "0.3.8"
 description = "An MCP server that indexes local code into a graph database to provide context to AI assistants."
 authors = [{ name = "Shashank Shekhar Singh", email = "shashankshekharsingh1205@gmail.com" }]
 readme = "README.md"
@@ -30,6 +30,7 @@ dependencies = [
     "nbconvert>=7.16.6",
     "pathspec>=0.12.1",
     "falkordb>=0.1.0",
+    "requests>=2.28.0",
     "falkordblite>=0.1.0; sys_platform != 'win32' and python_version >= '3.12'",
     "fastapi>=0.100.0",
     "uvicorn>=0.22.0"

{codegraphcontext-0.3.7 → codegraphcontext-0.3.8}/src/codegraphcontext/cli/cli_helpers.py

@@ -483,9 +483,10 @@ def clean_helper():
     console.print("[cyan]🧹 Cleaning database (removing orphaned nodes)...[/cyan]")
     
     try:
-        # Determine if we're using FalkorDB or Neo4j for query optimization
+        # Determine backend type for query compatibility
         db_type = db_manager.__class__.__name__
         is_falkordb = "Falkor" in db_type
+        is_kuzu = "Kuzu" in db_type
         
         total_deleted = 0
         batch_size = 1000
@@ -493,14 +494,15 @@ def clean_helper():
         with db_manager.get_driver().session() as session:
             # Keep deleting orphaned nodes in batches until none are found
             while True:
-                if is_falkordb:
-                    # FalkorDB-compatible query using OPTIONAL MATCH
+                if is_falkordb or is_kuzu:
+                    # FalkorDB / KùzuDB-compatible query using OPTIONAL MATCH
+                    # (KùzuDB does not support the Neo4j `NOT EXISTS { MATCH ... }` subquery syntax)
                     query = """
                     MATCH (n)
                     WHERE NOT (n:Repository)
-                    OPTIONAL MATCH path = (n)-[*..10]-(r:Repository)
-                    WITH n, path
-                    WHERE path IS NULL
+                    OPTIONAL MATCH p = (n)-[*..10]-(r:Repository)
+                    WITH n, p
+                    WHERE p IS NULL
                     WITH n LIMIT $batch_size
                     DETACH DELETE n
                     RETURN count(n) as deleted

{codegraphcontext-0.3.7 → codegraphcontext-0.3.8}/src/codegraphcontext/core/database_kuzu.py

@@ -109,14 +109,21 @@ class KuzuDBManager:
             ("Parameter", "uid STRING, name STRING, path STRING, function_line_number INT64, PRIMARY KEY (uid)")
         ]
         
+        # rel_tables: list of (table_name, schema, use_group)
+        # use_group=True  -> CREATE REL TABLE GROUP (for multi FROM..TO bindings)
+        # use_group=False -> CREATE REL TABLE          (single binding)
         rel_tables = [
-            ("CONTAINS", "FROM File TO Function, FROM File TO Class, FROM File TO Variable, FROM File TO Trait, FROM File TO Interface, FROM `Macro` TO `Macro`, FROM File TO `Macro`, FROM File TO Struct, FROM File TO Enum, FROM File TO `Union`, FROM File TO Annotation, FROM File TO Record, FROM File TO Property, FROM Repository TO Directory, FROM Directory TO Directory, FROM Directory TO File, FROM Repository TO File, FROM Class TO Function, FROM Function TO Function"),
-            ("CALLS", "FROM Function TO Function, FROM Function TO Class, FROM File TO Function, FROM File TO Class, FROM Class TO Function, FROM Class TO Class, line_number INT64, args STRING[], full_call_name STRING"),
-            ("IMPORTS", "FROM File TO Module, alias STRING, full_import_name STRING, imported_name STRING, line_number INT64"),
-            ("INHERITS", "FROM Class TO Class, FROM Record TO Record, FROM Interface TO Interface"),
-            ("HAS_PARAMETER", "FROM Function TO Parameter"),
-            ("INCLUDES", "FROM Class TO Module"),
-            ("IMPLEMENTS", "FROM Class TO Interface, FROM Struct TO Interface, FROM Record TO Interface")
+            # Note: in KùzuDB, some labels (e.g. `Macro`, `Property`, `Union`) are treated as reserved
+            # keywords in CREATE REL TABLE statements. We must escape them with backticks
+            # or the rel table creation will fail silently, leading to runtime
+            # "Binder exception: Table CONTAINS does not exist".
+            ("CONTAINS", "FROM File TO Function, FROM File TO Class, FROM File TO Variable, FROM File TO Trait, FROM File TO Interface, FROM `Macro` TO `Macro`, FROM File TO `Macro`, FROM File TO Struct, FROM File TO Enum, FROM File TO `Union`, FROM File TO Annotation, FROM File TO Record, FROM File TO `Property`, FROM Repository TO Directory, FROM Directory TO Directory, FROM Directory TO File, FROM Repository TO File, FROM Class TO Function, FROM Function TO Function", True),
+            ("CALLS", "FROM Function TO Function, FROM Function TO Class, FROM File TO Function, FROM File TO Class, FROM Class TO Function, FROM Class TO Class, line_number INT64, args STRING[], full_call_name STRING", True),
+            ("IMPORTS", "FROM File TO Module, alias STRING, full_import_name STRING, imported_name STRING, line_number INT64", False),
+            ("INHERITS", "FROM Class TO Class, FROM Record TO Record, FROM Interface TO Interface", True),
+            ("HAS_PARAMETER", "FROM Function TO Parameter", False),
+            ("INCLUDES", "FROM Class TO Module", False),
+            ("IMPLEMENTS", "FROM Class TO Interface, FROM Struct TO Interface, FROM Record TO Interface", True)
         ]
 
         for table_name, schema in node_tables:
@@ -127,10 +134,13 @@ class KuzuDBManager:
                     warning_logger(f"Kuzu Schema Node Error ({table_name}): {e}")
                     debug_log(f"Kuzu Schema Node Error ({table_name}): {e}")
 
-        for table_name, schema in rel_tables:
+        for table_name, schema, use_group in rel_tables:
             try:
-                # Need to handle backticks in schema as well for keywords
-                self._conn.execute(f"CREATE REL TABLE `{table_name}`({schema})")
+                if use_group:
+                    # KùzuDB requires CREATE REL TABLE GROUP for multi-binding relationships
+                    self._conn.execute(f"CREATE REL TABLE GROUP `{table_name}`({schema})")
+                else:
+                    self._conn.execute(f"CREATE REL TABLE `{table_name}`({schema})")
             except Exception as e:
                 if "already exists" not in str(e).lower():
                     warning_logger(f"Kuzu Schema Rel Error ({table_name}): {e}")

{codegraphcontext-0.3.7 → codegraphcontext-0.3.8}/src/codegraphcontext/server.py

@@ -36,6 +36,40 @@ from .tools.handlers import (
 DEFAULT_EDIT_DISTANCE = 2
 DEFAULT_FUZZY_SEARCH = False
 
+WORKSPACE_PREFIX = "/workspace/"
+
+
+def _is_path_key(key: str) -> bool:
+    """Check if a dict key represents a file path field.
+
+    Matches keys like 'path', 'clone_path', 'caller_file_path', and also
+    Cypher-aliased keys like 'f.path', 'n.caller_file_path'.
+    """
+    # Strip Cypher alias prefix (e.g. "f.path" -> "path")
+    bare = key.rsplit(".", 1)[-1] if "." in key else key
+    return bare == "path" or bare.endswith("_path")
+
+
+def _strip_path_value(value):
+    """Strip /workspace/ prefix from a single string value."""
+    if isinstance(value, str) and value.startswith(WORKSPACE_PREFIX):
+        return value[len(WORKSPACE_PREFIX):]
+    return value
+
+
+def _strip_workspace_prefix(obj):
+    """Recursively strip /workspace/ prefix from path values in results."""
+    if isinstance(obj, dict):
+        return {
+            k: _strip_path_value(v) if _is_path_key(k) else _strip_workspace_prefix(v)
+            for k, v in obj.items()
+        }
+    elif isinstance(obj, list):
+        return [_strip_workspace_prefix(item) for item in obj]
+    return obj
+
+
+
 class MCPServer:
     """
     The main MCP Server class.
@@ -254,7 +288,8 @@ class MCPServer:
                     tool_name = params.get('name')
                     args = params.get('arguments', {})
                     result = await self.handle_tool_call(tool_name, args)
-                    
+                    result = _strip_workspace_prefix(result)
+
                     if "error" in result:
                         response = {
                             "jsonrpc": "2.0", "id": request_id,

{codegraphcontext-0.3.7 → codegraphcontext-0.3.8}/src/codegraphcontext/tools/code_finder.py

@@ -5,6 +5,7 @@ from typing import Any, Dict, List, Literal, Optional
 from pathlib import Path
 
 from ..core.database import DatabaseManager
+from ..utils.path_ignore import cypher_path_not_under_ignore_dirs
 
 logger = logging.getLogger(__name__)
 
@@ -540,10 +541,12 @@ class CodeFinder:
         with self.driver.session() as session:
             repo_filter = "AND func.path STARTS WITH $repo_path" if repo_path else ""
             decorator_filter = "AND ALL(decorator_name IN $exclude_decorated_with WHERE NOT decorator_name IN func.decorators)" if exclude_decorated_with else ""
+            func_ignore = cypher_path_not_under_ignore_dirs("func.path")
+            caller_ignore = cypher_path_not_under_ignore_dirs("caller.path")
             
             query = f"""
                 MATCH (func:Function)
-                WHERE func.is_dependency = false {repo_filter}
+                WHERE func.is_dependency = false {repo_filter} {func_ignore}
                   AND NOT func.name IN ['main', 'setup', 'run']
                   AND NOT (func.name STARTS WITH '__' AND func.name ENDS WITH '__')
                   AND NOT func.name STARTS WITH '_test'
@@ -555,7 +558,7 @@ class CodeFinder:
                   {decorator_filter}
                 WITH func
                 OPTIONAL MATCH (caller:Function)-[:CALLS]->(func)
-                WHERE caller.is_dependency = false
+                WHERE caller.is_dependency = false {caller_ignore}
                 WITH func, count(caller) as caller_count
                 WHERE caller_count = 0
                 OPTIONAL MATCH (file:File)-[:CONTAINS]->(func)
@@ -591,8 +594,8 @@ class CodeFinder:
                 # KùzuDB-compatible: Use anonymous end node and filter with WHERE
                 query = f"""
                     MATCH p = (f:Function)-[:CALLS*]->()
-                    WITH f, p, nodes(p) as path_nodes
-                    WITH f, path_nodes, list_extract(path_nodes, size(path_nodes)) as target
+                    WITH f as f, p as p, nodes(p) as path_nodes
+                    WITH f as f, path_nodes as path_nodes, path_nodes[size(path_nodes)] as target
                     WHERE target.name = $function_name AND target.path = $path {repo_filter}
                     RETURN DISTINCT f.name AS caller_name, f.path AS caller_file_path, f.line_number AS caller_line_number, f.is_dependency AS caller_is_dependency
                     ORDER BY caller_is_dependency ASC, caller_file_path, caller_line_number
@@ -603,8 +606,8 @@ class CodeFinder:
                 # KùzuDB-compatible: Use anonymous end node and filter with WHERE
                 query = f"""
                     MATCH p = (f:Function)-[:CALLS*]->()
-                    WITH f, p, nodes(p) as path_nodes
-                    WITH f, path_nodes, list_extract(path_nodes, size(path_nodes)) as target
+                    WITH f as f, p as p, nodes(p) as path_nodes
+                    WITH f as f, path_nodes as path_nodes, path_nodes[size(path_nodes)] as target
                     WHERE target.name = $function_name {repo_filter}
                     RETURN DISTINCT f.name AS caller_name, f.path AS caller_file_path, f.line_number AS caller_line_number, f.is_dependency AS caller_is_dependency
                     ORDER BY caller_is_dependency ASC, caller_file_path, caller_line_number
@@ -622,8 +625,8 @@ class CodeFinder:
                 query = f"""
                     MATCH (caller:Function {{name: $function_name, path: $path}})
                     MATCH p = (caller)-[:CALLS*]->()
-                    WITH p, nodes(p) as path_nodes
-                    WITH list_extract(path_nodes, size(path_nodes)) as f
+                    WITH p as p, nodes(p) as path_nodes
+                    WITH path_nodes[size(path_nodes)] as f
                     {repo_filter}
                     RETURN DISTINCT f.name AS callee_name, f.path AS callee_file_path, f.line_number AS callee_line_number, f.is_dependency AS callee_is_dependency
                     ORDER BY callee_is_dependency ASC, callee_file_path, callee_line_number
@@ -635,8 +638,8 @@ class CodeFinder:
                 query = f"""
                     MATCH (caller:Function {{name: $function_name}})
                     MATCH p = (caller)-[:CALLS*]->()
-                    WITH p, nodes(p) as path_nodes
-                    WITH list_extract(path_nodes, size(path_nodes)) as f
+                    WITH p as p, nodes(p) as path_nodes
+                    WITH path_nodes[size(path_nodes)] as f
                     {repo_filter}
                     RETURN DISTINCT f.name AS callee_name, f.path AS callee_file_path, f.line_number AS callee_line_number, f.is_dependency AS callee_is_dependency
                     ORDER BY callee_is_dependency ASC, callee_file_path, callee_line_number
@@ -657,24 +660,12 @@ class CodeFinder:
             query = f"""
                 MATCH (start:Function {start_props}), (end_target:Function {end_props})
                 {repo_filter}
-                WITH start, end_target
+                WITH start as start, end_target as end_target
                 MATCH path = (start)-[:CALLS*1..{max_depth}]->()
-                WITH path, end_target, nodes(path) as func_nodes, relationships(path) as call_rels
-                WITH path, func_nodes, call_rels, list_extract(func_nodes, size(func_nodes)) as path_end
+                WITH path as path, end_target as end_target, nodes(path) as func_nodes, relationships(path) as call_rels
+                WITH path as path, func_nodes as func_nodes, call_rels as call_rels, end_target as end_target, func_nodes[size(func_nodes)] as path_end
                 WHERE path_end.name = end_target.name AND (end_target.path IS NULL OR path_end.path = end_target.path)
-                RETURN 
-                    [node in func_nodes | {{
-                        name: node.name,
-                        path: node.path,
-                        line_number: node.line_number,
-                        is_dependency: node.is_dependency
-                    }}] as function_chain,
-                    [rel in call_rels | {{
-                        call_line: rel.line_number,
-                        args: rel.args,
-                        full_call_name: rel.full_call_name
-                    }}] as call_details,
-                    length(path) as chain_length
+                RETURN func_nodes as function_nodes, call_rels as call_nodes, size(call_rels) as chain_length
                 ORDER BY chain_length ASC
                 LIMIT 20
             """
@@ -689,7 +680,67 @@ class CodeFinder:
             }
             
             result = session.run(query, **params)
-            return result.data()
+
+            # Post-process Node/Rel objects into plain dicts so CLI output stays stable
+            rows = result.data()
+            transformed: List[Dict[str, Any]] = []
+            for row in rows:
+                func_nodes = row.get("function_nodes") or []
+                rel_nodes = row.get("call_nodes") or []
+                chain_len = row.get("chain_length", 0)
+
+                function_chain = []
+                for n in func_nodes:
+                    # Depending on KùzuDB + driver wrapping, list elements can arrive
+                    # either as Node/Rel objects or already-materialized dicts.
+                    if isinstance(n, dict):
+                        props = n
+                    else:
+                        props = None
+                        try:
+                            props = n.get_properties()
+                        except Exception:
+                            props = getattr(n, "properties", None)
+                        if props is None:
+                            props = {}
+                    function_chain.append(
+                        {
+                            "name": props.get("name"),
+                            "path": props.get("path"),
+                            "line_number": props.get("line_number"),
+                            "is_dependency": props.get("is_dependency"),
+                        }
+                    )
+
+                call_details = []
+                for r in rel_nodes:
+                    if isinstance(r, dict):
+                        props = r
+                    else:
+                        props = None
+                        try:
+                            props = r.get_properties()
+                        except Exception:
+                            props = getattr(r, "properties", None)
+                        if props is None:
+                            props = {}
+                    call_details.append(
+                        {
+                            "call_line": props.get("line_number"),
+                            "args": props.get("args"),
+                            "full_call_name": props.get("full_call_name"),
+                        }
+                    )
+
+                transformed.append(
+                    {
+                        "function_chain": function_chain,
+                        "call_details": call_details,
+                        "chain_length": chain_len,
+                    }
+                )
+
+            return transformed
 
     def find_by_type(self, element_type: str, limit: int = 50) -> List[Dict]:
         """Find all elements of a specific type (Function, Class, File, Module)."""
@@ -998,9 +1049,10 @@ class CodeFinder:
         """Find the most complex functions based on cyclomatic complexity."""
         with self.driver.session() as session:
             repo_filter = "AND f.path STARTS WITH $repo_path" if repo_path else ""
+            path_ignore = cypher_path_not_under_ignore_dirs("f.path")
             query = f"""
                 MATCH (f:Function)
-                WHERE f.cyclomatic_complexity IS NOT NULL AND f.is_dependency = false {repo_filter}
+                WHERE f.cyclomatic_complexity IS NOT NULL AND f.is_dependency = false {repo_filter} {path_ignore}
                 RETURN f.name as function_name, f.path as path, f.cyclomatic_complexity as complexity, f.line_number as line_number
                 ORDER BY f.cyclomatic_complexity DESC
                 LIMIT $limit

{codegraphcontext-0.3.7 → codegraphcontext-0.3.8}/src/codegraphcontext/tools/graph_builder.py

@@ -14,9 +14,22 @@ from ..utils.debug_log import debug_log, info_logger, error_logger, warning_logg
 from tree_sitter import Language, Parser
 from ..utils.tree_sitter_manager import get_tree_sitter_manager
 from ..cli.config_manager import get_config_value
+from ..utils.path_ignore import file_path_has_ignore_dir_segment
 import fnmatch
  
 DEFAULT_IGNORE_PATTERNS = [
+    # Vendor / env dirs (gitignore-style; complements IGNORE_DIRS during indexing)
+    "node_modules/",
+    "venv/",
+    ".venv/",
+    "env/",
+    ".env/",
+    "dist/",
+    "build/",
+    "target/",
+    "out/",
+    ".git/",
+    "__pycache__/",
     "*.png",
     "*.jpg",
     "*.jpeg",
@@ -210,6 +223,12 @@ class GraphBuilder:
             except Exception as e:
                 warning_logger(f"Schema creation warning: {e}")
 
+    # Neo4j RANGE indexes have an ~8 kB key-size limit.  Long C++ template
+    # function names (e.g. from llama.cpp) can exceed this, causing
+    # "Property value is too large to index" errors.  We cap string properties
+    # at 4096 chars, which is comfortably under the 8 kB boundary.
+    _MAX_STR_LEN = 4096
+
     @staticmethod
     def _sanitize_props(props: Dict) -> Dict:
         """Return a copy of *props* with all values coerced to database-safe types.
@@ -220,9 +239,15 @@ class GraphBuilder:
         parsers (e.g. C's ``detailed_args`` or Scala's tuple ``class_context``)
         are serialized to a JSON string so the data is preserved rather than
         being silently dropped.
+
+        Additionally, string values are truncated to _MAX_STR_LEN characters to
+        avoid Neo4j's RANGE-index 8 kB property-size limit (triggered by very
+        long C++ template-mangled function names).
         """
         import json
 
+        MAX = GraphBuilder._MAX_STR_LEN
+
         def _is_primitive(v):
             return isinstance(v, (str, int, float, bool)) or v is None
 
@@ -230,15 +255,21 @@ class GraphBuilder:
             return isinstance(v, list) and all(_is_primitive(item) for item in v)
 
         def _coerce(v):
+            if isinstance(v, str):
+                # Truncate long strings to stay within Neo4j RANGE index limits
+                return v[:MAX] if len(v) > MAX else v
             if _is_primitive(v):
                 return v
             if _is_flat_list(v):
-                return v
+                # Truncate any long strings in lists too
+                return [s[:MAX] if isinstance(s, str) and len(s) > MAX else s for s in v]
             # Tuples, dicts, lists-of-dicts, nested structures → JSON string
             try:
-                return json.dumps(v, default=str)
+                serialized = json.dumps(v, default=str)
+                return serialized[:MAX] if len(serialized) > MAX else serialized
             except Exception:
-                return str(v)
+                s = str(v)
+                return s[:MAX] if len(s) > MAX else s
 
         return {k: _coerce(v) for k, v in props.items()}
 
@@ -446,8 +477,20 @@ class GraphBuilder:
                     # before writing to the database to avoid runtime errors such as
                     # "Property values can only be of primitive types or arrays of
                     # primitive types" raised by FalkorDB / KùzuDB.
+                    # _sanitize_props also truncates long strings to avoid Neo4j's
+                    # 8 kB RANGE-index limit (seen with long C++ template names).
                     safe_props = self._sanitize_props(item)
-                    session.run(query, path=file_path_str, name=item['name'], line_number=item['line_number'], props=safe_props)
+                    try:
+                        session.run(query, path=file_path_str, name=item['name'], line_number=item['line_number'], props=safe_props)
+                    except Exception as node_err:
+                        err_str = str(node_err)
+                        if "too large to index" in err_str or "property size" in err_str.lower():
+                            warning_logger(
+                                f"Skipping {label} '{item['name']}' in {file_path_str}: "
+                                f"property value too large for index (name length={len(item['name'])})"
+                            )
+                        else:
+                            raise  # Re-raise unexpected errors
                     
                     if label == 'Function':
                         for arg_name in item.get('args', []):
@@ -517,30 +560,51 @@ class GraphBuilder:
                     # Ensure full_import_name is available in params for SET clause
                     params = imp.copy()
                     params['path'] = file_path_str
-                    params['rel_props'] = rel_props
                     params['module_name'] = imp.get('name') # Use 'name' from imp as module name
 
+                    # Sanitize scalar params but keep rel_props as a dict
+                    # (FalkorDB SET r += $rel_props requires a map, not a string)
+                    sanitized = self._sanitize_props(params)
+                    sanitized['rel_props'] = rel_props
+
                     session.run(f"""
                         MATCH (f:File {{path: $path}})
                         MERGE (m:Module {{name: $module_name}})
                         {set_clause_str}
                         MERGE (f)-[r:IMPORTS]->(m)
                         SET r += $rel_props
-                    """, **params)
+                    """, **sanitized)
 
 
             # Handle CONTAINS relationship between class to their children like variables
             for func in file_data.get('functions', []):
                 if func.get('class_context'):
-                    session.run("""
+                    # Try same-file match first (Python, JS, etc.)
+                    if not self._safe_run_create(session, """
                         MATCH (c:Class {name: $class_name, path: $path})
                         MATCH (fn:Function {name: $func_name, path: $path, line_number: $func_line})
                         MERGE (c)-[:CONTAINS]->(fn)
-                    """, 
-                    class_name=func['class_context'],
-                    path=file_path_str,
-                    func_name=func['name'],
-                    func_line=func['line_number'])
+                        RETURN count(*) as created
+                    """, {
+                        'class_name': func['class_context'],
+                        'path': file_path_str,
+                        'func_name': func['name'],
+                        'func_line': func['line_number']
+                    }):
+                        # Cross-file match for C/C++ where class is in .h and method in .cpp.
+                        # Note: matches by class name only (no path constraint), so classes
+                        # with identical names in different files could get false links.
+                        self._safe_run_create(session, """
+                            MATCH (c:Class {name: $class_name})
+                            MATCH (fn:Function {name: $func_name, path: $path, line_number: $func_line})
+                            MERGE (c)-[:CONTAINS]->(fn)
+                            RETURN count(*) as created
+                        """, {
+                            'class_name': func['class_context'],
+                            'path': file_path_str,
+                            'func_name': func['name'],
+                            'func_line': func['line_number']
+                        })
 
             # --- NEW: Class INCLUDES Module (Ruby mixins) ---
             for inc in file_data.get('module_inclusions', []):
@@ -693,7 +757,7 @@ class GraphBuilder:
                 
                 # KùzuDB workaround: Try Function->Function first, then other combinations
                 # This avoids polymorphic MERGE which KùzuDB doesn't support
-                call_params = {
+                call_params = self._sanitize_props({
                     'caller_name': caller_name,
                     'caller_file_path': caller_file_path,
                     'caller_line_number': caller_line_number,
@@ -702,8 +766,9 @@ class GraphBuilder:
                     'line_number': call['line_number'],
                     'args': call.get('args', []),
                     'full_call_name': call.get('full_name', called_name)
-                }
-                 # Try Function caller -> Function callee
+                })
+
+                # Try Function caller -> Function callee
                 if not self._safe_run_create(session, """
                     OPTIONAL MATCH (caller:Function {name: $caller_name, path: $caller_file_path})
                     OPTIONAL MATCH (called:Function {name: $called_name, path: $called_file_path})
@@ -782,14 +847,15 @@ class GraphBuilder:
                                 """, call_params)
             else:
                 # File-level calls: Try Function first, then Class
-                call_params = {
+                call_params = self._sanitize_props({
                     '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)
-                }
+                })
+
 
                 if not self._safe_run_create(session, """
                     OPTIONAL MATCH (caller:File {path: $caller_file_path})
@@ -1162,13 +1228,16 @@ class GraphBuilder:
 
             # Step 4: Write nodes to graph using existing add_file_to_graph()
             processed = 0
+            index_root = path.resolve()
             for abs_path_str, file_data in files_data.items():
-                file_data["repo_path"] = str(path.resolve())
+                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:
                     self.job_manager.update_job(job_id, current_file=abs_path_str)
 
                 # Step 5: Tree-sitter supplement — add source text, complexity, imports and bases
-                file_path = Path(abs_path_str)
                 ts_parser = self.get_parser(file_path.suffix)
                 if file_path.exists() and ts_parser:
                     try: