codegraphcontext 0.1.5__tar.gz → 0.1.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.1.5
+Version: 0.1.7
 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
@@ -47,9 +47,12 @@ 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"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
 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.
 

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

@@ -1,4 +1,6 @@
 # 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.
 
@@ -96,4 +98,4 @@ Once the server is running, you can interact with it through your AI assistant u
     -   "Find all implementations of the `render` method."
 
 -   **Code Quality and Maintenance:**
-    -   "Is there any dead or unused code in this project?"
+    -   "Is there any dead or unused code in this project?"

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

@@ -1,6 +1,6 @@
 [project]
 name = "codegraphcontext"
-version = "0.1.5"
+version = "0.1.7"
 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"
@@ -36,6 +36,7 @@ cgc = "codegraphcontext.cli.main:app"
 dev = [
     "pytest>=7.4.0",
     "black>=23.11.0",
+    "pytest-asyncio>=0.21.0",
 ]
 
 [tool.setuptools]

codegraphcontext-0.1.7/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.5 → codegraphcontext-0.1.7}/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)",
@@ -227,20 +229,141 @@ def setup_local_db():
         setup_local_binary()
 
 def setup_docker():
-    """Creates Docker files and runs docker-compose."""
-    console.print("This will create a `docker-compose.yml` and `.env` file in your current directory.")
-    # Here you would write the file contents
-    console.print("[green]docker-compose.yml and .env created.[/green]")
-    console.print("Please set your NEO4J_PASSWORD in the .env file.")
-    confirm_q = [{"type": "confirm", "message": "Ready to launch Docker containers?", "name": "proceed"}]
-    if prompt(confirm_q).get("proceed"):
-        try:
-            # Using our run_command to handle the subprocess call
-            docker_process = run_command(["docker", "compose", "up", "-d"], console, check=True)
-            if docker_process:
-                console.print("[bold green]Docker containers started successfully![/bold green]")
-        except Exception as e:
-            console.print(f"[bold red]Failed to start Docker containers:[/bold red] {e}")
+    """Creates Docker files and runs docker-compose for Neo4j."""
+    console.print("\n[bold cyan]Setting up Neo4j with Docker...[/bold cyan]")
+
+    # Prompt for password first
+    console.print("Please set a secure password for your Neo4j database:")
+    password_questions = [
+        {"type": "password", "message": "Enter Neo4j password:", "name": "password"},
+        {"type": "password", "message": "Confirm password:", "name": "password_confirm"},
+    ]
+    
+    while True:
+        passwords = prompt(password_questions)
+        if not passwords:
+            return  # User cancelled
+        
+        password = passwords.get("password", "")
+        if password and password == passwords.get("password_confirm"):
+            break
+        console.print("[red]Passwords do not match or are empty. Please try again.[/red]")
+
+    # Create data directories
+    neo4j_dir = Path.cwd() / "neo4j_data"
+    for subdir in ["data", "logs", "conf", "plugins"]:
+        (neo4j_dir / subdir).mkdir(parents=True, exist_ok=True)
+
+    # Fixed docker-compose.yml content
+    docker_compose_content = f"""
+services:
+  neo4j:
+    image: neo4j:5.21
+    container_name: neo4j-cgc
+    restart: unless-stopped
+    ports:
+      - "7474:7474"
+      - "7687:7687"
+    environment:
+      - NEO4J_AUTH=neo4j/12345678
+      - NEO4J_ACCEPT_LICENSE_AGREEMENT=yes
+    volumes:
+      - neo4j_data:/data
+      - neo4j_logs:/logs
+
+volumes:
+  neo4j_data:
+  neo4j_logs:
+"""
+
+    # Write docker-compose.yml
+    compose_file = Path.cwd() / "docker-compose.yml"
+    with open(compose_file, "w") as f:
+        f.write(docker_compose_content)
+
+    console.print("[green]✅ docker-compose.yml created with secure password.[/green]")
+
+    # Check if Docker is running
+    docker_check = run_command(["docker", "--version"], console, check=False)
+    if not docker_check:
+        console.print("[red]❌ Docker is not installed or not running. Please install Docker first.[/red]")
+        return
+
+    # Check if docker-compose is available
+    compose_check = run_command(["docker", "compose", "version"], console, check=False)
+    if not compose_check:
+        console.print("[red]❌ Docker Compose is not available. Please install Docker Compose.[/red]")
+        return
+
+    confirm_q = [{"type": "confirm", "message": "Ready to launch Neo4j in Docker?", "name": "proceed", "default": True}]
+    if not prompt(confirm_q).get("proceed"):
+        return
+
+    try:
+        # Pull the image first
+        console.print("[cyan]Pulling Neo4j Docker image...[/cyan]")
+        pull_process = run_command(["docker", "pull", "neo4j:5.21"], console, check=True)
+        if not pull_process:
+            console.print("[yellow]⚠️ Could not pull image, but continuing anyway...[/yellow]")
+
+        # Start containers
+        console.print("[cyan]Starting Neo4j container...[/cyan]")
+        docker_process = run_command(["docker", "compose", "up", "-d"], console, check=True)
+        
+        if docker_process:
+            console.print("[bold green]🚀 Neo4j Docker container started successfully![/bold green]")
+            
+            # Wait for Neo4j to be ready
+            console.print("[cyan]Waiting for Neo4j to be ready (this may take 30-60 seconds)...[/cyan]")
+            
+            # Try to connect for up to 2 minutes
+            max_attempts = 24  # 24 * 5 seconds = 2 minutes
+            for attempt in range(max_attempts):
+                time.sleep(5)
+                
+                # Check if container is still running
+                status_check = run_command(["docker", "compose", "ps", "-q", "neo4j"], console, check=False)
+                if not status_check or not status_check.stdout.strip():
+                    console.print("[red]❌ Neo4j container stopped unexpectedly. Check logs with: docker compose logs neo4j[/red]")
+                    return
+                
+                # Try to connect
+                health_check = run_command([
+                    "docker", "exec", "neo4j-cgc", "cypher-shell", 
+                    "-u", "neo4j", "-p", password, 
+                    "RETURN 'Connection successful' as status"
+                ], console, check=False)
+                
+                if health_check and health_check.returncode == 0:
+                    console.print("[bold green]✅ Neo4j is ready and accepting connections![/bold green]")
+                    break
+                    
+                if attempt < max_attempts - 1:
+                    console.print(f"[yellow]Still waiting... (attempt {attempt + 1}/{max_attempts})[/yellow]")
+            else:
+                console.print("[red]❌ Neo4j did not become ready within 2 minutes. Check logs with: docker compose logs neo4j[/red]")
+                return
+
+            # Generate MCP configuration
+            creds = {
+                "uri": "neo4j://localhost:7687",  # Use neo4j:// protocol for Neo4j 5.x
+                "username": "neo4j",
+                "password": password
+            }
+            _generate_mcp_json(creds)
+            
+            console.print("\n[bold green]🎉 Setup complete![/bold green]")
+            console.print("Neo4j is running at:")
+            console.print("  • Web interface: http://localhost:7474")
+            console.print("  • Bolt connection: neo4j://localhost:7687")
+            console.print("\n[cyan]Useful commands:[/cyan]")
+            console.print("  • Stop: docker compose down")
+            console.print("  • Restart: docker compose restart")
+            console.print("  • View logs: docker compose logs neo4j")
+            
+    except Exception as e:
+        console.print(f"[bold red]❌ Failed to start Neo4j Docker container:[/bold red] {e}")
+        console.print("[cyan]Try checking the logs with: docker compose logs neo4j[/cyan]")
 
 def setup_local_binary():
     """Automates the installation and configuration of Neo4j on Ubuntu/Debian."""

codegraphcontext-0.1.7/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.5 → codegraphcontext-0.1.7}/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.5 → codegraphcontext-0.1.7}/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
 
@@ -126,7 +125,7 @@ class MCPServer:
             },
             "execute_cypher_query": {
                 "name": "execute_cypher_query",
-                "description": "Fallback tool to run a direct, read-only Cypher query against the code graph.",
+                "description": "Fallback tool to run a direct, read-only Cypher query against the code graph. Use this for complex questions not covered by other tools. The graph contains nodes representing code structures and relationships between them. **Schema Overview:**\n- **Nodes:** `Repository`, `File`, `Module`, `Class`, `Function`.\n- **Properties:** Nodes have properties like `name`, `path`, `cyclomatic_complexity` (on Function nodes), and `code`.\n- **Relationships:** `CONTAINS` (e.g., File-[:CONTAINS]->Function), `CALLS` (Function-[:CALLS]->Function or File-[:CALLS]->Function), `IMPORTS` (File-[:IMPORTS]->Module), `INHERITS` (Class-[:INHERITS]->Class).",
                 "inputSchema": {
                     "type": "object",
                     "properties": { "cypher_query": {"type": "string", "description": "The read-only Cypher query to execute."} },
@@ -209,9 +208,7 @@ class MCPServer:
                 }
             }
             # 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"""
@@ -225,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
             
@@ -473,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)
             
@@ -506,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:
@@ -742,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()