codegraphcontext 0.1.0__py3-none-any.whl

codegraphcontext/__init__.py

@@ -0,0 +1,2 @@
+# src/codegraphcontext/__init__.py
+# This makes 'codegraphcontext' a package.

codegraphcontext/__main__.py

@@ -0,0 +1,5 @@
+# src/codegraphcontext/__main__.py
+from .cli.main import app
+
+if __name__ == "__main__":
+    app()

codegraphcontext/prompts.py

@@ -0,0 +1,75 @@
+# src/codegraphcontext/prompts.py
+
+LLM_SYSTEM_PROMPT = """# AI Pair Programmer Instructions
+
+## 1. Your Role and Goal
+
+You are an expert AI pair programmer. Your primary goal is to help a developer understand, write, and refactor code within their **local project**. Your defining feature is your connection to a local Model Context Protocol (MCP) server, which gives you real-time, accurate information about the codebase.
+
+## 2. Your Core Principles
+
+### Principle I: Ground Your Answers in Fact
+**Your CORE DIRECTIVE is to use the provided tools to gather facts from the MCP server *before* answering questions or generating code.** Do not guess. Your value comes from providing contextually-aware, accurate assistance.
+
+### Principle II: Be an Agent, Not Just a Planner
+**Your goal is to complete the user's task in the fewest steps possible.**
+* If the user's request maps directly to a single tool, **execute that tool immediately.**
+* Do not create a multi-step plan for a one-step task. The Standard Operating Procedures (SOPs) below are for complex queries that require reasoning and combining information from multiple tools.
+
+**Example of what NOT to do:**
+
+> **User:** "Start watching the `my-project` folder."
+> **Incorrect Plan:**
+> 1. Check if `watchdog` is installed.
+> 2. Use the `watch_directory` tool on `my-project`.
+> 3. Update a todo list.
+
+**Example of the CORRECT, direct action:**
+
+> **User:** "Start watching the `my-project` folder."
+> **Correct Action:** Immediately call the `watch_directory` tool.
+> ```json
+> {
+>   "tool_name": "watch_directory",
+>   "arguments": { "path": "my-project" }
+> }
+> ```
+
+## 3. Tool Manifest & Usage
+
+| Tool Name                    | Purpose & When to Use                                                                                                                 |
+| :--------------------------- | :------------------------------------------------------------------------------------------------------------------------------------ |
+| **`find_code`** | **Your primary search tool.** Use this first for almost any query about locating code.                                                |
+| **`analyze_code_relationships`** | **Your deep analysis tool.** Use this after locating a specific item. Use query types like `find_callers` or `find_callees`.      |
+| **`add_code_to_graph`** | **Your indexing tool.** Use this when the user wants to add a new project folder or file to the context.                               |
+| **`add_package_to_graph`** | **Your dependency indexing tool.** Use this to add a `pip` package to the context.                                                    |
+| **`list_jobs`** & **`check_job_status`** | **Your job monitoring tools.** |
+| **`watch_directory`** | **Your live-update tool.** Use this if the user wants to automatically keep the context updated as they work.                         |
+| **`execute_cypher_query`** | **Expert Fallback Tool.** Use this *only* when other tools cannot answer a very specific or complex question about the code graph. Requires knowledge of Cypher. |
+
+
+## 4. Standard Operating Procedures (SOPs) for Complex Tasks
+
+**Note:** Follow these methodical workflows for **complex requests** that require multiple steps of reasoning or combining information from several tools. For direct commands, refer to Principle II and act immediately.
+
+### SOP-1: Answering "Where is...?" or "How does...?" Questions
+1.  **Locate:** Use `find_code` to find the relevant code.
+2.  **Analyze:** Use `analyze_code_relationships` to understand its usage.
+3.  **Synthesize:** Combine the information into a clear explanation.
+
+### SOP-2: Generating New Code
+1.  **Find Context:** Use `find_code` to find similar, existing code to match the style.
+2.  **Find Reusable Code:** Use `find_code` to locate specific helper functions the user wants you to use.
+3.  **Generate:** Write the code using the correct imports and signatures.
+
+### SOP-3: Refactoring or Analyzing Impact
+1.  **Identify & Locate:** Use `find_code` to get the canonical path of the item to be changed.
+2.  **Assess Impact:** Use `analyze_code_relationships` with the `find_callers` query type to find all affected locations.
+3.  **Report Findings:** Present a clear list of all affected files.
+
+### SOP-4: Using the Cypher Fallback
+1.  **Attempt Standard Tools:** First, always try to use `find_code` and `analyze_code_relationships`.
+2.  **Identify Failure:** If the standard tools cannot answer a complex, multi-step relationship query (e.g., "Find all functions that are called by a method in a class that inherits from 'BaseHandler'"), then and only then, resort to the fallback.
+3.  **Formulate & Execute:** Construct a Cypher query to find the answer and execute it using `execute_cypher_query`.
+4.  **Present Results:** Explain the results to the user based on the query output.
+"""

codegraphcontext/server.py

@@ -0,0 +1,630 @@
+# src/codegraphcontext/server.py
+import asyncio
+import json
+import logging
+import importlib
+import stdlibs
+import sys
+import traceback
+import os
+from datetime import datetime
+from pathlib import Path
+from neo4j.exceptions import CypherSyntaxError
+from dataclasses import asdict
+from codegraphcontext.core.database import DatabaseManager
+
+from typing import Any, Dict, Coroutine, Optional
+
+from .prompts import LLM_SYSTEM_PROMPT
+from .core.database import DatabaseManager
+from .core.jobs import JobManager, JobStatus
+from .core.watcher import CodeWatcher
+from .tools.graph_builder import GraphBuilder
+from .tools.code_finder import CodeFinder
+from .tools.import_extractor import ImportExtractor
+
+
+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()
+
+class MCPServer:
+    """Main MCP Server class that orchestrates all components."""
+
+    def __init__(self, loop=None):
+        try:
+            self.db_manager = DatabaseManager()
+            self.db_manager.get_driver() # Initialize connection early
+        except ValueError as e:
+            raise ValueError(f"Database configuration error: {e}")
+
+        self.job_manager = JobManager()
+        
+        # Get the current event loop to pass to thread-sensitive components
+        if loop is None:
+            try:
+                loop = asyncio.get_running_loop()
+            except RuntimeError:
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+        self.loop = loop
+
+        # Initialize tool handlers
+        self.graph_builder = GraphBuilder(self.db_manager, self.job_manager, loop)
+        self.code_finder = CodeFinder(self.db_manager)
+        self.import_extractor = ImportExtractor()
+        
+        self.code_watcher = CodeWatcher(self.graph_builder)
+        
+        self._init_tools()
+
+    def _init_tools(self):
+        """Defines the complete tool manifest for the LLM."""
+        self.tools = {
+            "add_code_to_graph": {
+                "name": "add_code_to_graph",
+                "description": "Add code from a local folder to the graph. Returns a job ID for background processing.",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "path": {"type": "string", "description": "Path to the directory or file to add."},
+                        "is_dependency": {"type": "boolean", "description": "Whether this code is a dependency.", "default": False}
+                    },
+                    "required": ["path"]
+                }
+            },
+            "check_job_status": {
+                "name": "check_job_status",
+                "description": "Check the status and progress of a background job.",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": { "job_id": {"type": "string", "description": "Job ID from a previous tool call"} },
+                    "required": ["job_id"]
+                }
+            },
+            "list_jobs": {
+                "name": "list_jobs",
+                "description": "List all background jobs and their current status.",
+                "inputSchema": {"type": "object", "properties": {}}
+            },
+            "find_code": {
+                "name": "find_code",
+                "description": "Find relevant code snippets related to a keyword (e.g., function name, class name, or content).",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": { "query": {"type": "string", "description": "Keyword or phrase to search for"} },
+                    "required": ["query"]
+                }
+            },
+            "analyze_code_relationships": {
+                "name": "analyze_code_relationships",
+                "description": "Analyze code relationships like 'who calls this function' or 'class hierarchy'.",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "query_type": {"type": "string", "description": "Type of relationship query to run."},
+                        "target": {"type": "string", "description": "The function, class, or module to analyze."},
+                        "context": {"type": "string", "description": "Optional: specific file path for precise results."}
+                    },
+                    "required": ["query_type", "target"]
+                }
+            },
+            "watch_directory": {
+                "name": "watch_directory",
+                "description": "Start watching a directory for code changes and automatically update the graph.",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": { "path": {"type": "string", "description": "Path to directory to watch"} },
+                    "required": ["path"]
+                }
+            },
+            "execute_cypher_query": {
+                "name": "execute_cypher_query",
+                "description": "Fallback tool to run a direct, read-only Cypher query against the code graph.",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": { "cypher_query": {"type": "string", "description": "The read-only Cypher query to execute."} },
+                    "required": ["cypher_query"]
+                }
+            },
+            "add_package_to_graph": {
+                "name": "add_package_to_graph",
+                "description": "Add a Python package to Neo4j graph by discovering its location. Returns immediately with job ID.",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "package_name": {"type": "string", "description": "Name of the Python package to add (e.g., 'requests')"},
+                        "is_dependency": {"type": "boolean", "description": "Mark as a dependency", "default": True}
+                    },
+                    "required": ["package_name"]
+                }
+            },
+            "list_imports": {
+                "name": "list_imports",
+                "description": "Extract all package imports from code files in a directory or file",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "path": {"type": "string", "description": "Path to file or directory to analyze"},
+                        "language": {"type": "string", "description": "Programming language (python, javascript, etc.)", "default": "python"},
+                        "recursive": {"type": "boolean", "description": "Whether to analyze subdirectories recursively", "default": True}
+                    },
+                    "required": ["path"]
+                }
+            },
+            "find_dead_code": {
+                "name": "find_dead_code",
+                "description": "Find potentially unused functions (dead code) across the entire indexed codebase.",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {},
+                    "additionalProperties": False
+                }
+            }
+            # Other tools like list_imports, add_package_to_graph can be added here following the same pattern
+        }
+
+    
+
+    def get_database_status(self) -> dict:
+        """Get current database connection status"""
+        return {"connected": self.db_manager.is_connected()}
+        
+    def get_local_package_path(self, package_name: str) -> Optional[str]:
+        """Get the local installation path of a Python package"""
+        try:
+            debug_log(f"Getting local path for package: {package_name}")
+            
+            module = importlib.import_module(package_name)
+            
+            if hasattr(module, '__file__') and module.__file__:
+                module_file = module.__file__
+                debug_log(f"Module file: {module_file}")
+                
+                if module_file.endswith('__init__.py'):
+                    package_path = os.path.dirname(module_file)
+                else:
+                    package_path = os.path.dirname(module_file)
+                
+                debug_log(f"Package path: {package_path}")
+                return package_path
+            
+            elif hasattr(module, '__path__'):
+                if isinstance(module.__path__, list) and module.__path__:
+                    package_path = module.__path__[0]
+                    debug_log(f"Package path from __path__: {package_path}")
+                    return package_path
+                else:
+                    package_path = str(module.__path__)
+                    debug_log(f"Package path from __path__ (str): {package_path}")
+                    return package_path
+            
+            debug_log(f"Could not determine path for {package_name}")
+            return None
+            
+        except ImportError as e:
+            debug_log(f"Could not import {package_name}: {e}")
+            return None
+        except Exception as e:
+            debug_log(f"Error getting local path for {package_name}: {e}")
+            return None
+        
+    def execute_cypher_query_tool(self, **args) -> Dict[str, Any]:
+        """
+        Tool to execute a read-only Cypher query.
+        This is a powerful tool and includes safety checks to prevent database modification.
+        """
+        cypher_query = args.get("cypher_query")
+        if not cypher_query:
+            return {"error": "Cypher query cannot be empty."}
+
+        # Safety Check: Prevent write operations.
+        forbidden_keywords = ['CREATE', 'MERGE', 'DELETE', 'SET', 'REMOVE', 'DROP', 'CALL apoc']
+        query_upper = cypher_query.upper()
+        if any(keyword in query_upper for keyword in forbidden_keywords):
+            return {
+                "error": "This tool only supports read-only queries. Prohibited keywords like CREATE, MERGE, DELETE, SET, etc., are not allowed."
+            }
+
+        try:
+            debug_log(f"Executing Cypher query: {cypher_query}")
+            with self.db_manager.get_driver().session() as session:
+                result = session.run(cypher_query)
+                # Convert results to a list of dictionaries for JSON serialization
+                records = [record.data() for record in result]
+                
+                return {
+                    "success": True,
+                    "query": cypher_query,
+                    "record_count": len(records),
+                    "results": records
+                }
+        
+        except CypherSyntaxError as e:
+            debug_log(f"Cypher syntax error: {str(e)}")
+            return {
+                "error": "Cypher syntax error.",
+                "details": str(e),
+                "query": cypher_query
+            }
+        except Exception as e:
+            debug_log(f"Error executing Cypher query: {str(e)}")
+            return {
+                "error": "An unexpected error occurred while executing the query.",
+                "details": str(e)
+            }
+    
+    def find_dead_code_tool(self) -> Dict[str, Any]:
+        """Tool to find potentially dead code across the entire project."""
+        try:
+            debug_log("Finding dead code.")
+            # The target argument from the old tool is not needed.
+            results = self.code_finder.find_dead_code()
+            
+            return {
+                "success": True,
+                "query_type": "dead_code",
+                "results": results
+            }
+        except Exception as e:
+            debug_log(f"Error finding dead code: {str(e)}")
+            return {"error": f"Failed to find dead code: {str(e)}"}
+
+    def watch_directory_tool(self, **args) -> Dict[str, Any]:
+        """Tool to start watching a directory."""
+        path = args.get("path")
+        if not path or not Path(path).is_dir():
+            return {"error": f"Invalid path provided: {path}. Must be a directory."}
+
+        try:
+            initial_scan_result = self.add_code_to_graph_tool(path=path, is_dependency=False)
+            if "error" in initial_scan_result:
+                return initial_scan_result
+
+            self.code_watcher.watch_directory(path)
+            
+            return {
+                "success": True,
+                "message": f"Initial scan started (Job ID: {initial_scan_result.get('job_id')}). Now watching for live changes in {path}.",
+                "instructions": "Changes to .py files in this directory will now be automatically updated in the graph."
+            }
+        except Exception as e:
+            logger.error(f"Failed to start watching directory {path}: {e}")
+            return {"error": f"Failed to start watching directory: {str(e)}"}
+        
+    def list_imports_tool(self, **args) -> Dict[str, Any]:
+        """Tool to list all imports from code files"""        
+        path = args.get("path")
+        language = args.get("language", "python")
+        recursive = args.get("recursive", True)
+        all_imports = set()
+        file_extensions = {
+            'python': ['.py'], 'javascript': ['.js', '.jsx', '.mjs'],
+            'typescript': ['.ts', '.tsx'], 'java': ['.java'],
+        }
+        
+        extensions = file_extensions.get(language, ['.py'])
+        extract_func = {
+            'python': self.import_extractor.extract_python_imports,
+            'javascript': self.import_extractor.extract_javascript_imports,
+            'typescript': self.import_extractor.extract_javascript_imports,
+            'java': self.import_extractor.extract_java_imports,
+        }.get(language, self.import_extractor.extract_python_imports)
+        
+        try:
+            path_obj = Path(path)
+            
+            if path_obj.is_file():
+                if any(str(path_obj).endswith(ext) for ext in extensions):
+                    all_imports.update(extract_func(str(path_obj)))
+            elif path_obj.is_dir():
+                pattern = "**/*" if recursive else "*"
+                for ext in extensions:
+                    for file_path in path_obj.glob(f"{pattern}{ext}"):
+                        if file_path.is_file():
+                            all_imports.update(extract_func(str(file_path)))
+            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
+            
+            return {
+                "imports": sorted(list(all_imports)), "language": language,
+                "path": path, "count": len(all_imports)
+            }
+        
+        except Exception as e:
+            return {"error": f"Failed to analyze imports: {str(e)}"}
+    
+    def add_code_to_graph_tool(self, **args) -> Dict[str, Any]:
+        """Tool to add code to Neo4j graph with background processing"""
+        path = args.get("path")
+        is_dependency = args.get("is_dependency", False)
+        
+        try:
+            path_obj = Path(path).resolve()
+
+            if not path_obj.exists():
+                return {"error": f"Path {path} does not exist"}
+            
+            total_files, estimated_time = self.graph_builder.estimate_processing_time(path_obj)
+            
+            job_id = self.job_manager.create_job(str(path_obj), is_dependency)
+            
+            self.job_manager.update_job(job_id, total_files=total_files, estimated_duration=estimated_time)
+            
+            coro = self.graph_builder.build_graph_from_path_async(
+                path_obj, is_dependency, job_id
+            )
+            asyncio.run_coroutine_threadsafe(coro, self.loop)
+            
+            debug_log(f"Started background job {job_id} for path: {str(path_obj)}, is_dependency: {is_dependency}")
+            
+            return {
+                "success": True, "job_id": job_id,
+                "message": f"Background processing started for {str(path_obj)}",
+                "estimated_files": total_files,
+                "estimated_duration_seconds": round(estimated_time, 2),
+                "estimated_duration_human": f"{int(estimated_time // 60)}m {int(estimated_time % 60)}s" if estimated_time >= 60 else f"{int(estimated_time)}s",
+                "instructions": f"Use 'check_job_status' with job_id '{job_id}' to monitor progress"
+            }
+        
+        except Exception as e:
+            debug_log(f"Error creating background job: {str(e)}")
+            return {"error": f"Failed to start background processing: {str(e)}"}
+    
+    def add_package_to_graph_tool(self, **args) -> Dict[str, Any]:
+        """Tool to add a Python package to Neo4j graph by auto-discovering its location"""
+        package_name = args.get("package_name")
+        is_dependency = args.get("is_dependency", True)
+        
+        try:
+            package_path = self.get_local_package_path(package_name)
+            
+            if not package_path:
+                return {"error": f"Could not find package '{package_name}'. Make sure it's installed."}
+            
+            if not os.path.exists(package_path):
+                return {"error": f"Package path '{package_path}' does not exist"}
+            
+            path_obj = Path(package_path)
+            
+            total_files, estimated_time = self.graph_builder.estimate_processing_time(path_obj)
+            
+            job_id = self.job_manager.create_job(package_path, is_dependency)
+            
+            self.job_manager.update_job(job_id, total_files=total_files, estimated_duration=estimated_time)
+            
+            coro = self.graph_builder.build_graph_from_path_async(
+                path_obj, is_dependency, job_id
+            )
+            asyncio.run_coroutine_threadsafe(coro, self.loop)
+            
+            debug_log(f"Started background job {job_id} for package: {package_name} at {package_path}, is_dependency: {is_dependency}")
+            
+            return {
+                "success": True, "job_id": job_id, "package_name": package_name,
+                "discovered_path": package_path,
+                "message": f"Background processing started for package '{package_name}'",
+                "estimated_files": total_files,
+                "estimated_duration_seconds": round(estimated_time, 2),
+                "estimated_duration_human": f"{int(estimated_time // 60)}m {int(estimated_time % 60)}s" if estimated_time >= 60 else f"{int(estimated_time)}s",
+                "instructions": f"Use 'check_job_status' with job_id '{job_id}' to monitor progress"
+            }
+        
+        except Exception as e:
+            debug_log(f"Error creating background job for package {package_name}: {str(e)}")
+            return {"error": f"Failed to start background processing for package '{package_name}': {str(e)}"}
+    
+    def check_job_status_tool(self, **args) -> Dict[str, Any]:
+        """Tool to check job status"""
+        job_id = args.get("job_id")
+                
+        try:
+            job = self.job_manager.get_job(job_id)
+            
+            if not job:
+                return {"error": f"Job {job_id} not found"}
+            
+            job_dict = asdict(job)
+            
+            if job.status == JobStatus.RUNNING:
+                if job.estimated_time_remaining:
+                    remaining = job.estimated_time_remaining
+                    job_dict["estimated_time_remaining_human"] = (
+                        f"{int(remaining // 60)}m {int(remaining % 60)}s" 
+                        if remaining >= 60 else f"{int(remaining)}s"
+                    )
+                
+                if job.start_time:
+                    elapsed = (datetime.now() - job.start_time).total_seconds()
+                    job_dict["elapsed_time_human"] = (
+                        f"{int(elapsed // 60)}m {int(elapsed % 60)}s" 
+                        if elapsed >= 60 else f"{int(elapsed)}s"
+                    )
+            
+            elif job.status == JobStatus.COMPLETED and job.start_time and job.end_time:
+                duration = (job.end_time - job.start_time).total_seconds()
+                job_dict["actual_duration_human"] = (
+                    f"{int(duration // 60)}m {int(duration % 60)}s" 
+                    if duration >= 60 else f"{int(duration)}s"
+                )
+            
+            job_dict["start_time"] = job.start_time.strftime("%Y-%m-%d %H:%M:%S")
+            if job.end_time:
+                job_dict["end_time"] = job.end_time.strftime("%Y-%m-%d %H:%M:%S")
+            
+            job_dict["status"] = job.status.value
+            
+            return {"success": True, "job": job_dict}
+        
+        except Exception as e:
+            debug_log(f"Error checking job status: {str(e)}")
+            return {"error": f"Failed to check job status: {str(e)}"}
+    
+    def list_jobs_tool(self) -> Dict[str, Any]:
+        """Tool to list all jobs"""
+        try:
+            jobs = self.job_manager.list_jobs()
+            
+            jobs_data = []
+            for job in jobs:
+                job_dict = asdict(job)
+                job_dict["status"] = job.status.value
+                job_dict["start_time"] = job.start_time.strftime("%Y-%m-%d %H:%M:%S")
+                if job.end_time:
+                    job_dict["end_time"] = job.end_time.strftime("%Y-%m-%d %H:%M:%S")
+                jobs_data.append(job_dict)
+            
+            jobs_data.sort(key=lambda x: x["start_time"], reverse=True)
+            
+            return {"success": True, "jobs": jobs_data, "total_jobs": len(jobs_data)}
+        
+        except Exception as e:
+            debug_log(f"Error listing jobs: {str(e)}")
+            return {"error": f"Failed to list jobs: {str(e)}"}
+    
+    def analyze_code_relationships_tool(self, **args) -> Dict[str, Any]:
+        """Tool to analyze code relationships"""
+        query_type = args.get("query_type")
+        target = args.get("target")
+        context = args.get("context")
+
+        if not query_type or not target:
+            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"
+                ]
+            }
+        
+        try:
+            debug_log(f"Analyzing relationships: {query_type} for {target}")
+            results = self.code_finder.analyze_code_relationships(query_type, target, context)
+            
+            return {
+                "success": True, "query_type": query_type, "target": target,
+                "context": context, "results": results
+            }
+        
+        except Exception as e:
+            debug_log(f"Error analyzing relationships: {str(e)}")
+            return {"error": f"Failed to analyze relationships: {str(e)}"}
+
+    def find_code_tool(self, **args) -> Dict[str, Any]:
+        """Tool to find relevant code snippets"""
+        query = args.get("query")
+        
+        try:
+            debug_log(f"Finding code for query: {query}")
+            results = self.code_finder.find_related_code(query)
+            
+            return {"success": True, "query": query, "results": results}
+        
+        except Exception as e:
+            debug_log(f"Error finding code: {str(e)}")
+            return {"error": f"Failed to find code: {str(e)}"}
+    
+
+    async def handle_tool_call(self, tool_name: str, args: Dict[str, Any]) -> Dict[str, Any]:
+        """Routes a tool call to the appropriate handler."""
+        tool_map: Dict[str, Coroutine] = {
+            "list_imports": self.list_imports_tool,
+            "add_package_to_graph": self.add_package_to_graph_tool,
+            "find_dead_code": self.find_dead_code_tool,
+            "find_code": self.find_code_tool,
+            "analyze_code_relationships": self.analyze_code_relationships_tool,
+            "watch_directory": self.watch_directory_tool,
+            "execute_cypher_query": self.execute_cypher_query_tool,
+            "add_code_to_graph": self.add_code_to_graph_tool,
+            "check_job_status": self.check_job_status_tool,
+            "list_jobs": self.list_jobs_tool
+        }
+        handler = tool_map.get(tool_name)
+        if handler:
+            return await asyncio.to_thread(handler, **args)
+        else:
+            return {"error": f"Unknown tool: {tool_name}"}
+
+    async def run(self):
+        """Runs the main server loop, listening for JSON-RPC requests."""
+        logger.info("MCP Server is running. Waiting for requests...")
+        self.code_watcher.start()
+        
+        loop = asyncio.get_event_loop()
+        while True:
+            try:
+                line = await loop.run_in_executor(None, sys.stdin.readline)
+                if not line:
+                    logger.info("Client disconnected (EOF received). Shutting down.")
+                    break
+                
+                request = json.loads(line.strip())
+                method = request.get('method')
+                params = request.get('params', {})
+                request_id = request.get('id')
+                
+                response = {}
+                if method == 'initialize':
+                    response = {
+                        "jsonrpc": "2.0", "id": request_id,
+                        "result": {
+                            "protocolVersion": "2024-11-05",
+                            "serverInfo": {
+                                "name": "CodeGraphContext", "version": "0.1.0",
+                                "systemPrompt": LLM_SYSTEM_PROMPT
+                            },
+                            "capabilities": {"tools": {"listTools": True}},
+                        }
+                    }
+                elif method == 'tools/list':
+                    # This now correctly returns the list of defined tools
+                    response = {
+                        "jsonrpc": "2.0", "id": request_id,
+                        "result": {"tools": list(self.tools.values())}
+                    }
+                elif method == 'tools/call':
+                    tool_name = params.get('name')
+                    args = params.get('arguments', {})
+                    result = await self.handle_tool_call(tool_name, args)
+                    response = {
+                        "jsonrpc": "2.0", "id": request_id,
+                        "result": {"content": [{"type": "text", "text": json.dumps(result, indent=2)}]}
+                    }
+                else:
+                    response = {
+                        "jsonrpc": "2.0", "id": request_id,
+                        "error": {"code": -32601, "message": f"Method not found: {method}"}
+                    }
+                
+                print(json.dumps(response), flush=True)
+
+            except Exception as e:
+                logger.error(f"Error processing request: {e}\n{traceback.format_exc()}")
+                error_response = {
+                    "jsonrpc": "2.0", "id": request.get('id') if 'request' in locals() else None,
+                    "error": {"code": -32603, "message": f"Internal error: {str(e)}", "data": traceback.format_exc()}
+                }
+                print(json.dumps(error_response), flush=True)
+
+    def shutdown(self):
+        logger.info("Shutting down server...")
+        self.code_watcher.stop()
+        self.db_manager.close_driver()

codegraphcontext-0.1.0.dist-info/METADATA

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: codegraphcontext
+Version: 0.1.0
+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
+        
+        Copyright (c) 2025
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/Shashankss1205/CodeGraphContext
+Project-URL: Bug Tracker, https://github.com/Shashankss1205/CodeGraphContext/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: neo4j>=5.15.0
+Requires-Dist: watchdog>=3.0.0
+Requires-Dist: requests>=2.31.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.4
+Requires-Dist: python-dotenv>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: black>=23.11.0; extra == "dev"
+Dynamic: license-file
+
+# CodeGraphContext
+
+An MCP server that indexes local code into a graph database to provide context to AI assistants.
+
+## Features
+
+-   **Code Indexing:** Analyzes Python code and builds a knowledge graph of its components.
+-   **Relationship Analysis:** Query for callers, callees, class hierarchies, and more.
+-   **Live Updates:** Watches local files for changes and automatically updates the graph.
+-   **Interactive Setup:** A user-friendly command-line wizard for easy setup.
+
+## 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"}'`
+
+## MCP Client Configuration
+
+Add the following to your MCP client's configuration:
+
+```json
+{
+  "mcpServers": {
+    "CodeGraphContext": {
+      "command": "cgc",
+      "args": [
+        "start"
+      ],
+      "env": {
+        "NEO4J_URI": "************",
+        "NEO4J_USER": "************",
+        "NEO4J_PASSWORD": "**************"
+      },
+      "tools": {
+        "alwaysAllow": [
+          "list_imports",
+          "add_code_to_graph",
+          "add_package_to_graph",
+          "check_job_status",
+          "list_jobs",
+          "find_code",
+          "analyze_code_relationships",
+          "watch_directory",
+          "find_dead_code",
+          "execute_cypher_query"
+        ],
+        "disabled": false
+      },
+      "disabled": false,
+      "alwaysAllow": []
+    }
+  }
+}
+```
+
+## Natural Language Interaction Examples
+
+Once the server is running, you can interact with it through your AI assistant using plain English. Here are some examples of what you can say:
+
+### Indexing and Watching Files
+
+-   **To index a new project:**
+    -   "Please index the code in the `/path/to/my-project` directory."
+    OR
+    -   "Add the project at `~/dev/my-other-project` to the code graph."
+
+
+-   **To start watching a directory for live changes:**
+    -   "Watch the `/path/to/my-active-project` directory for changes."
+    OR
+    -   "Keep the code graph updated for the project I'm working on at `~/dev/main-app`."
+
+### Querying and Understanding Code
+
+-   **Finding where code is defined:**
+    -   "Where is the `process_payment` function?"
+    -   "Find the `User` class for me."
+    -   "Show me any code related to 'database connection'."
+
+-   **Analyzing relationships and impact:**
+    -   "What other functions call the `get_user_by_id` function?"
+    -   "If I change the `calculate_tax` function, what other parts of the code will be affected?"
+    -   "Show me the inheritance hierarchy for the `BaseController` class."
+    -   "What methods does the `Order` class have?"
+
+-   **Exploring dependencies:**
+    -   "Which files import the `requests` library?"
+    -   "Find all implementations of the `render` method."
+
+-   **Code Quality and Maintenance:**
+    -   "Is there any dead or unused code in this project?"

codegraphcontext-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+codegraphcontext/__init__.py,sha256=mFY5raGZpG90gG6E8NH0R85mDl3Ikak2HQHOiwCXl-I,77
+codegraphcontext/__main__.py,sha256=21QjL_lfd6cy-clJYPBg6xKb_IuNDcvvWdaAJEvZ-HQ,99
+codegraphcontext/prompts.py,sha256=gu0T_N7QwTIil1WhRiO1eI4KUCeKfDiztH9MvcgsV24,5037
+codegraphcontext/server.py,sha256=pZ8QumE95M24tO-kcQyKmEMVXgE3Zg-tLmhiucGKDdc,28364
+codegraphcontext-0.1.0.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
+codegraphcontext-0.1.0.dist-info/METADATA,sha256=Ad7HCv7wm3XALyDXU3UALqDlvHkcPWWNCjoWc_2_Bx4,5352
+codegraphcontext-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+codegraphcontext-0.1.0.dist-info/entry_points.txt,sha256=74LVRivtqMnlXdAamQTLkkxUp12zVAmDRFbAV4kArss,54
+codegraphcontext-0.1.0.dist-info/top_level.txt,sha256=CBgc6LAPZIO5FS0nSYYkylDifHsZTIqw3Gf5UwDxeGI,17
+codegraphcontext-0.1.0.dist-info/RECORD,,

codegraphcontext-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

codegraphcontext-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cgc = codegraphcontext.cli.main:app

codegraphcontext-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

codegraphcontext-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+codegraphcontext