mcp-code-indexer 3.4.3__tar.gz → 3.5.0__tar.gz

{mcp_code_indexer-3.4.3 → mcp_code_indexer-3.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: mcp-code-indexer
-Version: 3.4.3
+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?34)](https://badge.fury.io/py/mcp-code-indexer)
-[![Python](https://img.shields.io/pypi/pyversions/mcp-code-indexer.svg?34)](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.3 → mcp_code_indexer-3.5.0}/README.md

@@ -1,7 +1,7 @@
 # MCP Code Indexer 🚀
 
-[![PyPI version](https://badge.fury.io/py/mcp-code-indexer.svg?34)](https://badge.fury.io/py/mcp-code-indexer)
-[![Python](https://img.shields.io/pypi/pyversions/mcp-code-indexer.svg?34)](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.3 → mcp_code_indexer-3.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "mcp-code-indexer"
-version = "3.4.3"
+version = "3.5.0"
 description = "MCP server that tracks file descriptions across codebases, enabling AI agents to efficiently navigate and understand code through searchable summaries and token-aware overviews."
 authors = ["MCP Code Indexer Contributors"]
 maintainers = ["MCP Code Indexer Contributors"]

{mcp_code_indexer-3.4.3 → mcp_code_indexer-3.5.0}/src/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-3.5.0/src/mcp_code_indexer/commands/__init__.py

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

mcp_code_indexer-3.5.0/src/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-3.5.0/src/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-3.5.0/src/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-3.4.3 → mcp_code_indexer-3.5.0}/src/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']}")