codegraphcontext 0.1.4__tar.gz → 0.1.6__tar.gz

{codegraphcontext-0.1.4/src/codegraphcontext.egg-info → codegraphcontext-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.1.4
+Version: 0.1.6
 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
@@ -123,6 +123,12 @@ Once the server is running, you can interact with it through your AI assistant u
     OR
     -   "Keep the code graph updated for the project I'm working on at `~/dev/main-app`."
 
+    When you ask to watch a directory, the system performs two actions at once:
+    1.  It kicks off a full scan to index all the code in that directory. This process runs in the background, and you'll receive a `job_id` to track its progress.
+    2.  It begins watching the directory for any file changes to keep the graph updated in real-time.
+
+    This means you can start by simply telling the system to watch a directory, and it will handle both the initial indexing and the continuous updates automatically.
+
 ### Querying and Understanding Code
 
 -   **Finding where code is defined:**

{codegraphcontext-0.1.4 → codegraphcontext-0.1.6}/README.md

@@ -72,6 +72,12 @@ Once the server is running, you can interact with it through your AI assistant u
     OR
     -   "Keep the code graph updated for the project I'm working on at `~/dev/main-app`."
 
+    When you ask to watch a directory, the system performs two actions at once:
+    1.  It kicks off a full scan to index all the code in that directory. This process runs in the background, and you'll receive a `job_id` to track its progress.
+    2.  It begins watching the directory for any file changes to keep the graph updated in real-time.
+
+    This means you can start by simply telling the system to watch a directory, and it will handle both the initial indexing and the continuous updates automatically.
+
 ### Querying and Understanding Code
 
 -   **Finding where code is defined:**

{codegraphcontext-0.1.4 → codegraphcontext-0.1.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codegraphcontext"
-version = "0.1.4"
+version = "0.1.6"
 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.6/src/codegraphcontext/cli/main.py

@@ -0,0 +1,93 @@
+# src/codegraphcontext/cli/main.py
+import typer
+from rich.console import Console
+import asyncio
+import logging
+from codegraphcontext.server import MCPServer
+from .setup_wizard import run_setup_wizard
+
+# Set the log level for the noisy neo4j logger to WARNING
+logging.getLogger("neo4j").setLevel(logging.WARNING) # <-- ADD THIS LINE
+
+app = typer.Typer(
+    name="cgc",
+    help="CodeGraphContext: An MCP server for AI-powered code analysis.",
+    add_completion=False,
+)
+console = Console()
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(name)s - %(message)s')
+
+@app.command()
+def setup():
+    """
+    Run the interactive setup wizard to configure the server and database.
+    """
+    run_setup_wizard()
+
+@app.command()
+def start():
+    """
+    Start the CodeGraphContext MCP server.
+    """
+    console.print("[bold green]Starting CodeGraphContext Server...[/bold green]")
+    server = None
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    try:
+        server = MCPServer(loop=loop)
+        loop.run_until_complete(server.run())
+    except ValueError as e:
+        console.print(f"[bold red]Configuration Error:[/bold red] {e}")
+        console.print("Please run `cgc setup` to configure the server.")
+    except KeyboardInterrupt:
+        console.print("\n[bold yellow]Server stopped by user.[/bold yellow]")
+    finally:
+        if server:
+            server.shutdown()
+        loop.close()
+
+
+@app.command()
+def tool(
+    name: str = typer.Argument(..., help="The name of the tool to call."),
+    args: str = typer.Argument("{}", help="A JSON string of arguments for the tool."),
+):
+    """
+    Directly call a CodeGraphContext tool.
+    Note: This command instantiates a new, independent MCP server instance for each call.
+    Therefore, it does not share state (like job IDs) with a server started via `cgc start`.
+
+    This command can be used for:\n
+    - `add_code_to_graph`: Index a new project or directory. Args: `path` (str), `is_dependency` (bool, optional)\n
+    - `add_package_to_graph`: Add a Python package to the graph. Args: `package_name` (str), `is_dependency` (bool, optional)\n
+    - `find_code`: Search for code snippets. Args: `query` (str)\n
+    - `analyze_code_relationships`: Analyze code relationships (e.g., callers, callees). Args: `query_type` (str), `target` (str), `context` (str, optional)\n
+    - `watch_directory`: Start watching a directory for changes. Args: `path` (str)\n
+    - `execute_cypher_query`: Run direct Cypher queries. Args: `cypher_query` (str)\n
+    - `list_imports`: List imports from files. Args: `path` (str), `language` (str, optional), `recursive` (bool, optional)\n
+    - `find_dead_code`: Find potentially unused functions. Args: None\n
+    - `calculate_cyclomatic_complexity`: Calculate function complexity. Args: `function_name` (str), `file_path` (str, optional)\n
+    - `find_most_complex_functions`: Find the most complex functions. Args: `limit` (int, optional)\n
+    - `list_indexed_repositories`: List indexed repositories. Args: None\n
+    - `delete_repository`: Delete an indexed repository. Args: `repo_path` (str)
+    """
+
+    # This is a placeholder for a more advanced tool caller that would
+    # connect to the running server via a different mechanism (e.g., a socket).
+    # For now, it's a conceptual part of the CLI.
+    console.print(f"Calling tool [bold cyan]{name}[/bold cyan] with args: {args}")
+    console.print("[yellow]Note: This is a placeholder for direct tool invocation.[/yellow]")
+
+
+@app.command(name="help")
+def show_help():
+    """
+    Show a list of available commands and their descriptions.
+    """
+    console.print("[bold]CodeGraphContext CLI Commands:[/bold]")
+    for command in app.registered_commands:
+        # Get the first line of the docstring as a short description
+        description = command.help.split('\n')[0].strip() if command.help else "No description."
+        console.print(f"  [bold cyan]{command.name}[/bold cyan]: {description}")
+    console.print("\nFor more information on a specific command, run: [bold]cgc <command> --help[/bold]")

{codegraphcontext-0.1.4 → codegraphcontext-0.1.6}/src/codegraphcontext/cli/setup_wizard.py

@@ -38,7 +38,9 @@ def _generate_mcp_json(creds):
                         "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"
+                        "find_dead_code", "execute_cypher_query",
+                        "calculate_cyclomatic_complexity", "find_most_complex_functions",
+                        "list_indexed_repositories", "delete_repository"
                     ],
                     "disabled": False
                 },
@@ -99,7 +101,7 @@ def run_setup_wizard():
     questions = [
         {
             "type": "list",
-            "message": "Where is your Neo4j database located?",
+            "message": "Where is your Neo4j database located? We can help you get one, if you don't have.",
             "choices": [
                 "Local (Recommended: I'll help you run it on this machine)",
                 "Hosted (Connect to a remote database like AuraDB)",

{codegraphcontext-0.1.4 → codegraphcontext-0.1.6}/src/codegraphcontext/core/jobs.py

@@ -5,6 +5,8 @@ from datetime import datetime, timedelta
 from dataclasses import dataclass, asdict
 from enum import Enum
 from typing import Any, Dict, List, Optional
+from pathlib import Path
+
 
 class JobStatus(Enum):
     """Job status enumeration"""
@@ -90,6 +92,23 @@ class JobManager:
         with self.lock:
             return list(self.jobs.values())
 
+    def find_active_job_by_path(self, path: str) -> Optional[JobInfo]:
+        """Finds the most recent, active job for a given path."""
+        with self.lock:
+            path_obj = Path(path).resolve()
+            
+            matching_jobs = sorted(
+                [job for job in self.jobs.values() if job.path and Path(job.path).resolve() == path_obj],
+                key=lambda j: j.start_time,
+                reverse=True
+            )
+
+            for job in matching_jobs:
+                if job.status in [JobStatus.PENDING, JobStatus.RUNNING]:
+                    return job
+                    
+            return None
+
     def cleanup_old_jobs(self, max_age_hours: int = 24):
         """Clean up jobs older than specified hours"""
         cutoff_time = datetime.now() - timedelta(hours=max_age_hours)

codegraphcontext-0.1.6/src/codegraphcontext/core/watcher.py

@@ -0,0 +1,141 @@
+# src/codegraphcontext/core/watcher.py
+import logging
+import threading
+from pathlib import Path
+import typing
+from watchdog.observers import Observer
+from watchdog.events import FileSystemEventHandler
+
+if typing.TYPE_CHECKING:
+    from codegraphcontext.tools.graph_builder import GraphBuilder
+    from codegraphcontext.core.jobs import JobManager
+
+logger = logging.getLogger(__name__)
+
+
+# --- NEW, MORE POWERFUL EVENT HANDLER ---
+class RepositoryEventHandler(FileSystemEventHandler):
+    """
+    An event handler that manages the state for a single repository.
+    It performs an initial scan and uses cached data for efficient updates.
+    """
+    def __init__(self, graph_builder: "GraphBuilder", repo_path: Path, debounce_interval=2.0):
+        super().__init__()
+        self.graph_builder = graph_builder
+        self.repo_path = repo_path
+        self.debounce_interval = debounce_interval
+        self.timers = {}
+        
+        # --- STATE CACHING ---
+        self.all_file_data = []
+        self.imports_map = {}
+        
+        # Perform the initial scan and linking when created
+        self._initial_scan()
+
+    def _initial_scan(self):
+        """Scans the entire repository and builds the initial graph."""
+        logger.info(f"Performing initial scan for watcher: {self.repo_path}")
+        all_files = list(self.repo_path.rglob("*.py"))
+        
+        # 1. Pre-scan for the global import map
+        self.imports_map = self.graph_builder._pre_scan_for_imports(all_files)
+        
+        # 2. Parse all files and cache their data
+        for f in all_files:
+            parsed_data = self.graph_builder.parse_python_file(self.repo_path, f, self.imports_map)
+            if "error" not in parsed_data:
+                self.all_file_data.append(parsed_data)
+        
+        # 3. Perform the initial linking of the entire graph
+        self.graph_builder._create_all_function_calls(self.all_file_data, self.imports_map)
+        logger.info(f"Initial scan and graph linking complete for: {self.repo_path}")
+
+    def _debounce(self, event_path, action):
+        """Schedules an action after a debounce interval to avoid rapid firing."""
+        if event_path in self.timers:
+            self.timers[event_path].cancel()
+        timer = threading.Timer(self.debounce_interval, action)
+        timer.start()
+        self.timers[event_path] = timer
+
+    def _handle_modification(self, event_path_str):
+        """Orchestrates the complete and correct update cycle for a modified file."""
+        logger.info(f"File change detected, starting full update for: {event_path_str}")
+        modified_path = Path(event_path_str)
+
+        # 1. Use the helper to update the file's nodes and get new data
+        #    NOTE: You will need to modify `update_file_in_graph` to accept `repo_path`
+        #    and `imports_map` as arguments and to return the new parsed data.
+        new_file_data = self.graph_builder.update_file_in_graph(
+            modified_path, self.repo_path, self.imports_map
+        )
+
+        if not new_file_data:
+            logger.error(f"Update failed for {event_path_str}, skipping re-link.")
+            return
+
+        # 2. Update the cache
+        self.all_file_data = [d for d in self.all_file_data if d.get("file_path") != event_path_str]
+        if not new_file_data.get("deleted"):
+            self.all_file_data.append(new_file_data)
+
+        # 3. CRITICAL: Re-link the entire graph using the updated cache
+        logger.info("Re-linking the call graph with updated information...")
+        self.graph_builder._create_all_function_calls(self.all_file_data, self.imports_map)
+        logger.info(f"Graph update for {event_path_str} complete! ✅")
+
+    def on_created(self, event):
+        if not event.is_directory and event.src_path.endswith('.py'):
+            self._debounce(event.src_path, lambda: self._handle_modification(event.src_path))
+
+    def on_modified(self, event):
+        if not event.is_directory and event.src_path.endswith('.py'):
+            self._debounce(event.src_path, lambda: self._handle_modification(event.src_path))
+
+    def on_deleted(self, event):
+        if not event.is_directory and event.src_path.endswith('.py'):
+            # Deletion is handled inside _handle_modification
+            self._debounce(event.src_path, lambda: self._handle_modification(event.src_path))
+
+    def on_moved(self, event):
+        if not event.is_directory and event.src_path.endswith('.py'):
+            # A move is a deletion from the old path and a creation at the new path
+            self._debounce(event.src_path, lambda: self._handle_modification(event.src_path))
+            self._debounce(event.dest_path, lambda: self._handle_modification(event.dest_path))
+
+
+class CodeWatcher:
+    """Manages file system watching in a background thread."""
+    def __init__(self, graph_builder: "GraphBuilder", job_manager= "JobManager"):
+        self.graph_builder = graph_builder
+        self.observer = Observer()
+        self.watched_paths = set()
+
+    def watch_directory(self, path: str):
+        path_obj = Path(path).resolve()
+        path_str = str(path_obj)
+
+        if path_str in self.watched_paths:
+            logger.info(f"Path already being watched: {path_str}")
+            return {"message": f"Path already being watched: {path_str}"}
+        
+        # --- Create a NEW, DEDICATED handler for this path ---
+        event_handler = RepositoryEventHandler(self.graph_builder, path_obj)
+        
+        self.observer.schedule(event_handler, path_str, recursive=True)
+        self.watched_paths.add(path_str)
+        logger.info(f"Started watching for code changes in: {path_str}")
+        
+        return {"message": f"Started watching {path_str}. Initial scan is in progress."}
+
+    def start(self):
+        if not self.observer.is_alive():
+            self.observer.start()
+            logger.info("Code watcher observer thread started.")
+
+    def stop(self):
+        if self.observer.is_alive():
+            self.observer.stop()
+            self.observer.join()
+            logger.info("Code watcher observer thread stopped.")

{codegraphcontext-0.1.4 → codegraphcontext-0.1.6}/src/codegraphcontext/prompts.py

@@ -5,6 +5,7 @@ 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.
+**Always prioritize using this MCP tools when they can simplify or enhance your workflow compared to guessing.**
 
 ## 2. Your Core Principles
 

{codegraphcontext-0.1.4 → codegraphcontext-0.1.6}/src/codegraphcontext/server.py

@@ -11,7 +11,6 @@ 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
 
@@ -60,7 +59,7 @@ class MCPServer:
         self.code_finder = CodeFinder(self.db_manager)
         self.import_extractor = ImportExtractor()
         
-        self.code_watcher = CodeWatcher(self.graph_builder)
+        self.code_watcher = CodeWatcher(self.graph_builder, self.job_manager)
         
         self._init_tools()
 
@@ -69,7 +68,7 @@ class MCPServer:
         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.",
+                "description": "Performs a one-time scan of a local folder to add its code to the graph. Ideal for indexing libraries, dependencies, or projects not being actively modified. Returns a job ID for background processing.",
                 "inputSchema": {
                     "type": "object",
                     "properties": {
@@ -117,7 +116,7 @@ class MCPServer:
             },
             "watch_directory": {
                 "name": "watch_directory",
-                "description": "Start watching a directory for code changes and automatically update the graph.",
+                "description": "Performs an initial scan of a directory and then continuously monitors it for changes, automatically keeping the graph up-to-date. Ideal for projects under active development. Returns a job ID for the initial scan.",
                 "inputSchema": {
                     "type": "object",
                     "properties": { "path": {"type": "string", "description": "Path to directory to watch"} },
@@ -166,11 +165,50 @@ class MCPServer:
                     "properties": {},
                     "additionalProperties": False
                 }
+            },
+            "calculate_cyclomatic_complexity": {
+                "name": "calculate_cyclomatic_complexity",
+                "description": "Calculate the cyclomatic complexity of a specific function to measure its complexity.",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "function_name": {"type": "string", "description": "The name of the function to analyze."},
+                        "file_path": {"type": "string", "description": "Optional: The full path to the file containing the function for a more specific query."}
+                    },
+                    "required": ["function_name"]
+                }
+            },
+            "find_most_complex_functions": {
+                "name": "find_most_complex_functions",
+                "description": "Find the most complex functions in the codebase based on cyclomatic complexity.",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "limit": {"type": "integer", "description": "The maximum number of complex functions to return.", "default": 10}
+                    }
+                }
+            },
+            "list_indexed_repositories": {
+                "name": "list_indexed_repositories",
+                "description": "List all indexed repositories.",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {}
+                }
+            },
+            "delete_repository": {
+                "name": "delete_repository",
+                "description": "Delete an indexed repository from the graph.",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "repo_path": {"type": "string", "description": "The path of the repository to delete."}
+                    },
+                    "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:
         """Get current database connection status"""
@@ -184,24 +222,30 @@ class MCPServer:
             module = importlib.import_module(package_name)
             
             if hasattr(module, '__file__') and module.__file__:
-                module_file = module.__file__
+                module_file = Path(module.__file__)
                 debug_log(f"Module file: {module_file}")
-                
-                if module_file.endswith('__init__.py'):
-                    package_path = os.path.dirname(module_file)
+
+                if module_file.name == '__init__.py':
+                    # It's a package (directory)
+                    package_path = str(module_file.parent)
+                elif package_name in stdlibs.module_names:
+                    # It's a single-file standard library module (e.g., os.py, io.py)
+                    package_path = str(module_file)
                 else:
-                    package_path = os.path.dirname(module_file)
-                
-                debug_log(f"Package path: {package_path}")
+                    # Default to parent directory for other single-file modules
+                    package_path = str(module_file.parent)
+
+                debug_log(f"Determined package path: {package_path}")
                 return package_path
-            
+
             elif hasattr(module, '__path__'):
+                # This handles namespace packages or packages without __init__.py
                 if isinstance(module.__path__, list) and module.__path__:
-                    package_path = module.__path__[0]
+                    package_path = str(Path(module.__path__[0]))
                     debug_log(f"Package path from __path__: {package_path}")
                     return package_path
                 else:
-                    package_path = str(module.__path__)
+                    package_path = str(Path(str(module.__path__)))
                     debug_log(f"Package path from __path__ (str): {package_path}")
                     return package_path
             
@@ -276,6 +320,70 @@ class MCPServer:
             debug_log(f"Error finding dead code: {str(e)}")
             return {"error": f"Failed to find dead code: {str(e)}"}
 
+    def calculate_cyclomatic_complexity_tool(self, **args) -> Dict[str, Any]:
+        """Tool to calculate cyclomatic complexity for a given function."""
+        function_name = args.get("function_name")
+        file_path = args.get("file_path")
+
+        try:
+            debug_log(f"Calculating cyclomatic complexity for function: {function_name}")
+            results = self.code_finder.get_cyclomatic_complexity(function_name, file_path)
+            
+            response = {
+                "success": True,
+                "function_name": function_name,
+                "results": results
+            }
+            if file_path:
+                response["file_path"] = file_path
+            
+            return response
+        except Exception as e:
+            debug_log(f"Error calculating cyclomatic complexity: {str(e)}")
+            return {"error": f"Failed to calculate cyclomatic complexity: {str(e)}"}
+
+    def find_most_complex_functions_tool(self, **args) -> Dict[str, Any]:
+        """Tool to find the most complex functions."""
+        limit = args.get("limit", 10)
+        try:
+            debug_log(f"Finding the top {limit} most complex functions.")
+            results = self.code_finder.find_most_complex_functions(limit)
+            return {
+                "success": True,
+                "limit": limit,
+                "results": results
+            }
+        except Exception as e:
+            debug_log(f"Error finding most complex functions: {str(e)}")
+            return {"error": f"Failed to find most complex functions: {str(e)}"}
+
+    def list_indexed_repositories_tool(self, **args) -> Dict[str, Any]:
+        """Tool to list indexed repositories."""
+        try:
+            debug_log("Listing indexed repositories.")
+            results = self.code_finder.list_indexed_repositories()
+            return {
+                "success": True,
+                "repositories": results
+            }
+        except Exception as e:
+            debug_log(f"Error listing indexed repositories: {str(e)}")
+            return {"error": f"Failed to list indexed repositories: {str(e)}"}
+
+    def delete_repository_tool(self, **args) -> Dict[str, Any]:
+        """Tool to delete a repository from the graph."""
+        repo_path = args.get("repo_path")
+        try:
+            debug_log(f"Deleting repository: {repo_path}")
+            self.graph_builder.delete_repository_from_graph(repo_path)
+            return {
+                "success": True,
+                "message": f"Repository '{repo_path}' deleted successfully."
+            }
+        except Exception as e:
+            debug_log(f"Error deleting repository: {str(e)}")
+            return {"error": f"Failed to delete repository: {str(e)}"}
+
     def watch_directory_tool(self, **args) -> Dict[str, Any]:
         """Tool to start watching a directory."""
         path = args.get("path")
@@ -283,17 +391,23 @@ class MCPServer:
             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
+            # First, ensure the code is added/scanned
+            scan_job_result = self.add_code_to_graph_tool(path=path, is_dependency=False)
+            if "error" in scan_job_result:
+                return scan_job_result
 
-            self.code_watcher.watch_directory(path)
+            # Now, start the watcher
+            watch_result = self.code_watcher.watch_directory(path)
             
-            return {
+            # Combine results
+            final_result = {
                 "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."
+                "message": f"Initial scan started for {path}. Now watching for live changes.",
+                "job_id": scan_job_result.get("job_id"),
+                "details": watch_result
             }
+            return final_result
+            
         except Exception as e:
             logger.error(f"Failed to start watching directory {path}: {e}")
             return {"error": f"Failed to start watching directory: {str(e)}"}
@@ -362,6 +476,15 @@ class MCPServer:
 
             if not path_obj.exists():
                 return {"error": f"Path {path} does not exist"}
+
+            # Check if the repository is already indexed
+            indexed_repos = self.list_indexed_repositories_tool().get("repositories", [])
+            for repo in indexed_repos:
+                if Path(repo["path"]).resolve() == path_obj:
+                    return {
+                        "success": False,
+                        "message": f"Repository '{path}' is already indexed."
+                    }
             
             total_files, estimated_time = self.graph_builder.estimate_processing_time(path_obj)
             
@@ -395,6 +518,15 @@ class MCPServer:
         is_dependency = args.get("is_dependency", True)
         
         try:
+            # Check if the package is already indexed
+            indexed_repos = self.list_indexed_repositories_tool().get("repositories", [])
+            for repo in indexed_repos:
+                if repo.get("is_dependency") and (repo.get("name") == package_name or repo.get("name") == f"{package_name}.py"):
+                    return {
+                        "success": False,
+                        "message": f"Package '{package_name}' is already indexed."
+                    }
+
             package_path = self.get_local_package_path(package_name)
             
             if not package_path:
@@ -555,7 +687,11 @@ class MCPServer:
             "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
+            "list_jobs": self.list_jobs_tool,
+            "calculate_cyclomatic_complexity": self.calculate_cyclomatic_complexity_tool,
+            "find_most_complex_functions": self.find_most_complex_functions_tool,
+            "list_indexed_repositories": self.list_indexed_repositories_tool,
+            "delete_repository": self.delete_repository_tool
         }
         handler = tool_map.get(tool_name)
         if handler:
@@ -627,4 +763,4 @@ class MCPServer:
     def shutdown(self):
         logger.info("Shutting down server...")
         self.code_watcher.stop()
-        self.db_manager.close_driver()
+        self.db_manager.close_driver()