codegraphcontext 0.3.5__py3-none-any.whl → 0.3.8__py3-none-any.whl

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/cli/setup_wizard.py

@@ -296,6 +296,12 @@ def run_command(command, console, shell=False, check=True, input_text=None):
     Returns the completed process object on success, None on failure.
     """
     cmd_str = command if isinstance(command, str) else ' '.join(command)
+    
+    # Mask passwords from being printed out
+    if "set-initial-password" in cmd_str:
+        import re
+        cmd_str = re.sub(r'(set-initial-password\s+)(\S+)', r'\g<1>********', cmd_str)
+        
     console.print(f"[cyan]$ {cmd_str}[/cyan]")
     try:
         process = subprocess.run(

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/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/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__)
 
@@ -539,9 +540,13 @@ class CodeFinder:
 
         with self.driver.session() as session:
             repo_filter = "AND func.path STARTS WITH $repo_path" if repo_path else ""
-            result = session.run(f"""
+            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'
@@ -550,10 +555,10 @@ class CodeFinder:
                   AND NOT toLower(func.name) CONTAINS 'application'
                   AND NOT toLower(func.name) CONTAINS 'entry'
                   AND NOT toLower(func.name) CONTAINS 'entrypoint'
-                  AND ALL(decorator_name IN $exclude_decorated_with WHERE NOT decorator_name IN func.decorators)
+                  {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)
@@ -566,7 +571,15 @@ class CodeFinder:
                     file.name as file_name
                 ORDER BY func.path, func.line_number
                 LIMIT 50
-            """, exclude_decorated_with=exclude_decorated_with, repo_path=repo_path)
+            """
+            
+            params = {}
+            if repo_path:
+                params["repo_path"] = repo_path
+            if exclude_decorated_with:
+                params["exclude_decorated_with"] = exclude_decorated_with
+                
+            result = session.run(query, **params)
             
             return {
                 "potentially_unused_functions": result.data(),
@@ -581,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
@@ -593,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
@@ -612,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
@@ -625,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
@@ -647,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
             """
@@ -679,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)."""
@@ -988,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/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:

codegraphcontext/tools/languages/cpp.py

@@ -11,6 +11,7 @@ CPP_QUERIES = {
                 declarator: [
                     (identifier) @name
                     (field_identifier) @name
+                    (qualified_identifier) @qualified_name
                 ]
             )
         ) @function_node
@@ -35,6 +36,7 @@ CPP_QUERIES = {
                 (field_expression
                     field: (field_identifier) @method_name
                 )
+                (qualified_identifier) @scoped_name
             ]
         arguments: (argument_list) @args
     )
@@ -158,36 +160,40 @@ class CppTreeSitterParser:
         for match in execute_query(self.language, query_str, root_node):
             capture_name = match[1]
             node = match[0]
-            if capture_name == 'name':
-                # node is identifier
-                # node.parent is function_declarator
-                # node.parent.parent is function_definition
-                func_node = node.parent.parent
-                
-                # Double check to prevent crashes if AST is different (e.g. pointers)
-                if func_node.type != 'function_definition':
-                    # Fallback or try finding function_definition upwards
-                    curr = node
-                    while curr and curr.type != 'function_definition':
-                        curr = curr.parent
-                    func_node = curr
-                
+            if capture_name in ('name', 'qualified_name'):
+                # Find the enclosing function_definition node
+                func_node = node.parent
+                while func_node and func_node.type != 'function_definition':
+                    func_node = func_node.parent
+
                 if not func_node: continue
 
-                name = self._get_node_text(node)
-                
+                # For qualified names like QueueElement::execute, extract
+                # both the class context and the method name
+                raw_text = self._get_node_text(node)
+                class_context = None
+                if capture_name == 'qualified_name' and '::' in raw_text:
+                    parts = raw_text.rsplit('::', 1)
+                    class_context = parts[0]
+                    name = parts[1]
+                else:
+                    name = raw_text
+
                 params = self._extract_function_params(func_node)
-                
+
                 func_data = {
                     "name": name,
                     "line_number": node.start_point[0] + 1,
                     "end_line": func_node.end_point[0] + 1,
                     "args": params,
                 }
-                
+
+                if class_context:
+                    func_data["class_context"] = class_context
+
                 if self.index_source:
                     func_data["source"] = self._get_node_text(func_node)
-                
+
                 functions.append(func_data)
         return functions
 
@@ -238,17 +244,52 @@ class CppTreeSitterParser:
             if capture_name == 'name':
                 class_node = node.parent
                 name = self._get_node_text(node)
+                bases = self._extract_base_classes(class_node)
                 class_data = {
                     "name": name,
                     "line_number": node.start_point[0] + 1,
                     "end_line": class_node.end_point[0] + 1,
-                    "bases": [], # Placeholder
+                    "bases": bases,
                 }
                 if self.index_source:
                     class_data["source"] = self._get_node_text(class_node)
                 classes.append(class_data)
         return classes
 
+    def _extract_base_classes(self, class_node) -> list[str]:
+        """Extract base class names from a class_specifier node.
+
+        Handles: class Foo : public Bar, private Baz, virtual Base
+        Tree-sitter AST: class_specifier -> base_class_clause -> (base_class_specifier)+
+        Each base_class_specifier has an optional access_specifier and a type node.
+        """
+        bases = []
+        for child in class_node.children:
+            if child.type == 'base_class_clause':
+                for base_spec in child.children:
+                    if base_spec.type in ('base_class_specifier', 'type_identifier',
+                                          'qualified_identifier', 'template_type'):
+                        # base_class_specifier contains access specifier + type
+                        if base_spec.type == 'base_class_specifier':
+                            # Find the type identifier within the base specifier
+                            for sub in base_spec.children:
+                                if sub.type in ('type_identifier', 'qualified_identifier',
+                                                'template_type'):
+                                    base_name = self._get_node_text(sub)
+                                    # Strip template args for graph matching
+                                    if '<' in base_name:
+                                        base_name = base_name[:base_name.index('<')].strip()
+                                    bases.append(base_name)
+                                    break
+                        else:
+                            # Direct type node (no access specifier)
+                            base_name = self._get_node_text(base_spec)
+                            if '<' in base_name:
+                                base_name = base_name[:base_name.index('<')].strip()
+                            bases.append(base_name)
+                break  # Only one base_class_clause per class
+        return bases
+
     def _find_imports(self, root_node):
         imports = []
         query_str = CPP_QUERIES['imports']
@@ -270,6 +311,7 @@ class CppTreeSitterParser:
         query_str = CPP_QUERIES['enums']
         for node, capture_name in execute_query(self.language, query_str, root_node):
             if capture_name == 'name':
+                name = self._get_node_text(node)
                 enum_node = node.parent
                 enum_data = {
                     "name": name,
@@ -346,17 +388,17 @@ class CppTreeSitterParser:
             if capture_name == 'name':
                 assignment_node = node.parent
                 lambda_node = assignment_node.child_by_field_name('value')
-            if lambda_node is None or lambda_node.type != 'lambda_expression':
-                continue
+                if lambda_node is None or lambda_node.type != 'lambda_expression':
+                    continue
 
-            params_node = lambda_node.child_by_field_name('declarator')
-            if params_node:
-                params_node = params_node.child_by_field_name('parameters')
+                params_node = lambda_node.child_by_field_name('declarator')
+                if params_node:
+                    params_node = params_node.child_by_field_name('parameters')
                 name = self._get_node_text(node)
                 params_node = lambda_node.child_by_field_name('parameters')
-                
+
                 context, context_type, _ = self._get_parent_context(assignment_node)
-                class_context, _, _ = self._get_parent_context(assignment_node, types=('class_definition',))
+                class_context, _, _ = self._get_parent_context(assignment_node, types=('class_specifier',))
 
                 func_data = {
                     "name": name,
@@ -402,7 +444,7 @@ class CppTreeSitterParser:
                 type_text = self._get_node_text(type_node) if type_node else None
 
                 context, _, _ = self._get_parent_context(node)
-                class_context, _, _ = self._get_parent_context(node, types=('class_definition',))
+                class_context, _, _ = self._get_parent_context(node, types=('class_specifier',))
 
                 variable_data = {
                     "name": name,
@@ -417,17 +459,24 @@ class CppTreeSitterParser:
                 variables.append(variable_data)
         return variables
     
-    def _get_parent_context(self, node, types=('function_definition', 'class_definition')):
+    def _get_parent_context(self, node, types=('function_definition', 'class_specifier')):
         curr = node.parent
         while curr:
             if curr.type in types:
                 if curr.type == 'function_definition':
-                    # Traverse declarator to find name
+                    # Traverse declarator to find name, handling qualified names
                     decl = curr.child_by_field_name('declarator')
                     while decl:
                         if decl.type == 'identifier':
                              return self._get_node_text(decl), curr.type, decl.start_point[0] + 1
-                        
+                        if decl.type == 'qualified_identifier':
+                            # e.g. QueueElement::execute — return just the method name
+                            text = self._get_node_text(decl)
+                            name = text.rsplit('::', 1)[-1] if '::' in text else text
+                            return name, curr.type, decl.start_point[0] + 1
+                        if decl.type == 'field_identifier':
+                            return self._get_node_text(decl), curr.type, decl.start_point[0] + 1
+
                         child = decl.child_by_field_name('declarator')
                         if child:
                             decl = child
@@ -435,6 +484,9 @@ class CppTreeSitterParser:
                             break
                     # Fallback or if not found
                     return None, curr.type, curr.start_point[0] + 1
+                elif curr.type == 'class_specifier':
+                    name_node = curr.child_by_field_name('name')
+                    return self._get_node_text(name_node) if name_node else None, curr.type, curr.start_point[0] + 1
                 else:
                     name_node = curr.child_by_field_name('name')
                     return self._get_node_text(name_node) if name_node else None, curr.type, curr.start_point[0] + 1
@@ -445,49 +497,43 @@ class CppTreeSitterParser:
         calls = []
         query_str = CPP_QUERIES['calls']
         for node, capture_name in execute_query(self.language, query_str, root_node):
-            if capture_name == "function_name":
-                func_name = self._get_node_text(node)
-                func_node = node.parent.parent  # function_declarator -> function_definition
-                full_name = self._get_full_name(func_node) or func_name
-
-                # Find return type node (captured separately)
-                return_type_node = None
-                for n, cap in execute_query(self.language, query_str, func_node):
-                    if cap == "return_type":
-                        return_type_node = n
-                        break
-                return_type = self._get_node_text(return_type_node) if return_type_node else None
-
-                # Extract parameters
-                args = []
-                parameters_node = func_node.child_by_field_name("declarator")
-                if parameters_node:
-                    param_list_node = parameters_node.child_by_field_name("parameters")
-                    if param_list_node:
-                        for param in param_list_node.children:
-                            if param.type == "parameter_declaration":
-                                type_node = param.child_by_field_name("type")
-                                name_node = param.child_by_field_name("declarator")
-
-                                param_type = self._get_node_text(type_node) if type_node else None
-                                param_name = self._get_node_text(name_node) if name_node else None
-
-                                args.append({
-                                    "type": param_type,
-                                    "name": param_name
-                                })
-                
+            if capture_name in ("function_name", "method_name", "scoped_name"):
+                raw_text = self._get_node_text(node)
+
+                # Determine the called function name and any object/class qualifier
+                inferred_obj_type = None
+                if capture_name == "scoped_name" and '::' in raw_text:
+                    # e.g. QueueElement::setStatus or std::move
+                    parts = raw_text.rsplit('::', 1)
+                    func_name = parts[1]
+                    inferred_obj_type = parts[0]
+                elif capture_name == "method_name":
+                    # e.g. obj.method() or ptr->method() — field_expression
+                    func_name = raw_text
+                    # Try to get the object expression for type inference
+                    field_expr = node.parent  # field_expression node
+                    if field_expr and field_expr.type == 'field_expression':
+                        obj_node = field_expr.child_by_field_name('argument')
+                        if obj_node:
+                            obj_text = self._get_node_text(obj_node)
+                            # Treat this->method like self.method for resolution
+                            if obj_text == 'this':
+                                inferred_obj_type = 'this'
+                            else:
+                                inferred_obj_type = obj_text
+                else:
+                    func_name = raw_text
 
-                # Get context info (function may be inside class)
+                # Get context info (which function/class contains this call)
                 context_name, context_type, context_line = self._get_parent_context(node)
-                class_context, _, _ = self._get_parent_context(node, types=("class_definition",))
+                class_context, _, _ = self._get_parent_context(node, types=("class_specifier",))
 
                 call_data = {
                     "name": func_name,
-                    "full_name": full_name,
+                    "full_name": raw_text,
                     "line_number": node.start_point[0] + 1,
-                    "args": args,
-                    "inferred_obj_type": None,
+                    "args": [],
+                    "inferred_obj_type": inferred_obj_type,
                     "context": (context_name, context_type, context_line),
                     "class_context": class_context,
                     "lang": self.language_name,
@@ -506,8 +552,12 @@ class CppTreeSitterParser:
         while curr:
             if curr.type in ("function_definition", "function_declarator"):
                 id_node = curr.child_by_field_name("declarator")
-                if id_node and id_node.type == "identifier":
-                    name_parts.insert(0, id_node.text.decode("utf8"))
+                if id_node:
+                    if id_node.type == "identifier":
+                        name_parts.insert(0, id_node.text.decode("utf8"))
+                    elif id_node.type == "qualified_identifier":
+                        # Already contains Class::method — use it directly
+                        return id_node.text.decode("utf8")
             elif curr.type == "class_specifier":
                 name_node = curr.child_by_field_name("name")
                 if name_node:
@@ -532,8 +582,9 @@ def pre_scan_cpp(files: list[Path], parser_wrapper) -> dict:
         (class_specifier name: (type_identifier) @name)
         (struct_specifier name: (type_identifier) @name)
         (function_definition declarator: (function_declarator declarator: (identifier) @name))
+        (function_definition declarator: (function_declarator declarator: (qualified_identifier) @qualified_name))
     """
-    
+
 
     for path in files:
         try:
@@ -542,9 +593,23 @@ def pre_scan_cpp(files: list[Path], parser_wrapper) -> dict:
                 tree = parser_wrapper.parser.parse(source_bytes)
 
             for node, capture_name in execute_query(parser_wrapper.language, query_str, tree.root_node):
+                resolved_path = str(path.resolve())
                 if capture_name == "name":
                     name = node.text.decode("utf-8")
-                    imports_map.setdefault(name, []).append(str(path.resolve()))
+                    paths = imports_map.setdefault(name, [])
+                    if resolved_path not in paths:
+                        paths.append(resolved_path)
+                elif capture_name == "qualified_name":
+                    # e.g. QueueElement::execute — index both the full name and the method name
+                    full_name = node.text.decode("utf-8")
+                    paths = imports_map.setdefault(full_name, [])
+                    if resolved_path not in paths:
+                        paths.append(resolved_path)
+                    if '::' in full_name:
+                        method_name = full_name.rsplit('::', 1)[1]
+                        paths = imports_map.setdefault(method_name, [])
+                        if resolved_path not in paths:
+                            paths.append(resolved_path)
         except Exception as e:
             warning_logger(f"Tree-sitter pre-scan failed for {path}: {e}")
 

codegraphcontext/tools/languages/go.py

@@ -79,6 +79,7 @@ class GoTreeSitterParser:
         self.language_name = generic_parser_wrapper.language_name
         self.language = generic_parser_wrapper.language
         self.parser = generic_parser_wrapper.parser
+        self.index_source = False
 
     def _get_node_text(self, node) -> str:
         return node.text.decode('utf-8')
@@ -99,17 +100,52 @@ class GoTreeSitterParser:
         return None, None, None
 
     def _calculate_complexity(self, node):
-        complexity_nodes = {
-            "if_statement", "for_statement", "switch_statement", "case_clause",
-            "expression_switch_statement", "type_switch_statement",
-            "binary_expression", "call_expression"
+        """
+        Compute a simple cyclomatic complexity score from the Go AST.
+
+        We treat each decision/control-flow construct as +1:
+        - if/for/switch/select
+        - switch cases (case_clause) and select clauses (comm_clause)
+        - logical operators (&&, ||) inside binary_expression as +1
+        """
+        # Note: tree-sitter-go node types differ from other languages and from
+        # what we'd typically expect (e.g. it's `switch`/`case` rather than
+        # `switch_statement`/`case_clause`).
+        decision_node_types = {
+            # top-level control constructs
+            "if_statement",
+            "for_statement",
+            "switch",
+            "select_statement",
+            "select",
+            # switch variants (tree-sitter grammar)
+            "expression_switch_statement",
+            "type_switch_statement",
+            # switch case branches
+            "case",
+            "expression_case",
+            "default_case",
+            # select communication branches
+            "communication_case",
         }
+
         count = 1
 
         def traverse(n):
             nonlocal count
-            if n.type in complexity_nodes:
+            if n.type in decision_node_types:
                 count += 1
+                # Still traverse children because nested constructs also contribute.
+            elif n.type == "binary_expression":
+                # Only count logical operators, not all binary expressions/comparisons.
+                # Example patterns: "a && b", "a || b".
+                try:
+                    txt = self._get_node_text(n)
+                except Exception:
+                    txt = ""
+                if "&&" in txt or "||" in txt:
+                    count += 1
+
             for child in n.children:
                 traverse(child)
 
@@ -240,6 +276,7 @@ class GoTreeSitterParser:
                     "decorators": [],
                     "lang": self.language_name,
                     "is_dependency": False,
+                    "cyclomatic_complexity": self._calculate_complexity(func_node),
                 }
                 
                 if self.index_source:

codegraphcontext/utils/path_ignore.py

@@ -0,0 +1,55 @@
+"""
+Path segment helpers aligned with IGNORE_DIRS indexing rules.
+
+`is_dependency` on graph nodes marks separately indexed packages, not vendored
+dirs inside a repo (e.g. node_modules). Analysis queries must also exclude
+those paths when IGNORE_DIRS would skip them during indexing.
+"""
+
+from pathlib import Path
+from typing import List, Optional
+
+from ..cli.config_manager import DEFAULT_CONFIG, get_config_value
+
+
+def parse_ignore_dir_names() -> List[str]:
+    """Directory names from IGNORE_DIRS, falling back to defaults when unset or empty."""
+    raw = (get_config_value("IGNORE_DIRS") or "").strip()
+    if not raw:
+        raw = DEFAULT_CONFIG["IGNORE_DIRS"]
+    return [d.strip() for d in raw.split(",") if d.strip()]
+
+
+def cypher_path_not_under_ignore_dirs(path_var: str, ignore_dir_names: Optional[List[str]] = None) -> str:
+    """
+    Returns a Cypher fragment that keeps only paths not under any IGNORE_DIRS segment
+    (Unix `/name/` or Windows `\\name\\`).
+    """
+    names = ignore_dir_names if ignore_dir_names is not None else parse_ignore_dir_names()
+    if not names:
+        return ""
+    parts: List[str] = []
+    for d in names:
+        esc = d.replace("\\", "\\\\").replace("'", "\\'")
+        parts.append(f"{path_var} CONTAINS '/{esc}/'")
+        parts.append(f"{path_var} CONTAINS '\\\\{esc}\\\\'")
+    return " AND NOT (" + " OR ".join(parts) + ")"
+
+
+def file_path_has_ignore_dir_segment(file_path: Path, index_root: Path) -> bool:
+    """
+    True if any directory segment of file_path relative to index_root matches
+    IGNORE_DIRS (same logic as Tree-sitter indexing).
+    """
+    ignore_dirs_str = (get_config_value("IGNORE_DIRS") or "").strip()
+    if not ignore_dirs_str:
+        ignore_dirs_str = DEFAULT_CONFIG["IGNORE_DIRS"]
+    ignore_dirs = {d.strip().lower() for d in ignore_dirs_str.split(",") if d.strip()}
+    if not ignore_dirs:
+        return False
+    try:
+        rel = file_path.resolve().relative_to(index_root.resolve())
+        parts = {p.lower() for p in rel.parent.parts}
+        return bool(parts.intersection(ignore_dirs))
+    except ValueError:
+        return False

codegraphcontext/utils/tree_sitter_manager.py

@@ -60,6 +60,11 @@ LANGUAGE_ALIASES = {
     "exs": "elixir",
 }
 
+# Canonical names that differ from tree-sitter-language-pack names
+LANGUAGE_PACK_NAMES = {
+    "c_sharp": "csharp",
+}
+
 
 class TreeSitterManager:
     """
@@ -128,15 +133,9 @@ class TreeSitterManager:
                 return self._language_cache[canonical_name]
             
             try:
-                # Special handling for C# which is available as tree_sitter_c_sharp
-                if canonical_name == "c_sharp":
-                    import tree_sitter_c_sharp
-                    # tree_sitter_c_sharp.language() returns a PyCapsule, wrap it in Language
-                    capsule = tree_sitter_c_sharp.language()
-                    language = Language(capsule)
-                else:
-                    # Load the language from tree-sitter-language-pack
-                    language = get_language(canonical_name)
+                # Map canonical name to language-pack name where they differ
+                pack_name = LANGUAGE_PACK_NAMES.get(canonical_name, canonical_name)
+                language = get_language(pack_name)
                 
                 self._language_cache[canonical_name] = language
                 return language

{codegraphcontext-0.3.5.dist-info → codegraphcontext-0.3.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.3.5
+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
@@ -41,7 +41,7 @@ Requires-Dist: watchdog>=3.0.0
 Requires-Dist: stdlibs>=2023.11.18
 Requires-Dist: typer[all]>=0.9.0
 Requires-Dist: rich>=13.7.0
-Requires-Dist: inquirerpy>=0.3.5
+Requires-Dist: inquirerpy>=0.3.4
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: tree-sitter>=0.21.0
 Requires-Dist: tree-sitter-language-pack>=0.6.0
@@ -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.5
+- **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/)
@@ -249,7 +250,7 @@ _If you’re using CodeGraphContext in your project, feel free to open a PR and
 - `stdlibs>=2023.11.18`
 - `typer[all]>=0.9.0`
 - `rich>=13.7.0`
-- `inquirerpy>=0.3.5`
+- `inquirerpy>=0.3.7`
 - `python-dotenv>=1.0.0`
 - `tree-sitter>=0.21.0`
 - `tree-sitter-language-pack>=0.6.0`
@@ -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.5.dist-info → codegraphcontext-0.3.8.dist-info}/RECORD

@@ -1,15 +1,15 @@
 codegraphcontext/__init__.py,sha256=mFY5raGZpG90gG6E8NH0R85mDl3Ikak2HQHOiwCXl-I,77
 codegraphcontext/__main__.py,sha256=21QjL_lfd6cy-clJYPBg6xKb_IuNDcvvWdaAJEvZ-HQ,99
 codegraphcontext/prompts.py,sha256=E5P55paM0oHfBcNVfxkxpXRGZnya1kr_mKDg9i49FwM,6755
-codegraphcontext/server.py,sha256=gcb6V4x0Oh8haBOCm2WBjTCO9FDukrSalAMMApL-oc8,12806
+codegraphcontext/server.py,sha256=Rz6Exa99INSaHKdeIBDQwwMoDOFJY8vhuXwEAdqs6qg,13917
 codegraphcontext/tool_definitions.py,sha256=_0ahezQSURX_ewWydT2sFcvC6OFGdMoPA7KwgWNVcks,11482
 codegraphcontext/cli/__init__.py,sha256=v6CMDVKM5d_sXn3S5nZNf0phXn0IdrnhLazUoen9k9w,38
-codegraphcontext/cli/cli_helpers.py,sha256=QcpEV9VRFuPiiIEUwiXCr_nm7Z7amzphXv9zQY0aWIU,29646
+codegraphcontext/cli/cli_helpers.py,sha256=sWm9TLWy8GahX3htlonz5wO54DUV_OqkkvT9ohNVR1M,29777
 codegraphcontext/cli/config_manager.py,sha256=MK7GMGZ4hd8-ZOShXBd_KDtNqHQ3ngdbef5KM_naPrQ,15899
 codegraphcontext/cli/main.py,sha256=89jWaO8Gr3nRdLQtfwF434wpU77d5bJwt016f_lLnGg,86486
 codegraphcontext/cli/registry_commands.py,sha256=30rJm4SeS0n1jax4JVuhuv4zYLzyMmlHcCSnsDDhgc8,19964
 codegraphcontext/cli/setup_macos.py,sha256=Xjlv_9jk9qv8Gh7stpH1pvlalzC0Fg176y7jc5G1zh0,3575
-codegraphcontext/cli/setup_wizard.py,sha256=yVXKqvAtUM0UC4tUreiS6C5utJbBO5Et2MiPUPWit9s,41393
+codegraphcontext/cli/setup_wizard.py,sha256=UptvbVfHPudIkoO8idWpEuomweIBsXEm9yNw21PXFvc,41598
 codegraphcontext/cli/visualizer.py,sha256=YgqXA-o1l3qRABat_s-wT0gTM_rmHmOhpUtxS7Rhcfk,1861
 codegraphcontext/core/__init__.py,sha256=r-dC2b8hn5e4ZBVfWnCcBYMTQVcayxG5-eA5Do6uSM4,7278
 codegraphcontext/core/bundle_registry.py,sha256=kLvTLEl99QwfyAw8a7-4hqconLCtS64G9ECPVdfVBsM,7476
@@ -17,14 +17,14 @@ codegraphcontext/core/cgc_bundle.py,sha256=lxaImBnEJMiscrGssLTgLaeEa7tY33xztjbxO
 codegraphcontext/core/database.py,sha256=2UL8AyE6vX5mVHg1zcD74TYEREmddhKzN7Bjy2THQwM,11435
 codegraphcontext/core/database_falkordb.py,sha256=IKRcUwqdCR92ymX9rNAQSs49RWPxug_78utwePEcliQ,18842
 codegraphcontext/core/database_falkordb_remote.py,sha256=aMiuJTB_-2rBUpbAmX8ElZiZrYZbOXK-On3ncgMCyhY,7118
-codegraphcontext/core/database_kuzu.py,sha256=YklmEaUVWJkO22FXnlZNbuPT7A0bSc75Va80g8Pmv9M,22799
+codegraphcontext/core/database_kuzu.py,sha256=3SkKI-BtsMfSIbt-ZIavB113xtht1LszPGMdZk4Zpbs,23578
 codegraphcontext/core/falkor_worker.py,sha256=bMcTOac6e8IzSPjCd-YulGVh-S7QsNtXs2c8hx6M6gk,4958
 codegraphcontext/core/jobs.py,sha256=d6v_IERdEcDlIsz3CW3p0QMp3N-6dgQICs3FZRPgPgU,4809
 codegraphcontext/core/watcher.py,sha256=42AWDv7LUE5v_HlY_Rvvlk8deDdlUBvM3hI-DMDWAOk,9813
 codegraphcontext/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 codegraphcontext/tools/advanced_language_query_tool.py,sha256=APtC-KSkXXSrVLwiw3kgi6Q-xaqXl6skLWHPyuNh358,3670
-codegraphcontext/tools/code_finder.py,sha256=2wd05dMrPW8xZDBUixS4BaipNbrE4rttqSD6JYEeQM4,55552
-codegraphcontext/tools/graph_builder.py,sha256=FaEeXQP5gdDclrXKjhWiwbmWXBEPadmqdeHZ2bWLK5A,81339
+codegraphcontext/tools/code_finder.py,sha256=RwhS2uelcRmkL8TsQze0D2aXRUWEmKbBTVzhyXkq5ds,58271
+codegraphcontext/tools/graph_builder.py,sha256=5cudzFiymG1J1SQ-JWnl-AdeMI3CvaHnl9ZaNGdtuQ4,84927
 codegraphcontext/tools/package_resolver.py,sha256=KtbdMReTezszjdsqYniL-Xb-QUsrAJWtf1NSiyIPkLI,18704
 codegraphcontext/tools/scip_indexer.py,sha256=gxe5-f090wonHEWYDT1CV6b3SpSTQtwng6A1SfPX_LA,19970
 codegraphcontext/tools/scip_pb2.py,sha256=dwOMNKlu6VyLq5h8kTPZRDqxrwfVL8yw7I7ziokFG48,98229
@@ -35,11 +35,11 @@ codegraphcontext/tools/handlers/management_handlers.py,sha256=jCosISjq4QD7oBa8Za
 codegraphcontext/tools/handlers/query_handlers.py,sha256=Go_qhx2XXcymlEiU8JC16PHTyrLQo59drauAPytUQZA,3508
 codegraphcontext/tools/handlers/watcher_handlers.py,sha256=9hBkMdI8mwQyXj77WvgyUWCtNeItV3DiCLnmNI7Xjp8,3623
 codegraphcontext/tools/languages/c.py,sha256=mrXQWEvMtzLVElATYNZ7VThNk1ZNZdw2UV8i6r2y2y4,22291
-codegraphcontext/tools/languages/cpp.py,sha256=JgQnQDtEvNFz7ZZD35buQG-Kwyqto54resVICCy2N6U,21745
+codegraphcontext/tools/languages/cpp.py,sha256=aXBF_MX43PpRTr5U7UBcn5mZvP6fjP4Q8g21JuCho38,25761
 codegraphcontext/tools/languages/csharp.py,sha256=0ZIpV531i8yhz4vktaKkzbHDg-TCxgSZPC69SBkmfYU,22594
 codegraphcontext/tools/languages/dart.py,sha256=RXs4OhyGuFM7l4WH42dSfmgt1HTqwfobx0hFqnQ2rg0,15030
 codegraphcontext/tools/languages/elixir.py,sha256=mFsMvi_5ZlCsrB5QQ7Kklj94tLo3D6aFU7ukuhGmGSI,18815
-codegraphcontext/tools/languages/go.py,sha256=E8wdJDfaojdRw2nN47ZVg3ByViX0nJtJake9l8r40hM,19016
+codegraphcontext/tools/languages/go.py,sha256=cBfeM3Qt9W73KKb39VPhS6LlcWLdVJpvrAnnUeSiH4E,20456
 codegraphcontext/tools/languages/haskell.py,sha256=ewXkp4HipC2yMkfhUwobjk5RXTlSnXd4tqzoja4W6ck,24008
 codegraphcontext/tools/languages/java.py,sha256=5lu8qY8zG2Xl2sFTXLx-pZLU3a1CDbvMnwxcwTuyQNs,20707
 codegraphcontext/tools/languages/javascript.py,sha256=W7PaY2r7KKDQ2Mw1cp20b9ZI_Y5JQB5FYL6xeYDxl1I,24291
@@ -69,12 +69,13 @@ codegraphcontext/tools/query_tool_languages/scala_toolkit.py,sha256=dbSMAUNZOBS7
 codegraphcontext/tools/query_tool_languages/swift_toolkit.py,sha256=qg5VHM4-xkAiSOt7cbcYymLg9G-uAKlzgKnIrRSEgJU,207
 codegraphcontext/tools/query_tool_languages/typescript_toolkit.py,sha256=3S4hpmOpEyaHoTP5ZdElFNkVyMZZDL_Gl4-DF0We1Mg,211
 codegraphcontext/utils/debug_log.py,sha256=Qg7jwyeg7x2h3Ur_2S34bdMCkHdlk_ngHfPwa97A9vE,2836
-codegraphcontext/utils/tree_sitter_manager.py,sha256=bIuKYN1aj1Zi6BnksGjZSLZzgBwuFRselZzyUpbToAU,9180
+codegraphcontext/utils/path_ignore.py,sha256=WPIcDmyAi6eL9692rPBQrUZunn5gHRb57nzNRHSIq28,2124
+codegraphcontext/utils/tree_sitter_manager.py,sha256=qYFAfDcMRtJ712bf8IMEZlBKsnY3-mbreCqJEOnmiuM,8975
 codegraphcontext/utils/visualize_graph.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 codegraphcontext/viz/server.py,sha256=Yu4fwMC2FsE6KUt7oYNlcE3GpCrblstkwUIVaGXTPYI,12767
-codegraphcontext-0.3.5.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
-codegraphcontext-0.3.5.dist-info/METADATA,sha256=rkKzmh5bAjIJNVO_ShCsjn54nCb2dCOySSpT9Ptlo_Y,21685
-codegraphcontext-0.3.5.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-codegraphcontext-0.3.5.dist-info/entry_points.txt,sha256=LCxWCWMshdvYGoHBPuQZ8C-e4CiNSHCLXofrNSGHkoE,103
-codegraphcontext-0.3.5.dist-info/top_level.txt,sha256=CBgc6LAPZIO5FS0nSYYkylDifHsZTIqw3Gf5UwDxeGI,17
-codegraphcontext-0.3.5.dist-info/RECORD,,
+codegraphcontext-0.3.8.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
+codegraphcontext-0.3.8.dist-info/METADATA,sha256=gH5p3c4aTnpthV2hOeqrK2013T5ASgTH5eJ_WvB2v2g,21613
+codegraphcontext-0.3.8.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+codegraphcontext-0.3.8.dist-info/entry_points.txt,sha256=LCxWCWMshdvYGoHBPuQZ8C-e4CiNSHCLXofrNSGHkoE,103
+codegraphcontext-0.3.8.dist-info/top_level.txt,sha256=CBgc6LAPZIO5FS0nSYYkylDifHsZTIqw3Gf5UwDxeGI,17
+codegraphcontext-0.3.8.dist-info/RECORD,,