codegraphcontext 0.1.7__tar.gz → 0.1.8__tar.gz

{codegraphcontext-0.1.7/src/codegraphcontext.egg-info → codegraphcontext-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.1.7
+Version: 0.1.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
@@ -53,9 +53,13 @@ Dynamic: license-file
 # CodeGraphContext
 [![Build Status](https://github.com/Shashankss1205/CodeGraphContext/actions/workflows/test.yml/badge.svg)](https://github.com/Shashankss1205/CodeGraphContext/actions/workflows/test.yml)
 
-
 An MCP server that indexes local code into a graph database to provide context to AI assistants.
 
+## Project Details
+- **Version:** 0.1.8
+- **Authors:** Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
+- **License:** MIT License (See [LICENSE](LICENSE) for details)
+
 ## Features
 
 -   **Code Indexing:** Analyzes Python code and builds a knowledge graph of its components.
@@ -63,12 +67,23 @@ An MCP server that indexes local code into a graph database to provide context t
 -   **Live Updates:** Watches local files for changes and automatically updates the graph.
 -   **Interactive Setup:** A user-friendly command-line wizard for easy setup.
 
+## Dependencies
+
+- `neo4j>=5.15.0`
+- `watchdog>=3.0.0`
+- `requests>=2.31.0`
+- `stdlibs>=2023.11.18`
+- `typer[all]>=0.9.0`
+- `rich>=13.7.0`
+- `inquirerpy>=0.3.4`
+- `python-dotenv>=1.0.0`
+
 ## Getting Started
 
 1.  **Install:** `pip install codegraphcontext`
 2.  **Setup:** `cgc setup`
 3.  **Start:** `cgc start`
-4.  **Index Code:** `cgc tool add-code-to-graph '{"path": "/path/to/your/project"}'`
+4.  **Index Code:** `cgc tool add-code-to-graph '{"path": "/path/to/your/project"}'` (Under active development)
 
 ## MCP Client Configuration
 
@@ -98,7 +113,11 @@ Add the following to your MCP client's configuration:
           "analyze_code_relationships",
           "watch_directory",
           "find_dead_code",
-          "execute_cypher_query"
+          "execute_cypher_query",
+          "calculate_cyclomatic_complexity",
+          "find_most_complex_functions",
+          "list_indexed_repositories",
+          "delete_repository"
         ],
         "disabled": false
       },
@@ -149,5 +168,22 @@ Once the server is running, you can interact with it through your AI assistant u
     -   "Which files import the `requests` library?"
     -   "Find all implementations of the `render` method."
 
+-   **Advanced Call Chain and Dependency Tracking (Spanning Hundreds of Files):**
+    The CodeGraphContext excels at tracing complex execution flows and dependencies across vast codebases. Leveraging the power of graph databases, it can identify direct and indirect callers and callees, even when a function is called through multiple layers of abstraction or across numerous files. This is invaluable for:
+    -   **Impact Analysis:** Understand the full ripple effect of a change to a core function.
+    -   **Debugging:** Trace the path of execution from an entry point to a specific bug.
+    -   **Code Comprehension:** Grasp how different parts of a large system interact.
+
+    -   "Show me the full call chain from the `main` function to `process_data`."
+    -   "Find all functions that directly or indirectly call `validate_input`."
+    -   "What are all the functions that `initialize_system` eventually calls?"
+    -   "Trace the dependencies of the `DatabaseManager` module."
+
 -   **Code Quality and Maintenance:**
     -   "Is there any dead or unused code in this project?"
+    -   "Calculate the cyclomatic complexity of the `process_data` function in `src/utils.py`."
+    -   "Find the 5 most complex functions in the codebase."
+
+-   **Repository Management:**
+    -   "List all currently indexed repositories."
+    -   "Delete the indexed repository at `/path/to/old-project`."

{codegraphcontext-0.1.7 → codegraphcontext-0.1.8}/README.md

@@ -1,9 +1,13 @@
 # CodeGraphContext
 [![Build Status](https://github.com/Shashankss1205/CodeGraphContext/actions/workflows/test.yml/badge.svg)](https://github.com/Shashankss1205/CodeGraphContext/actions/workflows/test.yml)
 
-
 An MCP server that indexes local code into a graph database to provide context to AI assistants.
 
+## Project Details
+- **Version:** 0.1.8
+- **Authors:** Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
+- **License:** MIT License (See [LICENSE](LICENSE) for details)
+
 ## Features
 
 -   **Code Indexing:** Analyzes Python code and builds a knowledge graph of its components.
@@ -11,12 +15,23 @@ An MCP server that indexes local code into a graph database to provide context t
 -   **Live Updates:** Watches local files for changes and automatically updates the graph.
 -   **Interactive Setup:** A user-friendly command-line wizard for easy setup.
 
+## Dependencies
+
+- `neo4j>=5.15.0`
+- `watchdog>=3.0.0`
+- `requests>=2.31.0`
+- `stdlibs>=2023.11.18`
+- `typer[all]>=0.9.0`
+- `rich>=13.7.0`
+- `inquirerpy>=0.3.4`
+- `python-dotenv>=1.0.0`
+
 ## Getting Started
 
 1.  **Install:** `pip install codegraphcontext`
 2.  **Setup:** `cgc setup`
 3.  **Start:** `cgc start`
-4.  **Index Code:** `cgc tool add-code-to-graph '{"path": "/path/to/your/project"}'`
+4.  **Index Code:** `cgc tool add-code-to-graph '{"path": "/path/to/your/project"}'` (Under active development)
 
 ## MCP Client Configuration
 
@@ -46,7 +61,11 @@ Add the following to your MCP client's configuration:
           "analyze_code_relationships",
           "watch_directory",
           "find_dead_code",
-          "execute_cypher_query"
+          "execute_cypher_query",
+          "calculate_cyclomatic_complexity",
+          "find_most_complex_functions",
+          "list_indexed_repositories",
+          "delete_repository"
         ],
         "disabled": false
       },
@@ -97,5 +116,22 @@ Once the server is running, you can interact with it through your AI assistant u
     -   "Which files import the `requests` library?"
     -   "Find all implementations of the `render` method."
 
+-   **Advanced Call Chain and Dependency Tracking (Spanning Hundreds of Files):**
+    The CodeGraphContext excels at tracing complex execution flows and dependencies across vast codebases. Leveraging the power of graph databases, it can identify direct and indirect callers and callees, even when a function is called through multiple layers of abstraction or across numerous files. This is invaluable for:
+    -   **Impact Analysis:** Understand the full ripple effect of a change to a core function.
+    -   **Debugging:** Trace the path of execution from an entry point to a specific bug.
+    -   **Code Comprehension:** Grasp how different parts of a large system interact.
+
+    -   "Show me the full call chain from the `main` function to `process_data`."
+    -   "Find all functions that directly or indirectly call `validate_input`."
+    -   "What are all the functions that `initialize_system` eventually calls?"
+    -   "Trace the dependencies of the `DatabaseManager` module."
+
 -   **Code Quality and Maintenance:**
     -   "Is there any dead or unused code in this project?"
+    -   "Calculate the cyclomatic complexity of the `process_data` function in `src/utils.py`."
+    -   "Find the 5 most complex functions in the codebase."
+
+-   **Repository Management:**
+    -   "List all currently indexed repositories."
+    -   "Delete the indexed repository at `/path/to/old-project`."

{codegraphcontext-0.1.7 → codegraphcontext-0.1.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codegraphcontext"
-version = "0.1.7"
+version = "0.1.8"
 description = "An MCP server that indexes local code into a graph database to provide context to AI assistants."
 authors = [{ name = "Shashank Shekhar Singh", email = "shashankshekharsingh1205@gmail.com" }]
 readme = "README.md"

{codegraphcontext-0.1.7 → codegraphcontext-0.1.8}/src/codegraphcontext/server.py

@@ -103,11 +103,11 @@ class MCPServer:
             },
             "analyze_code_relationships": {
                 "name": "analyze_code_relationships",
-                "description": "Analyze code relationships like 'who calls this function' or 'class hierarchy'.",
+                "description": "Analyze code relationships like 'who calls this function' or 'class hierarchy'. Supported query types include: find_callers, find_callees, find_all_callers, find_all_callees, find_importers, who_modifies, class_hierarchy, overrides, dead_code, call_chain, module_deps, variable_scope, find_complexity, find_functions_by_argument, find_functions_by_decorator.",
                 "inputSchema": {
                     "type": "object",
                     "properties": {
-                        "query_type": {"type": "string", "description": "Type of relationship query to run."},
+                        "query_type": {"type": "string", "description": "Type of relationship query to run.", "enum": ["find_callers", "find_callees", "find_all_callers", "find_all_callees", "find_importers", "who_modifies", "class_hierarchy", "overrides", "dead_code", "call_chain", "module_deps", "variable_scope", "find_complexity", "find_functions_by_argument", "find_functions_by_decorator"]},
                         "target": {"type": "string", "description": "The function, class, or module to analyze."},
                         "context": {"type": "string", "description": "Optional: specific file path for precise results."}
                     },
@@ -159,11 +159,12 @@ class MCPServer:
             },
             "find_dead_code": {
                 "name": "find_dead_code",
-                "description": "Find potentially unused functions (dead code) across the entire indexed codebase.",
+                "description": "Find potentially unused functions (dead code) across the entire indexed codebase, optionally excluding functions with specific decorators.",
                 "inputSchema": {
                     "type": "object",
-                    "properties": {},
-                    "additionalProperties": False
+                    "properties": {
+                        "exclude_decorated_with": {"type": "array", "items": {"type": "string"}, "description": "Optional: A list of decorator names (e.g., '@app.route') to exclude from dead code detection.", "default": []}
+                    }
                 }
             },
             "calculate_cyclomatic_complexity": {
@@ -207,7 +208,6 @@ class MCPServer:
                     "required": ["repo_path"]
                 }
             }
-            # Other tools like list_imports, add_package_to_graph can be added here following the same pattern
         }    
 
     def get_database_status(self) -> dict:
@@ -304,12 +304,12 @@ class MCPServer:
                 "details": str(e)
             }
     
-    def find_dead_code_tool(self) -> Dict[str, Any]:
+    def find_dead_code_tool(self, **args) -> Dict[str, Any]:
         """Tool to find potentially dead code across the entire project."""
+        exclude_decorated_with = args.get("exclude_decorated_with", [])
         try:
             debug_log("Finding dead code.")
-            # The target argument from the old tool is not needed.
-            results = self.code_finder.find_dead_code()
+            results = self.code_finder.find_dead_code(exclude_decorated_with=exclude_decorated_with)
             
             return {
                 "success": True,
@@ -446,17 +446,11 @@ class MCPServer:
             else:
                 return {"error": f"Path {path} does not exist"}
             
-            if language == 'python':
-                # Get the list of stdlib modules for the current Python version
-                stdlib_modules = set(stdlibs.module_names)
-                # stdlib_modules = {
-                #     'os', 'sys', 'json', 'time', 'datetime', 'math', 'random', 're', 'collections', 
-                #     'itertools', 'functools', 'operator', 'pathlib', 'urllib', 'http', 'logging', 
-                #     'threading', 'multiprocessing', 'asyncio', 'typing', 'dataclasses', 'enum', 
-                #     'abc', 'io', 'csv', 'sqlite3', 'pickle', 'base64', 'hashlib', 'hmac', 'secrets', 
-                #     'unittest', 'doctest', 'pdb', 'profile', 'cProfile', 'timeit'
-                # }
-                all_imports = all_imports - stdlib_modules
+            # Removed standard library filtering as per user request.
+            # if language == 'python':
+            #     # Get the list of stdlib modules for the current Python version
+            #     stdlib_modules = set(stdlibs.module_names)
+            #     all_imports = all_imports - stdlib_modules
             
             return {
                 "imports": sorted(list(all_imports)), "language": language,
@@ -642,8 +636,9 @@ class MCPServer:
             return {
                 "error": "Both 'query_type' and 'target' are required",
                 "supported_query_types": [
-                    "who_calls", "what_calls", "who_imports", "who_modifies",
-                    "class_hierarchy", "overrides", "dead_code"
+                    "find_callers", "find_callees", "find_importers", "who_modifies",
+                    "class_hierarchy", "overrides", "dead_code", "call_chain",
+                    "module_deps", "variable_scope", "find_complexity"
                 ]
             }
         

{codegraphcontext-0.1.7 → codegraphcontext-0.1.8}/src/codegraphcontext/tools/code_finder.py

@@ -2,6 +2,7 @@
 import logging
 import re
 from typing import Any, Dict, List
+from pathlib import Path
 
 from ..core.database import DatabaseManager
 
@@ -116,6 +117,56 @@ class CodeFinder:
         
         return results
     
+    def find_functions_by_argument(self, argument_name: str, file_path: str = None) -> List[Dict]:
+        """Find functions that take a specific argument name."""
+        with self.driver.session() as session:
+            if file_path:
+                query = """
+                    MATCH (f:Function)-[:HAS_PARAMETER]->(p:Parameter)
+                    WHERE p.name = $argument_name AND f.file_path = $file_path
+                    RETURN f.name AS function_name, f.file_path AS file_path, f.line_number AS line_number,
+                           f.docstring AS docstring, f.is_dependency AS is_dependency
+                    ORDER BY f.is_dependency ASC, f.file_path, f.line_number
+                    LIMIT 20
+                """
+                result = session.run(query, argument_name=argument_name, file_path=file_path)
+            else:
+                query = """
+                    MATCH (f:Function)-[:HAS_PARAMETER]->(p:Parameter)
+                    WHERE p.name = $argument_name
+                    RETURN f.name AS function_name, f.file_path AS file_path, f.line_number AS line_number,
+                           f.docstring AS docstring, f.is_dependency AS is_dependency
+                    ORDER BY f.is_dependency ASC, f.file_path, f.line_number
+                    LIMIT 20
+                """
+                result = session.run(query, argument_name=argument_name)
+            return [dict(record) for record in result]
+
+    def find_functions_by_decorator(self, decorator_name: str, file_path: str = None) -> List[Dict]:
+        """Find functions that have a specific decorator applied to them."""
+        with self.driver.session() as session:
+            if file_path:
+                query = """
+                    MATCH (f:Function)
+                    WHERE f.file_path = $file_path AND $decorator_name IN f.decorators
+                    RETURN f.name AS function_name, f.file_path AS file_path, f.line_number AS line_number,
+                           f.docstring AS docstring, f.is_dependency AS is_dependency, f.decorators AS decorators
+                    ORDER BY f.is_dependency ASC, f.file_path, f.line_number
+                    LIMIT 20
+                """
+                result = session.run(query, decorator_name=decorator_name, file_path=file_path)
+            else:
+                query = """
+                    MATCH (f:Function)
+                    WHERE $decorator_name IN f.decorators
+                    RETURN f.name AS function_name, f.file_path AS file_path, f.line_number AS line_number,
+                           f.docstring AS docstring, f.is_dependency AS is_dependency, f.decorators AS decorators
+                    ORDER BY f.is_dependency ASC, f.file_path, f.line_number
+                    LIMIT 20
+                """
+                result = session.run(query, decorator_name=decorator_name)
+            return [dict(record) for record in result]
+    
     def who_calls_function(self, function_name: str, file_path: str = None) -> List[Dict]:
         """Find what functions call a specific function using CALLS relationships with improved matching"""
         with self.driver.session() as session:
@@ -230,7 +281,7 @@ class CodeFinder:
         with self.driver.session() as session:
             result = session.run("""
                 MATCH (file:File)-[imp:IMPORTS]->(module:Module)
-                WHERE module.name CONTAINS $module_name OR module.name = $module_name
+                WHERE module.name = $module_name OR module.full_import_name CONTAINS $module_name
                 OPTIONAL MATCH (repo:Repository)-[:CONTAINS]->(file)
                 RETURN DISTINCT
                     file.name as file_name,
@@ -344,8 +395,11 @@ class CodeFinder:
             
             return [dict(record) for record in result]
     
-    def find_dead_code(self) -> Dict[str, Any]:
-        """Find potentially unused functions (not called by other functions in the project)"""
+    def find_dead_code(self, exclude_decorated_with: List[str] = None) -> Dict[str, Any]:
+        """Find potentially unused functions (not called by other functions in the project), optionally excluding those with specific decorators."""
+        if exclude_decorated_with is None:
+            exclude_decorated_with = []
+
         with self.driver.session() as session:
             result = session.run("""
                 MATCH (func:Function)
@@ -353,6 +407,7 @@ class CodeFinder:
                   AND NOT func.name IN ['main', '__init__', '__main__', 'setup', 'run', '__new__', '__del__']
                   AND NOT func.name STARTS WITH '_test'
                   AND NOT func.name STARTS WITH 'test_'
+                  AND ALL(decorator_name IN $exclude_decorated_with WHERE NOT decorator_name IN func.decorators)
                 WITH func
                 OPTIONAL MATCH (caller:Function)-[:CALLS]->(func)
                 WHERE caller.is_dependency = false
@@ -368,37 +423,84 @@ class CodeFinder:
                     file.name as file_name
                 ORDER BY func.file_path, func.line_number
                 LIMIT 50
-            """)
+            """, exclude_decorated_with=exclude_decorated_with)
             
             return {
                 "potentially_unused_functions": [dict(record) for record in result],
                 "note": "These functions might be unused, but could be entry points, callbacks, or called dynamically"
             }
     
+    def find_all_callers(self, function_name: str, file_path: str = None) -> List[Dict]:
+        """Find all direct and indirect callers of a specific function."""
+        with self.driver.session() as session:
+            if file_path:
+                # Find functions within the specified file_path that call the target function
+                query = """
+                    MATCH (f:Function)-[:CALLS*]->(target:Function {name: $function_name})
+                    WHERE f.file_path = $file_path
+                    RETURN DISTINCT f.name AS caller_name, f.file_path AS caller_file_path, f.line_number AS caller_line_number, f.is_dependency AS caller_is_dependency
+                    ORDER BY f.is_dependency ASC, f.file_path, f.line_number
+                    LIMIT 50
+                """
+                result = session.run(query, function_name=function_name, file_path=file_path)
+            else:
+                # If no file_path (context) is provided, find all callers of the function by name
+                query = """
+                    MATCH (f:Function)-[:CALLS*]->(target:Function {name: $function_name})
+                    RETURN DISTINCT f.name AS caller_name, f.file_path AS caller_file_path, f.line_number AS caller_line_number, f.is_dependency AS caller_is_dependency
+                    ORDER BY f.is_dependency ASC, f.file_path, f.line_number
+                    LIMIT 50
+                """
+                result = session.run(query, function_name=function_name)
+            return [dict(record) for record in result]
+
+    def find_all_callees(self, function_name: str, file_path: str = None) -> List[Dict]:
+        """Find all direct and indirect callees of a specific function."""
+        with self.driver.session() as session:
+            if file_path:
+                query = """
+                    MATCH (caller:Function {name: $function_name, file_path: $file_path})
+                    MATCH (caller)-[:CALLS*]->(f:Function)
+                    RETURN DISTINCT f.name AS callee_name, f.file_path AS callee_file_path, f.line_number AS callee_line_number, f.is_dependency AS callee_is_dependency
+                    ORDER BY f.is_dependency ASC, f.file_path, f.line_number
+                    LIMIT 50
+                """
+                result = session.run(query, function_name=function_name, file_path=file_path)
+            else:
+                query = """
+                    MATCH (caller:Function {name: $function_name})
+                    MATCH (caller)-[:CALLS*]->(f:Function)
+                    RETURN DISTINCT f.name AS callee_name, f.file_path AS callee_file_path, f.line_number AS callee_line_number, f.is_dependency AS callee_is_dependency
+                    ORDER BY f.is_dependency ASC, f.file_path, f.line_number
+                    LIMIT 50
+                """
+                result = session.run(query, function_name=function_name)
+            return [dict(record) for record in result]
+
     def find_function_call_chain(self, start_function: str, end_function: str, max_depth: int = 5) -> List[Dict]:
         """Find call chains between two functions"""
         with self.driver.session() as session:
-            result = session.run("""
+            result = session.run(f"""
                 MATCH path = shortestPath(
-                    (start:Function {name: $start_function})-[:CALLS*1..$max_depth]->(end:Function {name: $end_function})
+                    (start:Function {{name: $start_function}})-[:CALLS*1..{max_depth}]->(end:Function {{name: $end_function}})
                 )
                 WITH path, nodes(path) as func_nodes, relationships(path) as call_rels
                 RETURN 
-                    [node in func_nodes | {
+                    [node in func_nodes | {{
                         name: node.name,
                         file_path: node.file_path,
                         line_number: node.line_number,
                         is_dependency: node.is_dependency
-                    }] as function_chain,
-                    [rel in call_rels | {
+                    }}] 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,
+                    }}] as call_details,
                     length(path) as chain_length
                 ORDER BY chain_length ASC
                 LIMIT 10
-            """, start_function=start_function, end_function=end_function, max_depth=max_depth)
+            """, start_function=start_function, end_function=end_function)
             
             return [dict(record) for record in result]
     
@@ -494,6 +596,20 @@ class CodeFinder:
                     "summary": f"Found {len(results)} files that import '{target}'"
                 }
                 
+            elif query_type == "find_functions_by_argument":
+                results = self.find_functions_by_argument(target, context)
+                return {
+                    "query_type": "find_functions_by_argument", "target": target, "context": context, "results": results,
+                    "summary": f"Found {len(results)} functions that take '{target}' as an argument"
+                }
+            
+            elif query_type == "find_functions_by_decorator":
+                results = self.find_functions_by_decorator(target, context)
+                return {
+                    "query_type": "find_functions_by_decorator", "target": target, "context": context, "results": results,
+                    "summary": f"Found {len(results)} functions decorated with '{target}'"
+                }
+                
             elif query_type in ["who_modifies", "modifies", "mutations", "changes", "variable_usage"]:
                 results = self.who_modifies_variable(target)
                 return {
@@ -530,13 +646,29 @@ class CodeFinder:
                     "summary": f"Found the top {len(results)} most complex functions"
                 }
             
+            elif query_type == "find_all_callers":
+                results = self.find_all_callers(target, context)
+                return {
+                    "query_type": "find_all_callers", "target": target, "context": context, "results": results,
+                    "summary": f"Found {len(results)} direct and indirect callers of '{target}'"
+                }
+
+            elif query_type == "find_all_callees":
+                results = self.find_all_callees(target, context)
+                return {
+                    "query_type": "find_all_callees", "target": target, "context": context, "results": results,
+                    "summary": f"Found {len(results)} direct and indirect callees of '{target}'"
+                }
+                
             elif query_type in ["call_chain", "path", "chain"]:
                 if '->' in target:
                     start_func, end_func = target.split('->', 1)
-                    results = self.find_function_call_chain(start_func.strip(), end_func.strip())
+                    # max_depth can be passed as context, default to 5 if not provided or invalid
+                    max_depth = int(context) if context and context.isdigit() else 5
+                    results = self.find_function_call_chain(start_func.strip(), end_func.strip(), max_depth)
                     return {
                         "query_type": "call_chain", "target": target, "results": results,
-                        "summary": f"Found {len(results)} call chains from '{start_func.strip()}' to '{end_func.strip()}'"
+                        "summary": f"Found {len(results)} call chains from '{start_func.strip()}' to '{end_func.strip()}' (max depth: {max_depth})"
                     }
                 else:
                     return {

{codegraphcontext-0.1.7 → codegraphcontext-0.1.8}/src/codegraphcontext/tools/graph_builder.py

@@ -244,7 +244,9 @@ class CodeVisitor(ast.NodeVisitor):
                      "args": [arg.arg for arg in node.args.args], "source": ast.unparse(node),
                      "context": self.current_context, "class_context": self.current_class,
                      "is_dependency": self.is_dependency, "docstring": ast.get_docstring(node),
-                     "decorators": [ast.unparse(d) for d in node.decorator_list]}
+                     "decorators": [ast.unparse(d) for d in node.decorator_list],
+                     "source_code": ast.unparse(node)} # Add source_code here
+        self.functions.append(func_data)
         self.functions.append(func_data)
         self._push_context(node.name, "function", node.lineno)
         # This will trigger visit_Assign and visit_Call for nodes inside the function
@@ -343,7 +345,8 @@ class CodeVisitor(ast.NodeVisitor):
         """Visit import statements"""
         for name in node.names:
             import_data = {
-                "name": name.name,
+                "name": name.name.split('.')[0], # Store the top-level package name
+                "full_import_name": name.name, # Store the full import name
                 "line_number": node.lineno,
                 "alias": name.asname,
                 "context": self.current_context,
@@ -361,14 +364,20 @@ class CodeVisitor(ast.NodeVisitor):
 
         for alias in node.names:
             # If node.module is None, it's an import like `from . import name`
+            # Determine the base module name for the 'name' property
             if node.module:
-                full_name = f"{prefix}{node.module}.{alias.name}"
+                # For 'from .module import name', base_module is 'module'
+                # For 'from package.module import name', base_module is 'package'
+                base_module = node.module.split('.')[0]
+                full_import_name = f"{prefix}{node.module}.{alias.name}"
             else:
-                # The full name is just the prefix and the imported name
-                full_name = f"{prefix}{alias.name}"
+                # For 'from . import name', base_module is 'name'
+                base_module = alias.name
+                full_import_name = f"{prefix}{alias.name}"
 
             import_data = {
-                "name": full_name,
+                "name": base_module,  # Store the top-level module name
+                "full_import_name": full_import_name, # Store the full import path
                 "line_number": node.lineno,
                 "alias": alias.asname,
                 "context": self.current_context,
@@ -445,29 +454,29 @@ class CodeVisitor(ast.NodeVisitor):
         inferred_obj_type = None
         if isinstance(node.func, ast.Attribute):
             base_obj_node = node.func.value
-            
+
             if isinstance(base_obj_node, ast.Name):
                 obj_name = base_obj_node.id
                 if obj_name == 'self':
                     # If the base is 'self', find the type of the attribute on the current class
                     inferred_obj_type = self.class_symbol_table.get(node.func.attr)
                     if not inferred_obj_type: # Fallback for method calls directly on self
-                         inferred_obj_type = self.current_class
+                        inferred_obj_type = self.current_class
                 else:
                     inferred_obj_type = (self.local_symbol_table.get(obj_name) or
-                                         self.class_symbol_table.get(obj_name) or
-                                         self.module_symbol_table.get(obj_name))
+                                        self.class_symbol_table.get(obj_name) or
+                                        self.module_symbol_table.get(obj_name))
                     # If it's not a variable, it might be a direct call on a Class name.
                     if not inferred_obj_type and obj_name in self.imports_map:
                         inferred_obj_type = obj_name
 
             elif isinstance(base_obj_node, ast.Call):
                 inferred_obj_type = self._resolve_type_from_call(base_obj_node)
-            
+
             elif isinstance(base_obj_node, ast.Attribute): # e.g., self.job_manager
                 # This handles nested attributes
                 # The goal is to find the type of `self.job_manager`, which is 'JobManager'
-                
+
                 # Resolve the base of the chain, e.g., get 'self' from 'self.job_manager'
                 base = base_obj_node
                 while isinstance(base, ast.Attribute):
@@ -477,11 +486,66 @@ class CodeVisitor(ast.NodeVisitor):
                     # In self.X.Y... The attribute we care about is the first one, X
                     attr_name = base_obj_node.attr
                     inferred_obj_type = self.class_symbol_table.get(attr_name)
-            
+
         elif isinstance(node.func, ast.Name):
             inferred_obj_type = (self.local_symbol_table.get(call_name) or
-                                 self.class_symbol_table.get(call_name) or
-                                 self.module_symbol_table.get(call_name))
+                                self.class_symbol_table.get(call_name) or
+                                self.module_symbol_table.get(call_name))
+    
+        #   there are no CALLS relationships originating from P2pkhAddress.to_address in the graph. This is the root cause of the find_all_callees tool reporting 0
+        #   results.
+
+        #   The problem is not with the find_all_callees query itself, but with the GraphBuilder's ability to correctly identify and create CALLS relationships for methods like
+        #   P2pkhAddress.to_address.
+
+        #   Specifically, the GraphBuilder._create_function_calls method is likely not correctly processing calls made within methods of a class, especially when those calls are to:
+        #    1. self.method(): Internal method calls.
+        #    2. Functions imported from other modules (e.g., h_to_b, get_network).
+        #    3. Functions from external libraries (e.g., hashlib.sha256, b58encode).
+
+        #   The GraphBuilder.CodeVisitor.visit_Call method is responsible for identifying function calls. It needs to be improved to handle these cases.
+
+        #   Plan:
+
+        #    1. Enhance `CodeVisitor.visit_Call` in `src/codegraphcontext/tools/graph_builder.py`:
+        #        * Internal Method Calls (`self.method()`): When node.func is an ast.Attribute and node.func.value.id is self, the call_name should be node.func.attr, and the resolved_path should
+        #          be the file_path of the current class.
+        #        * Imported Functions: The _create_function_calls method already has some logic for resolving imported functions using imports_map. I need to ensure this logic is robust and
+        #          correctly applied within visit_Call to set inferred_obj_type or resolved_path accurately.
+        #        * External Library Functions: For now, we might not be able to fully resolve calls to external library functions unless those libraries are also indexed. However, we should at
+        #          least capture the full_call_name and call_name for these.
+        # inferred_obj_type = None
+        # if isinstance(node.func, ast.Attribute):
+        #     base_obj_node = node.func.value
+            
+        #     if isinstance(base_obj_node, ast.Name):
+        #         obj_name = base_obj_node.id
+        #         if obj_name == 'self':
+        #             # If the base is 'self', the call is to a method of the current class
+        #             inferred_obj_type = self.current_class
+        #         else:
+        #             # Try to resolve the type of the object from symbol tables
+        #             inferred_obj_type = (self.local_symbol_table.get(obj_name) or
+        #                                  self.class_symbol_table.get(obj_name) or
+        #                                  self.module_symbol_table.get(obj_name))
+        #             # If not found in symbol tables, check if it's a class name from imports
+        #             if not inferred_obj_type and obj_name in self.imports_map:
+        #                 inferred_obj_type = obj_name
+
+        #     elif isinstance(base_obj_node, ast.Call):
+        #         inferred_obj_type = self._resolve_type_from_call(base_obj_node)
+            
+        #     elif isinstance(base_obj_node, ast.Attribute): # e.g., self.job_manager.method()
+        #         # Recursively resolve the type of the base attribute
+        #         inferred_obj_type = self._resolve_attribute_base_type(base_obj_node)
+            
+        # elif isinstance(node.func, ast.Name):
+        #     # If it's a direct function call, try to infer its type from symbol tables or imports
+        #     inferred_obj_type = (self.local_symbol_table.get(call_name) or
+        #                          self.class_symbol_table.get(call_name) or
+        #                          self.module_symbol_table.get(call_name))
+        #     if not inferred_obj_type and call_name in self.imports_map:
+        #         inferred_obj_type = call_name
 
         if call_name and call_name not in __builtins__:
             call_data = {
@@ -621,12 +685,36 @@ class GraphBuilder:
                         MERGE (f)-[:CONTAINS]->(n)
                     """
                     session.run(query, file_path=file_path_str, name=item['name'], line_number=item['line_number'], props=item)
+                    
+                    # If it's a function, create parameter nodes and relationships and calculate complexity
+                    if label == 'Function':
+                        # Calculate cyclomatic complexity
+                        try:
+                            func_tree = ast.parse(item['source_code'])
+                            complexity_visitor = CyclomaticComplexityVisitor()
+                            complexity_visitor.visit(func_tree)
+                            item['cyclomatic_complexity'] = complexity_visitor.complexity
+                        except Exception as e:
+                            logger.warning(f"Could not calculate cyclomatic complexity for {item['name']} in {file_path_str}: {e}")
+                            item['cyclomatic_complexity'] = 1 # Default to 1 on error
+
+                        for arg_name in item.get('args', []):
+                            session.run("""
+                                MATCH (fn:Function {name: $func_name, file_path: $file_path, line_number: $line_number})
+                                MERGE (p:Parameter {name: $arg_name, file_path: $file_path, function_line_number: $line_number})
+                                MERGE (fn)-[:HAS_PARAMETER]->(p)
+                            """, func_name=item['name'], file_path=file_path_str, line_number=item['line_number'], arg_name=arg_name)
 
             for imp in file_data['imports']:
-                session.run("""
-                    MATCH (f:File {path: $file_path})
-                    MERGE (m:Module {name: $name})
-                    SET m.alias = $alias
+                set_clauses = ["m.alias = $alias"]
+                if 'full_import_name' in imp:
+                    set_clauses.append("m.full_import_name = $full_import_name")
+                set_clause_str = ", ".join(set_clauses)
+
+                session.run(f"""
+                    MATCH (f:File {{path: $file_path}})
+                    MERGE (m:Module {{name: $name}})
+                    SET {set_clause_str}
                     MERGE (f)-[:IMPORTS]->(m)
                 """, file_path=file_path_str, **imp)
 
@@ -663,9 +751,20 @@ class GraphBuilder:
 
         for var in file_data.get('variables', []):
             context = var.get('context')
+            class_context = var.get('class_context')
             parent_line = var.get('parent_line')
             
-            if context and parent_line:
+            if class_context:
+                session.run("""
+                    MATCH (c:Class {name: $class_name, file_path: $file_path})
+                    MATCH (v:Variable {name: $var_name, file_path: $file_path, line_number: $var_line})
+                    MERGE (c)-[:CONTAINS]->(v)
+                """,
+                class_name=class_context,
+                file_path=file_path,
+                var_name=var['name'],
+                var_line=var['line_number'])
+            elif context and parent_line:
                 parent_label = "Function"
                 parent_node_data = None
                 
@@ -749,7 +848,11 @@ class GraphBuilder:
             
             # Fallback if no path could be resolved by any of the above rules
             if not resolved_path:
-                resolved_path = caller_file_path
+                # If the called name is in the imports map, use its path
+                if called_name in imports_map and imports_map[called_name]:
+                    resolved_path = imports_map[called_name][0] # Take the first path for now
+                else:
+                    resolved_path = caller_file_path
 
             caller_context = call.get('context')
             inferred_type = call.get('inferred_obj_type')

{codegraphcontext-0.1.7 → codegraphcontext-0.1.8}/src/codegraphcontext/tools/import_extractor.py

@@ -6,6 +6,18 @@ from pathlib import Path
 from typing import Set
 
 import stdlibs
+import os
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+def debug_log(message):
+    """Write debug message to a file"""
+    debug_file = os.path.expanduser("~/mcp_debug.log")
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    with open(debug_file, "a") as f:
+        f.write(f"[{timestamp}] {message}\n")
+        f.flush()
 
 logger = logging.getLogger(__name__)
 
@@ -32,6 +44,7 @@ class ImportExtractor:
                         imports.add(node.module.split('.')[0]) # Get top-level package
         except Exception as e:
             logger.warning(f"Error parsing or reading {file_path}: {e}")
+        debug_log(f"Raw imports extracted from {file_path}: {imports}") # Add this line
         return imports
 
 

{codegraphcontext-0.1.7 → codegraphcontext-0.1.8/src/codegraphcontext.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.1.7
+Version: 0.1.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
@@ -53,9 +53,13 @@ Dynamic: license-file
 # CodeGraphContext
 [![Build Status](https://github.com/Shashankss1205/CodeGraphContext/actions/workflows/test.yml/badge.svg)](https://github.com/Shashankss1205/CodeGraphContext/actions/workflows/test.yml)
 
-
 An MCP server that indexes local code into a graph database to provide context to AI assistants.
 
+## Project Details
+- **Version:** 0.1.8
+- **Authors:** Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
+- **License:** MIT License (See [LICENSE](LICENSE) for details)
+
 ## Features
 
 -   **Code Indexing:** Analyzes Python code and builds a knowledge graph of its components.
@@ -63,12 +67,23 @@ An MCP server that indexes local code into a graph database to provide context t
 -   **Live Updates:** Watches local files for changes and automatically updates the graph.
 -   **Interactive Setup:** A user-friendly command-line wizard for easy setup.
 
+## Dependencies
+
+- `neo4j>=5.15.0`
+- `watchdog>=3.0.0`
+- `requests>=2.31.0`
+- `stdlibs>=2023.11.18`
+- `typer[all]>=0.9.0`
+- `rich>=13.7.0`
+- `inquirerpy>=0.3.4`
+- `python-dotenv>=1.0.0`
+
 ## Getting Started
 
 1.  **Install:** `pip install codegraphcontext`
 2.  **Setup:** `cgc setup`
 3.  **Start:** `cgc start`
-4.  **Index Code:** `cgc tool add-code-to-graph '{"path": "/path/to/your/project"}'`
+4.  **Index Code:** `cgc tool add-code-to-graph '{"path": "/path/to/your/project"}'` (Under active development)
 
 ## MCP Client Configuration
 
@@ -98,7 +113,11 @@ Add the following to your MCP client's configuration:
           "analyze_code_relationships",
           "watch_directory",
           "find_dead_code",
-          "execute_cypher_query"
+          "execute_cypher_query",
+          "calculate_cyclomatic_complexity",
+          "find_most_complex_functions",
+          "list_indexed_repositories",
+          "delete_repository"
         ],
         "disabled": false
       },
@@ -149,5 +168,22 @@ Once the server is running, you can interact with it through your AI assistant u
     -   "Which files import the `requests` library?"
     -   "Find all implementations of the `render` method."
 
+-   **Advanced Call Chain and Dependency Tracking (Spanning Hundreds of Files):**
+    The CodeGraphContext excels at tracing complex execution flows and dependencies across vast codebases. Leveraging the power of graph databases, it can identify direct and indirect callers and callees, even when a function is called through multiple layers of abstraction or across numerous files. This is invaluable for:
+    -   **Impact Analysis:** Understand the full ripple effect of a change to a core function.
+    -   **Debugging:** Trace the path of execution from an entry point to a specific bug.
+    -   **Code Comprehension:** Grasp how different parts of a large system interact.
+
+    -   "Show me the full call chain from the `main` function to `process_data`."
+    -   "Find all functions that directly or indirectly call `validate_input`."
+    -   "What are all the functions that `initialize_system` eventually calls?"
+    -   "Trace the dependencies of the `DatabaseManager` module."
+
 -   **Code Quality and Maintenance:**
     -   "Is there any dead or unused code in this project?"
+    -   "Calculate the cyclomatic complexity of the `process_data` function in `src/utils.py`."
+    -   "Find the 5 most complex functions in the codebase."
+
+-   **Repository Management:**
+    -   "List all currently indexed repositories."
+    -   "Delete the indexed repository at `/path/to/old-project`."