mcp-code-indexer 3.4.2__py3-none-any.whl → 3.5.0__py3-none-any.whl

mcp_code_indexer/__init__.py

@@ -6,7 +6,11 @@ intelligent codebase navigation through searchable file descriptions,
 token-aware overviews, and advanced merge capabilities.
 """
 
-from .server.mcp_server import MCPCodeIndexServer
+# Delay import to avoid dependency issues during testing
+def get_server():
+    """Get MCPCodeIndexServer (lazy import)."""
+    from .server.mcp_server import MCPCodeIndexServer
+    return MCPCodeIndexServer
 
 
 def _get_version() -> str:
@@ -54,4 +58,4 @@ __author__ = "MCP Code Indexer Contributors"
 __email__ = ""
 __license__ = "MIT"
 
-__all__ = ["MCPCodeIndexServer", "__version__"]
+__all__ = ["get_server", "__version__"]

mcp_code_indexer/commands/__init__.py

@@ -0,0 +1 @@
+"""Commands package for MCP Code Indexer."""

mcp_code_indexer/commands/makelocal.py

@@ -0,0 +1,202 @@
+"""
+Command to migrate project data from global to local database.
+
+This module provides functionality to extract project data from the global database
+and create a local database in a project folder.
+"""
+
+import logging
+from pathlib import Path
+from typing import List, Optional
+
+from mcp_code_indexer.database.database import DatabaseManager
+from mcp_code_indexer.database.database_factory import DatabaseFactory
+from mcp_code_indexer.database.models import Project, FileDescription, ProjectOverview
+
+logger = logging.getLogger(__name__)
+
+
+class MakeLocalCommand:
+    """
+    Command to migrate project data from global to local database.
+    
+    Extracts all project data, file descriptions, and project overviews
+    from the global database and creates a local database in the specified folder.
+    """
+    
+    def __init__(self, db_factory: DatabaseFactory):
+        """
+        Initialize the make local command.
+        
+        Args:
+            db_factory: Database factory for creating database managers
+        """
+        self.db_factory = db_factory
+    
+    async def execute(self, folder_path: str, project_name: Optional[str] = None) -> dict:
+        """
+        Execute the make local command.
+        
+        Args:
+            folder_path: Path to the project folder where local DB will be created
+            project_name: Optional project name to migrate (if None, tries to find by folder)
+            
+        Returns:
+            Dictionary with operation results
+        """
+        folder_path_obj = Path(folder_path).resolve()
+        
+        if not folder_path_obj.exists():
+            raise ValueError(f"Folder path does not exist: {folder_path}")
+        
+        if not folder_path_obj.is_dir():
+            raise ValueError(f"Path is not a directory: {folder_path}")
+        
+        # Check if local database already exists
+        local_db_path = folder_path_obj / ".code-index.db"
+        if local_db_path.exists() and local_db_path.stat().st_size > 0:
+            raise ValueError(f"Local database already exists: {local_db_path}")
+        
+        # Get global database manager
+        global_db_manager = await self.db_factory.get_database_manager()
+        
+        # Find the project to migrate
+        project = await self._find_project_to_migrate(global_db_manager, folder_path, project_name)
+        if not project:
+            if project_name:
+                raise ValueError(f"Project '{project_name}' not found in global database")
+            else:
+                raise ValueError(f"No project found for folder path: {folder_path}")
+        
+        logger.info(f"Found project to migrate: {project.name} (ID: {project.id})")
+        
+        # Get all project data
+        file_descriptions = await global_db_manager.get_all_file_descriptions(project.id)
+        project_overview = await global_db_manager.get_project_overview(project.id)
+        
+        logger.info(f"Found {len(file_descriptions)} file descriptions to migrate")
+        if project_overview:
+            logger.info("Found project overview to migrate")
+        
+        # Create local database (remove empty file if it exists)
+        if local_db_path.exists():
+            local_db_path.unlink()
+            
+        # Create local database manager
+        local_db_manager = await self.db_factory.get_database_manager(str(folder_path_obj))
+        
+        # Migrate data
+        await self._migrate_project_data(
+            local_db_manager, project, file_descriptions, project_overview
+        )
+        
+        # Remove data from global database
+        await self._remove_from_global_database(global_db_manager, project.id)
+        
+        return {
+            "success": True,
+            "project_name": project.name,
+            "project_id": project.id,
+            "local_database_path": str(local_db_path),
+            "migrated_files": len(file_descriptions),
+            "migrated_overview": project_overview is not None,
+        }
+    
+    async def _find_project_to_migrate(
+        self, 
+        global_db_manager: DatabaseManager, 
+        folder_path: str, 
+        project_name: Optional[str]
+    ) -> Optional[Project]:
+        """
+        Find the project to migrate from the global database.
+        
+        Args:
+            global_db_manager: Global database manager
+            folder_path: Project folder path
+            project_name: Optional project name
+            
+        Returns:
+            Project to migrate or None if not found
+        """
+        all_projects = await global_db_manager.get_all_projects()
+        
+        if project_name:
+            # Search by name
+            normalized_name = project_name.lower()
+            for project in all_projects:
+                if project.name.lower() == normalized_name:
+                    return project
+        else:
+            # Search by folder path in aliases
+            for project in all_projects:
+                if folder_path in project.aliases:
+                    return project
+        
+        return None
+    
+    async def _migrate_project_data(
+        self,
+        local_db_manager: DatabaseManager,
+        project: Project,
+        file_descriptions: List[FileDescription],
+        project_overview: Optional[ProjectOverview]
+    ) -> None:
+        """
+        Migrate project data to the local database.
+        
+        Args:
+            local_db_manager: Local database manager
+            project: Project to migrate
+            file_descriptions: File descriptions to migrate
+            project_overview: Project overview to migrate (if any)
+        """
+        # Create project in local database
+        await local_db_manager.create_project(project)
+        logger.info(f"Created project in local database: {project.name}")
+        
+        # Migrate file descriptions
+        if file_descriptions:
+            await local_db_manager.batch_create_file_descriptions(file_descriptions)
+            logger.info(f"Migrated {len(file_descriptions)} file descriptions")
+        
+        # Migrate project overview
+        if project_overview:
+            await local_db_manager.create_project_overview(project_overview)
+            logger.info("Migrated project overview")
+    
+    async def _remove_from_global_database(
+        self, global_db_manager: DatabaseManager, project_id: str
+    ) -> None:
+        """
+        Remove project data from the global database.
+        
+        Args:
+            global_db_manager: Global database manager
+            project_id: Project ID to remove
+        """
+        # Remove file descriptions
+        async with global_db_manager.get_write_connection_with_retry("remove_project_files") as db:
+            await db.execute(
+                "DELETE FROM file_descriptions WHERE project_id = ?",
+                (project_id,)
+            )
+            await db.commit()
+        
+        # Remove project overview
+        async with global_db_manager.get_write_connection_with_retry("remove_project_overview") as db:
+            await db.execute(
+                "DELETE FROM project_overviews WHERE project_id = ?",
+                (project_id,)
+            )
+            await db.commit()
+        
+        # Remove project
+        async with global_db_manager.get_write_connection_with_retry("remove_project") as db:
+            await db.execute(
+                "DELETE FROM projects WHERE id = ?",
+                (project_id,)
+            )
+            await db.commit()
+        
+        logger.info(f"Removed project data from global database: {project_id}")

mcp_code_indexer/database/connection_health.py

@@ -336,13 +336,8 @@ class ConnectionHealthMonitor:
             if retry_executor:
                 health_status["retry_statistics"] = retry_executor.get_retry_stats()
 
-        # Include database-level statistics if available
-        if hasattr(self.database_manager, "get_database_stats"):
-            try:
-                db_stats = self.database_manager.get_database_stats()
-                health_status["database_statistics"] = db_stats
-            except Exception as e:
-                logger.warning(f"Failed to get database statistics: {e}")
+        # Avoid circular dependency - don't include database stats here
+        # (they are included separately in the comprehensive diagnostics)
 
         return health_status
 

mcp_code_indexer/database/database_factory.py

@@ -0,0 +1,134 @@
+"""
+Database factory for managing multiple database instances.
+
+This module provides a factory that creates and manages DatabaseManager instances
+for both global and local databases, handling initialization and connection pooling.
+"""
+
+import logging
+from pathlib import Path
+from typing import Dict, Optional
+
+from .database import DatabaseManager
+from .path_resolver import DatabasePathResolver
+
+logger = logging.getLogger(__name__)
+
+
+class DatabaseFactory:
+    """
+    Factory for creating and managing DatabaseManager instances.
+    
+    Maintains a cache of database managers for different database paths
+    to avoid creating multiple instances for the same database.
+    """
+    
+    def __init__(
+        self,
+        global_db_path: Path,
+        pool_size: int = 3,
+        retry_count: int = 5,
+        timeout: float = 10.0,
+        enable_wal_mode: bool = True,
+        health_check_interval: float = 30.0,
+        retry_min_wait: float = 0.1,
+        retry_max_wait: float = 2.0,
+        retry_jitter: float = 0.2,
+    ):
+        """
+        Initialize the database factory.
+        
+        Args:
+            global_db_path: Path to the global database
+            pool_size: Database connection pool size
+            retry_count: Maximum retry attempts for database operations
+            timeout: Database operation timeout in seconds
+            enable_wal_mode: Whether to enable WAL mode for SQLite
+            health_check_interval: Health check interval in seconds
+            retry_min_wait: Minimum wait time between retries
+            retry_max_wait: Maximum wait time between retries
+            retry_jitter: Maximum jitter for retry delays
+        """
+        self.global_db_path = global_db_path
+        self.db_config = {
+            "pool_size": pool_size,
+            "retry_count": retry_count,
+            "timeout": timeout,
+            "enable_wal_mode": enable_wal_mode,
+            "health_check_interval": health_check_interval,
+            "retry_min_wait": retry_min_wait,
+            "retry_max_wait": retry_max_wait,
+            "retry_jitter": retry_jitter,
+        }
+        
+        self.path_resolver = DatabasePathResolver(global_db_path)
+        self._database_managers: Dict[str, DatabaseManager] = {}
+        self._initialized_dbs: set = set()
+    
+    async def get_database_manager(self, folder_path: Optional[str] = None) -> DatabaseManager:
+        """
+        Get a database manager for the appropriate database (local or global).
+        
+        Args:
+            folder_path: Project folder path to check for local database
+            
+        Returns:
+            DatabaseManager instance for the appropriate database
+        """
+        db_path = self.path_resolver.resolve_database_path(folder_path)
+        db_key = str(db_path)
+        
+        # Return existing manager if available
+        if db_key in self._database_managers:
+            return self._database_managers[db_key]
+        
+        # Check if we need to initialize an empty local database
+        if (folder_path and 
+            self.path_resolver.is_local_database(folder_path) and
+            self.path_resolver.should_initialize_local_database(folder_path)):
+            logger.info(f"Initializing empty local database: {db_path}")
+            # Remove the empty file so DatabaseManager can create it properly
+            if db_path.exists():
+                db_path.unlink()
+        
+        # Create new database manager
+        db_manager = DatabaseManager(
+            db_path=db_path,
+            **self.db_config
+        )
+        
+        # Initialize if not already done
+        if db_key not in self._initialized_dbs:
+            await db_manager.initialize()
+            self._initialized_dbs.add(db_key)
+            logger.info(f"Initialized database: {db_path}")
+        
+        self._database_managers[db_key] = db_manager
+        return db_manager
+    
+    async def close_all(self) -> None:
+        """Close all database managers and their connection pools."""
+        for db_manager in self._database_managers.values():
+            await db_manager.close_pool()
+        self._database_managers.clear()
+        self._initialized_dbs.clear()
+        logger.info("Closed all database connections")
+    
+    def get_path_resolver(self) -> DatabasePathResolver:
+        """Get the database path resolver."""
+        return self.path_resolver
+    
+    def list_active_databases(self) -> Dict[str, str]:
+        """
+        List all active database connections.
+        
+        Returns:
+            Dictionary mapping database paths to their types (global/local)
+        """
+        result = {}
+        for db_path in self._database_managers.keys():
+            if db_path == str(self.global_db_path):
+                result[db_path] = "global"
+            else:
+                result[db_path] = "local"
+        return result

mcp_code_indexer/database/path_resolver.py

@@ -0,0 +1,122 @@
+"""
+Database path resolution for local vs global databases.
+
+This module provides logic to determine whether to use a local project database
+or the global database based on the presence of .code-index.db files.
+"""
+
+import logging
+import os
+from pathlib import Path
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+class DatabasePathResolver:
+    """
+    Resolves database paths, determining whether to use local or global databases.
+    
+    Local databases are stored as .code-index.db in project folders.
+    If a local database file exists, it takes precedence over the global database.
+    """
+    
+    def __init__(self, global_db_path: Path):
+        """
+        Initialize the path resolver with the global database path.
+        
+        Args:
+            global_db_path: Path to the global database file
+        """
+        self.global_db_path = global_db_path
+        
+    def resolve_database_path(self, folder_path: Optional[str] = None) -> Path:
+        """
+        Resolve which database to use based on folder path.
+        
+        Args:
+            folder_path: Project folder path to check for local database
+            
+        Returns:
+            Path to the database file to use
+        """
+        if not folder_path:
+            logger.debug("No folder path provided, using global database")
+            return self.global_db_path
+            
+        try:
+            folder_path_obj = Path(folder_path).resolve()
+            local_db_path = folder_path_obj / ".code-index.db"
+            
+            if local_db_path.exists():
+                logger.debug(f"Found local database: {local_db_path}")
+                return local_db_path
+            else:
+                logger.debug(f"No local database found at {local_db_path}, using global database")
+                return self.global_db_path
+                
+        except (OSError, ValueError) as e:
+            logger.warning(f"Error resolving folder path '{folder_path}': {e}")
+            return self.global_db_path
+    
+    def is_local_database(self, folder_path: Optional[str] = None) -> bool:
+        """
+        Check if a local database exists for the given folder path.
+        
+        Args:
+            folder_path: Project folder path to check
+            
+        Returns:
+            True if a local database exists, False otherwise
+        """
+        if not folder_path:
+            return False
+            
+        try:
+            folder_path_obj = Path(folder_path).resolve()
+            local_db_path = folder_path_obj / ".code-index.db"
+            return local_db_path.exists()
+        except (OSError, ValueError):
+            return False
+    
+    def get_local_database_path(self, folder_path: str) -> Path:
+        """
+        Get the local database path for a folder (whether it exists or not).
+        
+        Args:
+            folder_path: Project folder path
+            
+        Returns:
+            Path where the local database would be located
+        """
+        return Path(folder_path).resolve() / ".code-index.db"
+    
+    def is_empty_database_file(self, db_path: Path) -> bool:
+        """
+        Check if a database file is empty (0 bytes).
+        
+        Args:
+            db_path: Path to the database file
+            
+        Returns:
+            True if the file exists and is empty, False otherwise
+        """
+        try:
+            return db_path.exists() and db_path.stat().st_size == 0
+        except (OSError, ValueError):
+            return False
+    
+    def should_initialize_local_database(self, folder_path: str) -> bool:
+        """
+        Check if a local database should be initialized.
+        
+        This returns True if .code-index.db exists and is empty.
+        
+        Args:
+            folder_path: Project folder path
+            
+        Returns:
+            True if local database should be initialized, False otherwise
+        """
+        local_db_path = self.get_local_database_path(folder_path)
+        return self.is_empty_database_file(local_db_path)

mcp_code_indexer/main.py

@@ -321,6 +321,7 @@ async def handle_runcommand(args: argparse.Namespace) -> None:
             "update_codebase_overview": server._handle_update_codebase_overview,
             "get_word_frequency": server._handle_get_word_frequency,
             "search_codebase_overview": server._handle_search_codebase_overview,
+            "check_database_health": server._handle_check_database_health,
         }
 
         if tool_name not in tool_handlers:
@@ -333,6 +334,7 @@ async def handle_runcommand(args: argparse.Namespace) -> None:
                     }
                 },
             )
+
             error_result = {
                 "error": {"code": -32601, "message": f"Unknown tool: {tool_name}"}
             }

mcp_code_indexer/server/mcp_server.py

@@ -23,6 +23,7 @@ from mcp.server.stdio import stdio_server
 from pydantic import ValidationError
 
 from mcp_code_indexer.database.database import DatabaseManager
+from mcp_code_indexer.database.database_factory import DatabaseFactory
 from mcp_code_indexer.file_scanner import FileScanner
 from mcp_code_indexer.token_counter import TokenCounter
 from mcp_code_indexer.database.models import (
@@ -97,8 +98,8 @@ class MCPCodeIndexServer:
         }
 
         # Initialize components
-        self.db_manager = DatabaseManager(
-            db_path=self.db_path,
+        self.db_factory = DatabaseFactory(
+            global_db_path=self.db_path,
             pool_size=db_pool_size,
             retry_count=db_retry_count,
             timeout=db_timeout,
@@ -108,8 +109,10 @@ class MCPCodeIndexServer:
             retry_max_wait=retry_max_wait,
             retry_jitter=retry_jitter,
         )
+        # Keep reference to global db_manager for backwards compatibility
+        self.db_manager = None  # Will be set during run()
         self.token_counter = TokenCounter(token_limit)
-        self.cleanup_manager = CleanupManager(self.db_manager, retention_months=6)
+        self.cleanup_manager = None  # Will be set during initialize()
 
         # Setup error handling
         self.logger = get_logger(__name__)
@@ -241,7 +244,10 @@ class MCPCodeIndexServer:
 
     async def initialize(self) -> None:
         """Initialize database and other resources."""
-        await self.db_manager.initialize()
+        # Initialize global database manager for backwards compatibility
+        self.db_manager = await self.db_factory.get_database_manager()
+        # Update cleanup manager with initialized db_manager
+        self.cleanup_manager = CleanupManager(self.db_manager, retention_months=6)
         self._start_background_cleanup()
         logger.info("Server initialized successfully")
 
@@ -745,14 +751,17 @@ class MCPCodeIndexServer:
         project_name = arguments["projectName"]
         folder_path = arguments["folderPath"]
 
+        # Get the appropriate database manager for this folder
+        db_manager = await self.db_factory.get_database_manager(folder_path)
+
         # Normalize project name for case-insensitive matching
         normalized_name = project_name.lower()
 
         # Find potential project matches
-        project = await self._find_matching_project(normalized_name, folder_path)
+        project = await self._find_matching_project(normalized_name, folder_path, db_manager)
         if project:
             # Update project metadata and aliases
-            await self._update_existing_project(project, normalized_name, folder_path)
+            await self._update_existing_project(project, normalized_name, folder_path, db_manager)
         else:
             # Create new project with UUID
             project_id = str(uuid.uuid4())
@@ -763,20 +772,20 @@ class MCPCodeIndexServer:
                 created=datetime.utcnow(),
                 last_accessed=datetime.utcnow(),
             )
-            await self.db_manager.create_project(project)
+            await db_manager.create_project(project)
             logger.info(f"Created new project: {normalized_name} ({project_id})")
 
         return project.id
 
     async def _find_matching_project(
-        self, normalized_name: str, folder_path: str
+        self, normalized_name: str, folder_path: str, db_manager: DatabaseManager
     ) -> Optional[Project]:
         """
         Find a matching project using name and folder path matching.
 
         Returns the best matching project or None if no sufficient match is found.
         """
-        all_projects = await self.db_manager.get_all_projects()
+        all_projects = await db_manager.get_all_projects()
 
         best_match = None
         best_score = 0
@@ -863,11 +872,11 @@ class MCPCodeIndexServer:
             return False
 
     async def _update_existing_project(
-        self, project: Project, normalized_name: str, folder_path: str
+        self, project: Project, normalized_name: str, folder_path: str, db_manager: DatabaseManager
     ) -> None:
         """Update an existing project with new metadata and folder alias."""
         # Update last accessed time
-        await self.db_manager.update_project_access_time(project.id)
+        await db_manager.update_project_access_time(project.id)
 
         should_update = False
 
@@ -891,16 +900,18 @@ class MCPCodeIndexServer:
             )
 
         if should_update:
-            await self.db_manager.update_project(project)
+            await db_manager.update_project(project)
             logger.debug(f"Updated project metadata for {project.name}")
 
     async def _handle_get_file_description(
         self, arguments: Dict[str, Any]
     ) -> Dict[str, Any]:
         """Handle get_file_description tool calls."""
+        folder_path = arguments["folderPath"]
+        db_manager = await self.db_factory.get_database_manager(folder_path)
         project_id = await self._get_or_create_project_id(arguments)
 
-        file_desc = await self.db_manager.get_file_description(
+        file_desc = await db_manager.get_file_description(
             project_id=project_id, file_path=arguments["filePath"]
         )
 
@@ -928,6 +939,8 @@ class MCPCodeIndexServer:
         description_length = len(arguments.get("description", ""))
         logger.info(f"Description length: {description_length} characters")
 
+        folder_path = arguments["folderPath"]
+        db_manager = await self.db_factory.get_database_manager(folder_path)
         project_id = await self._get_or_create_project_id(arguments)
 
         logger.info(f"Resolved project_id: {project_id}")
@@ -941,7 +954,7 @@ class MCPCodeIndexServer:
             version=1,
         )
 
-        await self.db_manager.create_file_description(file_desc)
+        await db_manager.create_file_description(file_desc)
 
         logger.info(f"Successfully updated description for: {arguments['filePath']}")
 
@@ -1337,16 +1350,15 @@ class MCPCodeIndexServer:
         database_stats = self.db_manager.get_database_stats()
 
         return {
-            "comprehensive_diagnostics": comprehensive_diagnostics,
-            "database_statistics": database_stats,
-            "configuration": {
-                **self.db_config,
-                "retry_executor_config": (
-                    self.db_manager._retry_executor.config.__dict__
-                    if hasattr(self.db_manager, "_retry_executor")
-                    and self.db_manager._retry_executor
-                    else {}
-                ),
+            "is_healthy": comprehensive_diagnostics.get("current_status", {}).get("is_healthy", True),
+            "status": comprehensive_diagnostics.get("current_status", {}),
+            "performance": {
+                "avg_response_time_ms": comprehensive_diagnostics.get("metrics", {}).get("avg_response_time_ms", 0),
+                "success_rate": comprehensive_diagnostics.get("current_status", {}).get("recent_success_rate_percent", 100)
+            },
+            "database": {
+                "total_operations": database_stats.get("retry_executor", {}).get("total_operations", 0),
+                "pool_size": database_stats.get("connection_pool", {}).get("current_size", 0)
             },
             "server_info": {
                 "token_limit": self.token_limit,

{mcp_code_indexer-3.4.2.dist-info → mcp_code_indexer-3.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: mcp-code-indexer
-Version: 3.4.2
+Version: 3.5.0
 Summary: MCP server that tracks file descriptions across codebases, enabling AI agents to efficiently navigate and understand code through searchable summaries and token-aware overviews.
 License: MIT
 Keywords: mcp,model-context-protocol,code-indexer,ai-tools,codebase-navigation,file-descriptions,llm-tools
@@ -40,8 +40,8 @@ Description-Content-Type: text/markdown
 
 # MCP Code Indexer 🚀
 
-[![PyPI version](https://badge.fury.io/py/mcp-code-indexer.svg?33)](https://badge.fury.io/py/mcp-code-indexer)
-[![Python](https://img.shields.io/pypi/pyversions/mcp-code-indexer.svg?33)](https://pypi.org/project/mcp-code-indexer/)
+[![PyPI version](https://badge.fury.io/py/mcp-code-indexer.svg?35)](https://badge.fury.io/py/mcp-code-indexer)
+[![Python](https://img.shields.io/pypi/pyversions/mcp-code-indexer.svg?35)](https://pypi.org/project/mcp-code-indexer/)
 [![License](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 
 A production-ready **Model Context Protocol (MCP) server** that revolutionizes how AI agents navigate and understand codebases. Built for high-concurrency environments with advanced database resilience, the server provides instant access to intelligent descriptions, semantic search, and context-aware recommendations while maintaining 800+ writes/sec throughput.

{mcp_code_indexer-3.4.2.dist-info → mcp_code_indexer-3.5.0.dist-info}/RECORD

@@ -1,21 +1,25 @@
-mcp_code_indexer/__init__.py,sha256=likkTMBFIcnaRqrvESq4WDqEIx1edUL74zilaQeF-Zc,1660
+mcp_code_indexer/__init__.py,sha256=L_IpDV7vnk_plYvcVoBOmysRfW7P9BvGNrr8dIRIiQ0,1809
 mcp_code_indexer/__main__.py,sha256=4Edinoe0ug43hobuLYcjTmGp2YJnlFYN4_8iKvUBJ0Q,213
 mcp_code_indexer/ask_handler.py,sha256=cy7gVFyXF0c10GZ3Aquktvgw1A8e4_NtBsbjlE1Bc84,9106
 mcp_code_indexer/claude_api_handler.py,sha256=uZF6P64Cac9AHfO2Q3Whe4exhZyZmqZ1grWT1nHw-Wc,13616
 mcp_code_indexer/cleanup_manager.py,sha256=qjIAMiJ-F1pfgCwVbNaNE0dfs8Wh9aaWh51DBMCWFuI,9491
+mcp_code_indexer/commands/__init__.py,sha256=141U722dS_NnFTZyxTPipzhXKdU21kCv-mcrN4djyHo,45
+mcp_code_indexer/commands/makelocal.py,sha256=2rbHG5G4VgDECZ74YFxcLtKYtuDYUMIbhv_LtW3ZVJQ,7550
 mcp_code_indexer/data/stop_words_english.txt,sha256=7Zdd9ameVgA6tN_zuXROvHXD4hkWeELVywPhb7FJEkw,6343
 mcp_code_indexer/database/__init__.py,sha256=aPq_aaRp0aSwOBIq9GkuMNjmLxA411zg2vhdrAuHm-w,38
-mcp_code_indexer/database/connection_health.py,sha256=zhw6WLR-YVDUKM9tQLcpcEM0yoaheYYzpa0iSMS-_N4,25476
+mcp_code_indexer/database/connection_health.py,sha256=vu8c8lDLEwva7ldTdxvlACTKT59kO-KjZ9I3tMbwr3s,25240
 mcp_code_indexer/database/database.py,sha256=BpsWoy5qXqLQpEZ42dt5efOGSrLhokQyvAc9ZK0afc4,46895
+mcp_code_indexer/database/database_factory.py,sha256=M7ojiDzs-acJG3QE4khTo2pYyQM9gUBcMAm0duboiLU,4875
 mcp_code_indexer/database/exceptions.py,sha256=Cs9_qc-6724DPJc25fPMvNfO3JQCHrOQ80y8Q55w_3Y,10389
 mcp_code_indexer/database/models.py,sha256=ITF5dMSBCuaunQ3YeaVQOZ5Kb8y59I5Fg0EU7O9Ez3A,7017
+mcp_code_indexer/database/path_resolver.py,sha256=UFLyo_Y5pyHmU1a27XB6S-XHq6l5IUlhfGe5lgFCWv4,4041
 mcp_code_indexer/database/retry_executor.py,sha256=wBIIbkU1bwQMrjM9AmDWNEQ-cw8IPNobfdeUOLhQVjQ,13528
 mcp_code_indexer/deepask_handler.py,sha256=wpKMYnlsOGiaKLvuXIb62jeEb4xnYOmIcvvXjvbgdnc,18475
 mcp_code_indexer/error_handler.py,sha256=XBjjEriq1diPTGKpHcaBh9fj88_qhuNMwPeLiTWxrds,11431
 mcp_code_indexer/file_scanner.py,sha256=smY1Yfxfyqb_J5RQz5ETaSgE2_syC2SUUwzJxby3Bg8,11432
 mcp_code_indexer/git_hook_handler.py,sha256=mP8uvtQFo4C6dPNSBlG4NUXwVTXofDzDpjZVSk43yzw,45542
 mcp_code_indexer/logging_config.py,sha256=hexJWw7-6QQkH_2BwtKGO1CDOtQnP8F3Yss_yHKnzE4,9816
-mcp_code_indexer/main.py,sha256=CMvEiwMd6O0oG25aIGbpxNjQzD5dH-ROFj7j1ff8RvE,30724
+mcp_code_indexer/main.py,sha256=2T2yXG_-MIDmj1xdW85FolaOtv4vshlWjljhRSIh5IA,30800
 mcp_code_indexer/middleware/__init__.py,sha256=p-mP0pMsfiU2yajCPvokCUxUEkh_lu4XJP1LyyMW2ug,220
 mcp_code_indexer/middleware/error_middleware.py,sha256=YHd7sm4PdNPIMKD8Nub_N7WaOH2JtiqkHBbTOGyxTno,11685
 mcp_code_indexer/migrations/001_initial.sql,sha256=hIXkCP4LA_4A9HJ1CHU0a1DD-a6EN6u-uJPMqW0c2Yo,4120
@@ -25,12 +29,12 @@ mcp_code_indexer/migrations/004_remove_branch_dependency.sql,sha256=whZvj2qfba1-
 mcp_code_indexer/migrations/005_remove_git_remotes.sql,sha256=vT84AaV1hyN4zq5W67hR14TgAwhW7_RNtBHrCoksxA4,1299
 mcp_code_indexer/query_preprocessor.py,sha256=PLFR1T9mSn2Mkxw6-GB4GkxyfzjJ2ia3dgLPcziHfVA,5483
 mcp_code_indexer/server/__init__.py,sha256=16xMcuriUOBlawRqWNBk6niwrvtv_JD5xvI36X1Vsmk,41
-mcp_code_indexer/server/mcp_server.py,sha256=L83xi38SEqoIXH_ZJVOmMNFwTnGRHbQRuAAxLjqwCWA,71554
+mcp_code_indexer/server/mcp_server.py,sha256=o6G5vNxtyWwL_x4UXTB9XfG6acoba5P9hTJ70qoZ_l4,72660
 mcp_code_indexer/tiktoken_cache/9b5ad71b2ce5302211f9c61530b329a4922fc6a4,sha256=Ijkht27pm96ZW3_3OFE-7xAPtR0YyTWXoRO8_-hlsqc,1681126
 mcp_code_indexer/token_counter.py,sha256=e6WsyCEWMMSkMwLbcVtr5e8vEqh-kFqNmiJErCNdqHE,8220
 mcp_code_indexer/tools/__init__.py,sha256=m01mxML2UdD7y5rih_XNhNSCMzQTz7WQ_T1TeOcYlnE,49
-mcp_code_indexer-3.4.2.dist-info/LICENSE,sha256=JN9dyPPgYwH9C-UjYM7FLNZjQ6BF7kAzpF3_4PwY4rY,1086
-mcp_code_indexer-3.4.2.dist-info/METADATA,sha256=XhyzREnGleVrnlpuObat0Mt7oO2XyYDZ4yR8F0vPsRk,19359
-mcp_code_indexer-3.4.2.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-mcp_code_indexer-3.4.2.dist-info/entry_points.txt,sha256=UABj7HZ0mC6rvF22gxaz2LLNLGQShTrFmp5u00iUtvo,67
-mcp_code_indexer-3.4.2.dist-info/RECORD,,
+mcp_code_indexer-3.5.0.dist-info/LICENSE,sha256=JN9dyPPgYwH9C-UjYM7FLNZjQ6BF7kAzpF3_4PwY4rY,1086
+mcp_code_indexer-3.5.0.dist-info/METADATA,sha256=2vo4ryVLHtcq_qNukXkMJCZoBT1qC_cmK5JHAd_NlB4,19359
+mcp_code_indexer-3.5.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+mcp_code_indexer-3.5.0.dist-info/entry_points.txt,sha256=UABj7HZ0mC6rvF22gxaz2LLNLGQShTrFmp5u00iUtvo,67
+mcp_code_indexer-3.5.0.dist-info/RECORD,,