codegraphcontext 0.4.8__tar.gz → 0.4.9__tar.gz

{codegraphcontext-0.4.8/src/codegraphcontext.egg-info → codegraphcontext-0.4.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.4.8
+Version: 0.4.9
 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
@@ -167,7 +167,7 @@ A powerful **MCP server** and **CLI toolkit** that indexes local code into a gra
 ---
 
 ## Project Details
-- **Version:** 0.4.8
+- **Version:** 0.4.9
 - **Authors:** Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 - **License:** MIT License (See [LICENSE](LICENSE) for details)
 - **Website:** [CodeGraphContext](http://codegraphcontext.vercel.app/)

{codegraphcontext-0.4.8 → codegraphcontext-0.4.9}/README.md

@@ -98,7 +98,7 @@ A powerful **MCP server** and **CLI toolkit** that indexes local code into a gra
 ---
 
 ## Project Details
-- **Version:** 0.4.8
+- **Version:** 0.4.9
 - **Authors:** Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 - **License:** MIT License (See [LICENSE](LICENSE) for details)
 - **Website:** [CodeGraphContext](http://codegraphcontext.vercel.app/)

{codegraphcontext-0.4.8 → codegraphcontext-0.4.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codegraphcontext"
-version = "0.4.8"
+version = "0.4.9"
 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"

{codegraphcontext-0.4.8 → codegraphcontext-0.4.9}/src/codegraphcontext/cli/cli_helpers.py

@@ -87,8 +87,9 @@ def _initialize_services(cli_context_flag: Optional[str] = None) -> tuple[Any, A
         ):
             os.environ["DEFAULT_DATABASE"] = ctx.database
         
-        # Pass the exact DB path resolved from the context
-        db_manager = get_database_manager(db_path=ctx.db_path)
+        # Pass the exact DB path resolved from the context, or the runtime override
+        runtime_path = os.getenv("CGC_RUNTIME_DB_PATH")
+        db_manager = get_database_manager(db_path=runtime_path or ctx.db_path)
     except ValueError as e:
         console.print(f"[bold red]Database Configuration Error:[/bold red] {e}")
         return None, None, None, ctx

{codegraphcontext-0.4.8 → codegraphcontext-0.4.9}/src/codegraphcontext/cli/config_manager.py

@@ -634,10 +634,17 @@ def _default_global_db_path(database: str) -> str:
     """Return the canonical DB path for the global context.
 
     New layout: ``~/.codegraphcontext/global/db/<backend>/``
-    For backward-compat, if the legacy flat path exists we keep using it.
+    For backward-compat, we check:
+    1. FALKORDB_PATH in config (if database is falkordb)
+    2. Legacy flat path
+    3. New layout default
     """
-    if database == "falkordb" and _LEGACY_FALKORDB_PATH.exists():
-        return str(_LEGACY_FALKORDB_PATH)
+    if database == "falkordb":
+        custom_path = load_config().get("FALKORDB_PATH")
+        if custom_path:
+            return str(Path(custom_path).resolve())
+        if _LEGACY_FALKORDB_PATH.exists():
+            return str(_LEGACY_FALKORDB_PATH)
     return str(CONFIG_DIR / "global" / "db" / database)
 
 

{codegraphcontext-0.4.8 → codegraphcontext-0.4.9}/src/codegraphcontext/cli/main.py

@@ -2552,12 +2552,22 @@ def main(
         "-h",
         help="[Root-level only] Show help and exit",
         is_eager=True,
-    ), 
+    ),
+    db_path: Optional[str] = typer.Option(
+        None,
+        "--path",
+        "--db-path",
+        help="[Global] Temporarily override database path (for local DBs like KuzuDB)"
+    ),
 ):
     """
     Main entry point for the cgc CLI application.
     If no subcommand is provided, it displays a welcome message with instructions.
     """
+    if db_path:
+        os.environ["CGC_RUNTIME_DB_PATH"] = db_path
+    if database:
+        os.environ["CGC_RUNTIME_DB_TYPE"] = database
     # Initialize context object for sharing state with subcommands
     ctx.ensure_object(dict)
     

{codegraphcontext-0.4.8 → codegraphcontext-0.4.9}/src/codegraphcontext/core/database_falkordb.py

@@ -335,7 +335,7 @@ class FalkorDBDriverWrapper:
     def __init__(self, graph):
         self.graph = graph
     
-    def session(self):
+    def session(self, **kwargs):
         """Returns a session-like object for FalkorDB."""
         return FalkorDBSessionWrapper(self.graph)
     
@@ -377,7 +377,7 @@ class FalkorDBSessionWrapper:
         except Exception as e:
             # Ignore errors about existing constraints/indexes
             error_msg = str(e).lower()
-            if "already exists" in error_msg or "already created" in error_msg:
+            if "already exists" in error_msg or "already created" in error_msg or "already indexed" in error_msg:
                 return FalkorDBResultWrapper(None)
                 
             error_logger(f"FalkorDB query failed: {query[:100]}... Error: {e}")

{codegraphcontext-0.4.8 → codegraphcontext-0.4.9}/src/codegraphcontext/core/database_kuzu.py

@@ -106,7 +106,7 @@ class KuzuDBManager:
             ("Repository", "path STRING, name STRING, is_dependency BOOLEAN, indexed_at STRING, commit_hash STRING, PRIMARY KEY (path)"),
             ("File", "path STRING, name STRING, relative_path STRING, package_name STRING, is_dependency BOOLEAN, PRIMARY KEY (path)"),
             ("Directory", "path STRING, name STRING, PRIMARY KEY (path)"),
-            ("Module", "name STRING, lang STRING, full_import_name STRING, PRIMARY KEY (name)"),
+            ("Module", "name STRING, lang STRING, full_import_name STRING, path STRING, line_number INT64, PRIMARY KEY (name)"),
             # For types with composite keys (name, path, line_number), we use a 'uid'
             ("Function", "uid STRING, name STRING, path STRING, line_number INT64, end_line INT64, source STRING, docstring STRING, lang STRING, cyclomatic_complexity INT64, context STRING, context_type STRING, class_context STRING, class_context_line INT64, is_dependency BOOLEAN, decorators STRING[], args STRING[], http_method STRING, http_path STRING, PRIMARY KEY (uid)"),
             ("Class", "uid STRING, name STRING, path STRING, line_number INT64, end_line INT64, source STRING, docstring STRING, lang STRING, node_type STRING, is_dependency BOOLEAN, decorators STRING[], PRIMARY KEY (uid)"),
@@ -120,7 +120,12 @@ class KuzuDBManager:
             ("Annotation", "uid STRING, name STRING, path STRING, line_number INT64, end_line INT64, source STRING, docstring STRING, lang STRING, is_dependency BOOLEAN, PRIMARY KEY (uid)"),
             ("Record", "uid STRING, name STRING, path STRING, line_number INT64, end_line INT64, source STRING, docstring STRING, lang STRING, is_dependency BOOLEAN, PRIMARY KEY (uid)"),
             ("Property", "uid STRING, name STRING, path STRING, line_number INT64, end_line INT64, source STRING, docstring STRING, lang STRING, is_dependency BOOLEAN, PRIMARY KEY (uid)"),
-            ("Parameter", "uid STRING, name STRING, path STRING, function_line_number INT64, PRIMARY KEY (uid)")
+            ("Parameter", "uid STRING, name STRING, path STRING, function_line_number INT64, PRIMARY KEY (uid)"),
+            ("Mixin", "uid STRING, name STRING, path STRING, line_number INT64, end_line INT64, source STRING, docstring STRING, lang STRING, is_dependency BOOLEAN, PRIMARY KEY (uid)"),
+            ("Extension", "uid STRING, name STRING, path STRING, line_number INT64, end_line INT64, source STRING, docstring STRING, lang STRING, is_dependency BOOLEAN, PRIMARY KEY (uid)"),
+            ("Object", "uid STRING, name STRING, path STRING, line_number INT64, end_line INT64, source STRING, docstring STRING, lang STRING, is_dependency BOOLEAN, PRIMARY KEY (uid)"),
+            ("DbTable", "name STRING, fqn STRING, datasource_name STRING, path STRING, PRIMARY KEY (name)"),
+            ("ExternalClass", "name STRING, path STRING, PRIMARY KEY (name)")
         ]
         
         # rel_tables: list of (table_name, schema, use_group)
@@ -131,26 +136,57 @@ class KuzuDBManager:
             # 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),
+            ("CONTAINS", """
+                FROM File TO Function, FROM File TO Class, FROM File TO Variable, FROM File TO Trait, FROM File TO Interface, 
+                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 File TO Mixin, FROM File TO Extension, FROM File TO Module, 
+                FROM File TO Object,
+                FROM Repository TO Directory, FROM Directory TO Directory, FROM Directory TO File, FROM Repository TO File, 
+                FROM Class TO Function, FROM Module TO Function, FROM Interface TO Function, FROM Struct TO Function, 
+                FROM Record TO Function, FROM Trait TO Function, FROM Object TO Function, FROM Mixin TO Function,
+                FROM Extension TO Function, FROM Class TO Class, FROM Class TO Interface, FROM Class TO Struct, 
+                FROM Class TO Variable, FROM Module TO Class, FROM Module TO Module, FROM `Macro` TO `Macro`, FROM Function TO Function
+            """, True),
             ("CALLS", """
-                FROM Function TO Function, FROM Function TO Class, FROM Function TO Interface, FROM Function TO Trait, FROM Function TO Struct, FROM Function TO Enum, FROM Function TO `Record`, FROM Function TO `Union`,
-                FROM Class TO Function, FROM Class TO Class, FROM Class TO Interface, FROM Class TO Trait, FROM Class TO Struct, FROM Class TO Enum, FROM Class TO `Record`, FROM Class TO `Union`,
+                FROM Function TO Function, FROM Function TO Class, FROM Function TO Interface, FROM Function TO Trait, 
+                FROM Function TO Struct, FROM Function TO Enum, FROM Function TO Record, FROM Function TO `Union`,
+                FROM Function TO Mixin, FROM Function TO Extension, FROM Function TO Object,
+                FROM Class TO Function, FROM Class TO Class, FROM Class TO Interface, FROM Class TO Trait, 
+                FROM Class TO Struct, FROM Class TO Enum, FROM Class TO Record, FROM Class TO `Union`,
                 FROM Interface TO Function, FROM Interface TO Class, FROM Interface TO Interface,
-                FROM File TO Function, FROM File TO Class, FROM File TO Interface, FROM File TO Trait, FROM File TO Struct, FROM File TO Enum, FROM File TO `Record`, FROM File TO `Union`,
-                line_number INT64, args STRING[], full_call_name STRING, confidence DOUBLE, resolution_tier INT64, confidence_label STRING, source STRING, resolution_method STRING, called_name STRING
+                FROM Trait TO Function, FROM Trait TO Class, FROM Trait TO Interface,
+                FROM Mixin TO Function, FROM Mixin TO Class, FROM Mixin TO Interface,
+                FROM Extension TO Function, FROM Extension TO Class, FROM Extension TO Interface,
+                FROM Object TO Function, FROM Object TO Class, FROM Object TO Interface,
+                FROM `Union` TO Function, FROM `Union` TO Class, FROM `Union` TO Interface,
+                FROM `Macro` TO Function, FROM `Macro` TO Class, FROM `Macro` TO Interface,
+                FROM File TO Function, FROM File TO Class, FROM File TO Interface, FROM File TO Trait, 
+                FROM File TO Struct, FROM File TO Enum, FROM File TO Record, FROM File TO `Union`,
+                FROM Variable TO Function, FROM Variable TO Class, FROM Variable TO Interface,
+                line_number INT64, args STRING[], full_call_name STRING, confidence DOUBLE, resolution_tier INT64, 
+                confidence_label STRING, source STRING, resolution_method STRING, called_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 Class TO Interface, FROM Class TO Trait,
-                FROM `Record` TO `Record`, FROM `Record` TO Interface,
-                FROM Interface TO Interface, FROM Interface TO Trait,
-                FROM Struct TO Interface, FROM Struct TO Trait,
+                FROM Class TO Class, FROM Class TO Interface, FROM Class TO Trait, FROM Class TO Mixin, FROM Class TO Extension, FROM Class TO ExternalClass, FROM Class TO Struct, FROM Class TO Enum, FROM Class TO `Union`, FROM Class TO Record, FROM Class TO Object,
+                FROM Trait TO Trait, FROM Trait TO Interface, FROM Trait TO ExternalClass, FROM Trait TO Class,
+                FROM Interface TO Interface, FROM Interface TO Trait, FROM Interface TO ExternalClass, FROM Interface TO Class,
+                FROM Struct TO Interface, FROM Struct TO Trait, FROM Struct TO ExternalClass, FROM Struct TO Struct, FROM Struct TO Class,
+                FROM Record TO Record, FROM Record TO Interface, FROM Record TO ExternalClass, FROM Record TO Class, FROM Record TO Struct,
+                FROM Mixin TO Mixin, FROM Mixin TO Interface, FROM Mixin TO ExternalClass, FROM Mixin TO Class,
+                FROM Extension TO Extension, FROM Extension TO Interface, FROM Extension TO ExternalClass, FROM Extension TO Class,
+                FROM Enum TO Class, FROM Enum TO Interface, FROM Enum TO ExternalClass, FROM Enum TO Enum,
+                FROM `Union` TO Class, FROM `Union` TO Interface, FROM `Union` TO ExternalClass, FROM `Union` TO `Union`,
+                FROM Module TO Module, FROM Module TO ExternalClass, FROM Object TO Object, FROM Object TO ExternalClass, FROM Object TO Class,
                 confidence_label STRING
             """, 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),
-            ("INJECTS", "FROM Class TO Class, field_name STRING, inject_line INT64, confidence_label STRING", False)
+            ("IMPLEMENTS", "FROM Class TO Interface, FROM Struct TO Interface, FROM Record TO Interface, FROM Mixin TO Interface, FROM Extension TO Interface, FROM Enum TO Interface, FROM Object TO Interface, FROM `Union` TO Interface, FROM Trait TO Interface", True),
+            ("INJECTS", "FROM Class TO Class, field_name STRING, inject_line INT64, confidence_label STRING", False),
+            ("MAPS_TO", "FROM Class TO DbTable, datastore STRING, line_number INT64", False),
+            ("READS", "FROM Function TO DbTable, line_number INT64", False),
+            ("WRITES", "FROM Function TO DbTable, line_number INT64", False)
         ]
 
         for table_name, schema in node_tables:
@@ -181,9 +217,12 @@ class KuzuDBManager:
         simple_migrations = [
             ("File", "package_name", "STRING"),
             ("Module", "full_import_name", "STRING"),
+            ("Module", "path", "STRING"),
+            ("Module", "line_number", "INT64"),
+            ("DbTable", "path", "STRING"),
+            ("ExternalClass", "path", "STRING"),
             ("IMPORTS", "full_import_name", "STRING"),
             ("IMPORTS", "imported_name", "STRING"),
-            # Freshness properties added to Repository in 0.4.8
             ("Repository", "indexed_at", "STRING"),
             ("Repository", "commit_hash", "STRING"),
             # Spring endpoint properties on Function

{codegraphcontext-0.4.8 → codegraphcontext-0.4.9}/src/codegraphcontext/server.py

@@ -27,6 +27,9 @@ from .cli.config_manager import (
     discover_child_contexts,
     save_workspace_mapping,
     get_workspace_mapping,
+    _default_global_db_path,
+    CONFIG_DIR,
+    load_config,
 )
 
 # Import Tool Definitions and Handlers
@@ -398,6 +401,48 @@ class MCPServer:
         if not raw_path:
             return {"error": "context_path is required."}
 
+        # --- Special case: switch back to the global context ---
+        if raw_path == "global":
+            try:
+                try:
+                    self.db_manager.close_driver()
+                except Exception:
+                    pass
+
+                # Resolve global DB path directly — do NOT use resolve_context()
+                # because that checks CWD for local .codegraphcontext/ and may
+                # return per-repo instead of global.
+                db = os.getenv("CGC_RUNTIME_DB_TYPE") or load_config().get("DEFAULT_DATABASE", "falkordb")
+                global_db_path = _default_global_db_path(db)
+                new_manager = get_database_manager(db_path=global_db_path)
+                new_manager.get_driver()
+
+                self.db_manager = new_manager
+                self.resolved_context = type(self.resolved_context)(
+                    mode="global",
+                    context_name="",
+                    database=db,
+                    db_path=global_db_path,
+                    cgcignore_path=str(CONFIG_DIR / "global" / ".cgcignore"),
+                    is_local=False,
+                )
+
+                # Rebuild dependent components
+                self.graph_builder = GraphBuilder(self.db_manager, self.job_manager, self.loop)
+                self.code_finder = CodeFinder(self.db_manager)
+                self.code_watcher = CodeWatcher(self.graph_builder, self.job_manager)
+                self._context_note_pending = False
+
+                return {
+                    "status": "ok",
+                    "message": f"Switched back to global context at {global_db_path}.",
+                    "database": db,
+                    "db_path": global_db_path,
+                }
+            except Exception as e:
+                return {"error": f"Failed to switch to global context: {e}"}
+
+        # --- Normal path-based switch ---
         target = Path(raw_path).resolve()
         # Accept either the repo dir or the .codegraphcontext dir directly
         if target.name == ".codegraphcontext":

{codegraphcontext-0.4.8 → codegraphcontext-0.4.9}/src/codegraphcontext/tools/code_finder.py

@@ -824,64 +824,79 @@ class CodeFinder:
                 "note": "These functions might be unused, but could be entry points, callbacks, or called dynamically"
             }
     
-    def find_all_callers(self, function_name: str, path: Optional[str] = None, repo_path: Optional[str] = None) -> List[Dict]:
-        """Find all direct and indirect callers of a specific function."""
+    def find_all_callers(self, function_name: str, path: Optional[str] = None, repo_path: Optional[str] = None, depth: int = 3) -> List[Dict]:
+        """Find all direct and indirect callers of a specific function, returning edges."""
         with self.driver.session() as session:
-            repo_filter = "AND f.path STARTS WITH $repo_path" if repo_path else ""
+            repo_filter = "AND caller.path STARTS WITH $repo_path" if repo_path else ""
+            depth_str = f"1..{depth}" if depth > 1 else "1"
+            
+            # KùzuDB-optimized: matching on the path end node via nodes(p) indexing
+            # ensures we avoid Binder exceptions for multi-labeled property lookups
+            # on the end node of variable-length paths.
             if path:
-                # KùzuDB-compatible: Use anonymous end node and filter with WHERE
                 query = f"""
-                    MATCH p = (f:Function)-[:CALLS*]->()
-                    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)-1] 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
-                    LIMIT 50
+                    MATCH p = (caller:Function)-[:CALLS*{depth_str}]->(target:Function)
+                    WITH p, nodes(p) as path_nodes, relationships(p) as rels
+                    WITH p, path_nodes, rels, path_nodes[size(path_nodes)-1] as last_node
+                    WHERE last_node.name = $function_name AND last_node.path = $path
+                    {repo_filter}
+                    UNWIND rels as r
+                    WITH startNode(r) as s, endNode(r) as e, r
+                    RETURN DISTINCT s.name as caller_name, s.path as caller_path, 
+                                    e.name as callee_name, e.path as callee_path, 
+                                    r.line_number as line
+                    LIMIT 100
                 """
                 result = session.run(query, function_name=function_name, path=path, repo_path=repo_path)
             else:
-                # KùzuDB-compatible: Use anonymous end node and filter with WHERE
                 query = f"""
-                    MATCH p = (f:Function)-[:CALLS*]->()
-                    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)-1] 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
-                    LIMIT 50
+                    MATCH p = (caller:Function)-[:CALLS*{depth_str}]->(target:Function)
+                    WITH p, nodes(p) as path_nodes, relationships(p) as rels
+                    WITH p, path_nodes, rels, path_nodes[size(path_nodes)-1] as last_node
+                    WHERE last_node.name = $function_name
+                    {repo_filter}
+                    UNWIND rels as r
+                    WITH startNode(r) as s, endNode(r) as e, r
+                    RETURN DISTINCT s.name as caller_name, s.path as caller_path, 
+                                    e.name as callee_name, e.path as callee_path, 
+                                    r.line_number as line
+                    LIMIT 100
                 """
                 result = session.run(query, function_name=function_name, repo_path=repo_path)
             return result.data()
 
-    def find_all_callees(self, function_name: str, path: Optional[str] = None, repo_path: Optional[str] = None) -> List[Dict]:
-        """Find all direct and indirect callees of a specific function."""
+    def find_all_callees(self, function_name: str, path: Optional[str] = None, repo_path: Optional[str] = None, depth: int = 3) -> List[Dict]:
+        """Find all direct and indirect callees of a specific function, returning edges."""
         with self.driver.session() as session:
-            repo_filter = "WHERE f.path STARTS WITH $repo_path" if repo_path else ""
+            repo_filter = "AND callee.path STARTS WITH $repo_path" if repo_path else ""
+            depth_str = f"1..{depth}" if depth > 1 else "1"
+            
             if path:
-                # KùzuDB-compatible: Use anonymous end node and extract from path
                 query = f"""
-                    MATCH (caller:Function {{name: $function_name, path: $path}})
-                    MATCH p = (caller)-[:CALLS*]->()
-                    WITH p as p, nodes(p) as path_nodes
-                    WITH path_nodes[size(path_nodes)-1] 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
-                    LIMIT 50
+                    MATCH p = (caller:Function {{name: $function_name, path: $path}})-[:CALLS*{depth_str}]->(callee:Function)
+                    WITH p, nodes(p) as path_nodes, relationships(p) as rels
+                    WITH p, path_nodes, rels, path_nodes[size(path_nodes)-1] as last_node
+                    WHERE 1=1 {repo_filter}
+                    UNWIND rels as r
+                    WITH startNode(r) as s, endNode(r) as e, r
+                    RETURN DISTINCT s.name as caller_name, s.path as caller_path, 
+                                    e.name as callee_name, e.path as callee_path, 
+                                    r.line_number as line
+                    LIMIT 100
                 """
                 result = session.run(query, function_name=function_name, path=path, repo_path=repo_path)
             else:
-                # KùzuDB-compatible: Use anonymous end node and extract from path
                 query = f"""
-                    MATCH (caller:Function {{name: $function_name}})
-                    MATCH p = (caller)-[:CALLS*]->()
-                    WITH p as p, nodes(p) as path_nodes
-                    WITH path_nodes[size(path_nodes)-1] 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
-                    LIMIT 50
+                    MATCH p = (caller:Function {{name: $function_name}})-[:CALLS*{depth_str}]->(callee:Function)
+                    WITH p, nodes(p) as path_nodes, relationships(p) as rels
+                    WITH p, path_nodes, rels, path_nodes[size(path_nodes)-1] as last_node
+                    WHERE 1=1 {repo_filter}
+                    UNWIND rels as r
+                    WITH startNode(r) as s, endNode(r) as e, r
+                    RETURN DISTINCT s.name as caller_name, s.path as caller_path, 
+                                    e.name as callee_name, e.path as callee_path, 
+                                    r.line_number as line
+                    LIMIT 100
                 """
                 result = session.run(query, function_name=function_name, repo_path=repo_path)
             return result.data()
@@ -1159,11 +1174,14 @@ class CodeFinder:
                 "variable_name": variable_name,
                 "instances": instances,
             }
-    
-    def analyze_code_relationships(self, query_type: str, target: str, context: Optional[str] = None, repo_path: Optional[str] = None) -> Dict[str, Any]:
+
+    def analyze_code_relationships(self, query_type: str, target: str, context: Optional[str] = None, repo_path: Optional[str] = None, depth: Optional[int] = None) -> Dict[str, Any]:
         """Main method to analyze different types of code relationships with fixed return types"""
         query_type = query_type.lower().strip()
         
+        # Use depth if provided, otherwise default to 3 for 'all' queries
+        effective_depth = depth if depth is not None else 3
+        
         try:
             if query_type == "find_callers":
                 results = self.who_calls_function(target, context, repo_path=repo_path)
@@ -1237,17 +1255,17 @@ class CodeFinder:
                 }
             
             elif query_type == "find_all_callers":
-                results = self.find_all_callers(target, context, repo_path=repo_path)
+                results = self.find_all_callers(target, context, repo_path=repo_path, depth=effective_depth)
                 return {
-                    "query_type": "find_all_callers", "target": target, "context": context, "results": results,
-                    "summary": f"Found {len(results)} direct and indirect callers of '{target}'"
+                    "query_type": "find_all_callers", "target": target, "context": context, "results": results, "depth": effective_depth,
+                    "summary": f"Found {len(results)} direct and indirect callers of '{target}' (depth: {effective_depth})"
                 }
-
+ 
             elif query_type == "find_all_callees":
-                results = self.find_all_callees(target, context, repo_path=repo_path)
+                results = self.find_all_callees(target, context, repo_path=repo_path, depth=effective_depth)
                 return {
-                    "query_type": "find_all_callees", "target": target, "context": context, "results": results,
-                    "summary": f"Found {len(results)} direct and indirect callees of '{target}'"
+                    "query_type": "find_all_callees", "target": target, "context": context, "results": results, "depth": effective_depth,
+                    "summary": f"Found {len(results)} direct and indirect callees of '{target}' (depth: {effective_depth})"
                 }
                 
             elif query_type in ["call_chain", "path", "chain"]:

{codegraphcontext-0.4.8 → codegraphcontext-0.4.9}/src/codegraphcontext/tools/graph_builder.py

@@ -858,6 +858,10 @@ class GraphBuilder:
             if "error" not in file_data:
                 self.add_file_to_graph(file_data, repo_name, imports_map)
                 return file_data
+            if not file_data.get("unsupported"):
+                # Generic file type (.md, .yml, .json, etc.) — create a bare File node
+                self.add_minimal_file_node(path, repo_path)
+                return file_data
             error_logger(f"Skipping graph add for {file_path_str} due to parsing error: {file_data['error']}")
             return None
         return {"deleted": True, "path": file_path_str}

{codegraphcontext-0.4.8 → codegraphcontext-0.4.9}/src/codegraphcontext/tools/handlers/analysis_handlers.py

@@ -89,8 +89,9 @@ def analyze_code_relationships(code_finder: CodeFinder, **args) -> Dict[str, Any
         }
 
     try:
-        debug_log(f"Analyzing relationships: {query_type} for {target}, repo_path={repo_path}")
-        results = code_finder.analyze_code_relationships(query_type, target, context, repo_path=repo_path)
+        depth = args.get("depth")
+        debug_log(f"Analyzing relationships: {query_type} for {target}, repo_path={repo_path}, depth={depth}")
+        results = code_finder.analyze_code_relationships(query_type, target, context, repo_path=repo_path, depth=depth)
 
         # Apply per-query-type limit (falls back to tool-level limit)
         limit = get_tool_result_limit(query_type) or get_tool_result_limit("analyze_code_relationships")