mcp-code-indexer 4.0.1__py3-none-any.whl → 4.1.0__py3-none-any.whl

mcp_code_indexer/query_preprocessor.py

@@ -15,8 +15,8 @@ Key features:
 - Special character handling: preserves special characters in quoted terms
 """
 
-import re
 import logging
+import re
 from typing import List, Set
 
 logger = logging.getLogger(__name__)
@@ -33,7 +33,7 @@ class QueryPreprocessor:
     # FTS5 operators that need to be escaped when used as literal search terms
     FTS5_OPERATORS: Set[str] = {"AND", "OR", "NOT", "NEAR"}
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Initialize the query preprocessor."""
         pass
 

mcp_code_indexer/server/mcp_server.py

@@ -15,30 +15,28 @@ import time
 import uuid
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Callable, cast
 
 from mcp import types
 from mcp.server import Server
-from mcp.server.stdio import stdio_server
 from pydantic import ValidationError
 
+from mcp_code_indexer.cleanup_manager import CleanupManager
 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 (
-    Project,
     FileDescription,
+    Project,
     ProjectOverview,
 )
 from mcp_code_indexer.error_handler import setup_error_handling
+from mcp_code_indexer.file_scanner import FileScanner
+from mcp_code_indexer.logging_config import get_logger
 from mcp_code_indexer.middleware.error_middleware import (
-    create_tool_middleware,
     AsyncTaskManager,
+    create_tool_middleware,
 )
-from mcp_code_indexer.logging_config import get_logger
-from mcp_code_indexer.cleanup_manager import CleanupManager
-
+from mcp_code_indexer.token_counter import TokenCounter
 
 logger = logging.getLogger(__name__)
 
@@ -65,6 +63,7 @@ class MCPCodeIndexServer:
         retry_max_wait: float = 2.0,
         retry_jitter: float = 0.2,
         transport: Optional[Any] = None,
+        vector_mode: bool = False,
     ):
         """
         Initialize the MCP Code Index Server.
@@ -82,10 +81,12 @@ class MCPCodeIndexServer:
             retry_max_wait: Maximum wait time between retries in seconds
             retry_jitter: Maximum jitter to add to retry delays in seconds
             transport: Optional transport instance (if None, uses default stdio)
+            vector_mode: Enable vector search capabilities and tools
         """
         self.token_limit = token_limit
         self.db_path = db_path or Path.home() / ".mcp-code-index" / "tracker.db"
         self.cache_dir = cache_dir or Path.home() / ".mcp-code-index" / "cache"
+        self.vector_mode = vector_mode
 
         # Store database configuration
         self.db_config = {
@@ -112,9 +113,11 @@ class MCPCodeIndexServer:
             retry_jitter=retry_jitter,
         )
         # Keep reference to global db_manager for backwards compatibility
-        self.db_manager = None  # Will be set during run()
+        self.db_manager: Optional[DatabaseManager] = None  # Will be set during run()
         self.token_counter = TokenCounter(token_limit)
-        self.cleanup_manager = None  # Will be set during initialize()
+        self.cleanup_manager: Optional[CleanupManager] = (
+            None  # Will be set during initialize()
+        )
         self.transport = transport
 
         # Setup error handling
@@ -124,7 +127,7 @@ class MCPCodeIndexServer:
         self.task_manager = AsyncTaskManager(self.error_handler)
 
         # Create MCP server
-        self.server = Server("mcp-code-indexer")
+        self.server: Server = Server("mcp-code-indexer")
 
         # Register handlers
         self._register_handlers()
@@ -168,7 +171,7 @@ class MCPCodeIndexServer:
         Returns:
             Dictionary with HTML entities decoded in all string values
         """
-        cleaned = {}
+        cleaned: Dict[str, Any] = {}
 
         for key, value in arguments.items():
             if isinstance(value, str):
@@ -203,7 +206,11 @@ class MCPCodeIndexServer:
         """
         # First try normal parsing
         try:
-            return json.loads(json_str)
+            result = json.loads(json_str)
+            if isinstance(result, dict):
+                return result
+            else:
+                raise ValueError(f"Parsed JSON is not a dictionary: {type(result)}")
         except json.JSONDecodeError as original_error:
             logger.warning(f"Initial JSON parse failed: {original_error}")
 
@@ -232,11 +239,16 @@ class MCPCodeIndexServer:
 
             try:
                 result = json.loads(repaired)
-                logger.info(
-                    f"Successfully repaired JSON. Original: {json_str[:100]}..."
-                )
-                logger.info(f"Repaired: {repaired[:100]}...")
-                return result
+                if isinstance(result, dict):
+                    logger.info(
+                        f"Successfully repaired JSON. Original: {json_str[:100]}..."
+                    )
+                    logger.info(f"Repaired: {repaired[:100]}...")
+                    return result
+                else:
+                    raise ValueError(
+                        f"Repaired JSON is not a dictionary: {type(result)}"
+                    )
             except json.JSONDecodeError as repair_error:
                 logger.error(f"JSON repair failed. Original: {json_str}")
                 logger.error(f"Repaired attempt: {repaired}")
@@ -250,14 +262,15 @@ class MCPCodeIndexServer:
         # 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)
+        if self.db_manager is not None:
+            self.cleanup_manager = CleanupManager(self.db_manager, retention_months=6)
         self._start_background_cleanup()
         logger.info("Server initialized successfully")
 
     def _register_handlers(self) -> None:
         """Register MCP tool and resource handlers."""
 
-        @self.server.list_tools()
+        @self.server.list_tools()  # type: ignore[misc]
         async def list_tools() -> List[types.Tool]:
             """Return list of available tools."""
             return [
@@ -673,7 +686,7 @@ class MCPCodeIndexServer:
                 ),
             ]
 
-        @self.server.call_tool()
+        @self.server.call_tool()  # type: ignore[misc]
         async def call_tool(
             name: str, arguments: Dict[str, Any]
         ) -> List[types.TextContent]:
@@ -719,7 +732,14 @@ class MCPCodeIndexServer:
                     f"MCP Tool '{name}' completed successfully in {elapsed_time:.2f}s"
                 )
 
-                return result
+                # Ensure result is List[types.TextContent]
+                if isinstance(result, list) and all(
+                    isinstance(item, types.TextContent) for item in result
+                ):
+                    return result
+                else:
+                    # Fallback: convert to proper format
+                    return [types.TextContent(type="text", text=str(result))]
             except Exception as e:
                 elapsed_time = time.time() - start_time
                 logger.error(f"MCP Tool '{name}' failed after {elapsed_time:.2f}s: {e}")
@@ -727,7 +747,7 @@ class MCPCodeIndexServer:
                 raise
 
     async def _execute_tool_handler(
-        self, handler, arguments: Dict[str, Any]
+        self, handler: Callable[[Dict[str, Any]], Any], arguments: Dict[str, Any]
     ) -> List[types.TextContent]:
         """Execute a tool handler and format the result."""
         # Clean HTML entities from all arguments before processing
@@ -753,10 +773,10 @@ class MCPCodeIndexServer:
 
         # Get the appropriate database manager for this folder
         db_manager = await self.db_factory.get_database_manager(folder_path)
-        
+
         # Check if this is a local database
         is_local = self.db_factory.get_path_resolver().is_local_database(folder_path)
-        
+
         if is_local:
             # For local databases: just get the single project (there should only be one)
             all_projects = await db_manager.get_all_projects()
@@ -764,7 +784,9 @@ class MCPCodeIndexServer:
                 project = all_projects[0]  # Use the first (and should be only) project
                 # Update last accessed time
                 await db_manager.update_project_access_time(project.id)
-                logger.info(f"Using existing local project: {project.name} (ID: {project.id})")
+                logger.info(
+                    f"Using existing local project: {project.name} (ID: {project.id})"
+                )
                 return project.id
             else:
                 # No project in local database - create one
@@ -772,22 +794,30 @@ class MCPCodeIndexServer:
                 project = Project(
                     id=project_id,
                     name=project_name.lower(),
-                    aliases=[folder_path],  # Store for reference but don't rely on it for matching
+                    aliases=[
+                        folder_path
+                    ],  # Store for reference but don't rely on it for matching
                     created=datetime.utcnow(),
                     last_accessed=datetime.utcnow(),
                 )
                 await db_manager.create_project(project)
-                logger.info(f"Created new local project: {project_name} (ID: {project_id})")
+                logger.info(
+                    f"Created new local project: {project_name} (ID: {project_id})"
+                )
                 return project_id
         else:
             # For global databases: use the existing matching logic
             normalized_name = project_name.lower()
 
             # Find potential project matches
-            project = await self._find_matching_project(normalized_name, folder_path, db_manager)
+            project = await self._find_matching_project(  # type: ignore[assignment]
+                normalized_name, folder_path, db_manager
+            )
             if project:
                 # Update project metadata and aliases
-                await self._update_existing_project(project, normalized_name, folder_path, db_manager)
+                await self._update_existing_project(
+                    project, normalized_name, folder_path, db_manager
+                )
             else:
                 # Create new project with UUID
                 project_id = str(uuid.uuid4())
@@ -799,8 +829,12 @@ class MCPCodeIndexServer:
                     last_accessed=datetime.utcnow(),
                 )
                 await db_manager.create_project(project)
-                logger.info(f"Created new global project: {normalized_name} (ID: {project_id})")
+                logger.info(
+                    f"Created new global project: {normalized_name} (ID: {project_id})"
+                )
 
+            if project is None:
+                raise RuntimeError("Project should always be set in if/else branches above")
             return project.id
 
     async def _find_matching_project(
@@ -826,11 +860,7 @@ class MCPCodeIndexServer:
                 match_factors.append("name")
 
             # Factor 2: Folder path in aliases
-            project_aliases = (
-                json.loads(project.aliases)
-                if isinstance(project.aliases, str)
-                else project.aliases
-            )
+            project_aliases = project.aliases
             if folder_path in project_aliases:
                 score += 1
                 match_factors.append("folder_path")
@@ -878,7 +908,7 @@ class MCPCodeIndexServer:
 
             # Get appropriate database manager for this folder
             db_manager = await self.db_factory.get_database_manager(folder_path)
-            
+
             # Get files already indexed for this project
             indexed_files = await db_manager.get_all_file_descriptions(project.id)
             indexed_basenames = {Path(fd.file_path).name for fd in indexed_files}
@@ -901,7 +931,11 @@ class MCPCodeIndexServer:
             return False
 
     async def _update_existing_project(
-        self, project: Project, normalized_name: str, folder_path: str, db_manager: DatabaseManager
+        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
@@ -915,11 +949,7 @@ class MCPCodeIndexServer:
             should_update = True
 
         # Add folder path to aliases if not already present
-        project_aliases = (
-            json.loads(project.aliases)
-            if isinstance(project.aliases, str)
-            else project.aliases
-        )
+        project_aliases = project.aliases
         if folder_path not in project_aliases:
             project_aliases.append(folder_path)
             project.aliases = project_aliases
@@ -975,12 +1005,15 @@ class MCPCodeIndexServer:
         logger.info(f"Resolved project_id: {project_id}")
 
         file_desc = FileDescription(
+            id=None,  # Will be set by database
             project_id=project_id,
             file_path=arguments["filePath"],
             description=arguments["description"],
             file_hash=arguments.get("fileHash"),
             last_modified=datetime.utcnow(),
             version=1,
+            source_project_id=None,
+            to_be_cleaned=None,
         )
 
         await db_manager.create_file_description(file_desc)
@@ -1039,13 +1072,13 @@ class MCPCodeIndexServer:
 
         total_tokens = descriptions_tokens + overview_tokens
         is_large = total_tokens > token_limit
-        
+
         # Smart recommendation logic:
         # - If total is small, use overview
         # - If total is large but overview is reasonable (< 8k tokens), recommend viewing overview + search
         # - If both are large, use search only
         overview_size_limit = 32000
-        
+
         if not is_large:
             recommendation = "use_overview"
         elif overview_tokens > 0 and overview_tokens <= overview_size_limit:
@@ -1103,7 +1136,9 @@ class MCPCodeIndexServer:
         logger.info(f"Scanning project directory: {folder_path_obj}")
         scanner = FileScanner(folder_path_obj)
         if not scanner.is_valid_project_directory():
-            logger.error(f"Invalid or inaccessible project directory: {folder_path_obj}")
+            logger.error(
+                f"Invalid or inaccessible project directory: {folder_path_obj}"
+            )
             return {
                 "error": f"Invalid or inaccessible project directory: {folder_path_obj}"
             }
@@ -1207,28 +1242,28 @@ class MCPCodeIndexServer:
         root = {"path": "", "files": [], "folders": {}}
 
         for file_desc in file_descriptions:
-            path_parts = Path(file_desc.file_path).parts
+            path_parts = cast(List[str], list(Path(file_desc.file_path).parts))
             current = root
 
             # Navigate/create folder structure
             for i, part in enumerate(path_parts[:-1]):
                 folder_path = "/".join(path_parts[: i + 1])
                 if part not in current["folders"]:
-                    current["folders"][part] = {
+                    current["folders"][part] = {  # type: ignore[index]
                         "path": folder_path,
                         "files": [],
                         "folders": {},
                     }
-                current = current["folders"][part]
+                current = current["folders"][part]  # type: ignore[index]
 
             # Add file to current folder
             if path_parts:  # Handle empty paths
-                current["files"].append(
+                current["files"].append(  # type: ignore[attr-defined]
                     {"path": file_desc.file_path, "description": file_desc.description}
                 )
 
         # Convert nested dict structure to list format, skipping empty folders
-        def convert_structure(node):
+        def convert_structure(node: Dict[str, Any]) -> Dict[str, Any]:
             folders = []
             for folder in node["folders"].values():
                 converted_folder = convert_structure(folder)
@@ -1389,40 +1424,56 @@ class MCPCodeIndexServer:
         """
         # Get comprehensive health diagnostics from the enhanced monitor
         if (
-            hasattr(self.db_manager, "_health_monitor")
+            self.db_manager
+            and hasattr(self.db_manager, "_health_monitor")
             and self.db_manager._health_monitor
         ):
             comprehensive_diagnostics = (
                 self.db_manager._health_monitor.get_comprehensive_diagnostics()
             )
-        else:
+        elif self.db_manager:
             # Fallback to basic health check if monitor not available
             health_check = await self.db_manager.check_health()
             comprehensive_diagnostics = {
                 "basic_health_check": health_check,
                 "note": "Enhanced health monitoring not available",
             }
+        else:
+            comprehensive_diagnostics = {
+                "error": "Database manager not initialized",
+            }
 
         # Get additional database-level statistics
-        database_stats = self.db_manager.get_database_stats()
+        database_stats = self.db_manager.get_database_stats() if self.db_manager else {}
 
         return {
-            "is_healthy": comprehensive_diagnostics.get("current_status", {}).get("is_healthy", True),
+            "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)
+                "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)
+                "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,
                 "db_path": str(self.db_path),
                 "cache_dir": str(self.cache_dir),
                 "health_monitoring_enabled": (
-                    hasattr(self.db_manager, "_health_monitor")
+                    self.db_manager is not None
+                    and hasattr(self.db_manager, "_health_monitor")
                     and self.db_manager._health_monitor is not None
                 ),
             },
@@ -1467,7 +1518,7 @@ class MCPCodeIndexServer:
         }
 
     async def _run_session_with_retry(
-        self, read_stream, write_stream, initialization_options
+        self, read_stream: Any, write_stream: Any, initialization_options: Any
     ) -> None:
         """Run a single MCP session with error handling and retry logic."""
         max_retries = 3
@@ -1566,7 +1617,7 @@ class MCPCodeIndexServer:
             try:
                 await asyncio.sleep(6 * 60 * 60)  # 6 hours
                 await self._run_cleanup_if_needed()
-                
+
             except asyncio.CancelledError:
                 logger.info("Periodic cleanup task cancelled")
                 break
@@ -1574,43 +1625,48 @@ class MCPCodeIndexServer:
                 logger.error(f"Error in periodic cleanup: {e}")
                 # Continue running despite errors
 
-    async def _run_cleanup_if_needed(self, project_id: str = None, project_root: Path = None) -> int:
+    async def _run_cleanup_if_needed(
+        self, project_id: Optional[str] = None, project_root: Optional[Path] = None
+    ) -> int:
         """Run cleanup if conditions are met (not running, not run recently)."""
         current_time = time.time()
-        
+
         # Check if cleanup is already running
         if self._cleanup_running:
             logger.debug("Cleanup already running, skipping")
             return 0
-            
+
         # Check if cleanup was run in the last 30 minutes
-        if (self._last_cleanup_time and 
-            current_time - self._last_cleanup_time < 30 * 60):
+        if self._last_cleanup_time and current_time - self._last_cleanup_time < 30 * 60:
             logger.debug("Cleanup ran recently, skipping")
             return 0
-            
+
         # Set running flag and update time
         self._cleanup_running = True
         self._last_cleanup_time = current_time
-        
+
         try:
             logger.info("Starting cleanup")
             total_cleaned = 0
-            
+
             if project_id and project_root:
                 # Single project cleanup - use appropriate database for this project's folder
                 try:
-                    folder_db_manager = await self.db_factory.get_database_manager(str(project_root))
+                    folder_db_manager = await self.db_factory.get_database_manager(
+                        str(project_root)
+                    )
                     missing_files = await folder_db_manager.cleanup_missing_files(
                         project_id=project_id, project_root=project_root
                     )
                     total_cleaned = len(missing_files)
-                    
+
                     # Perform permanent cleanup (retention policy)
-                    deleted_count = await self.cleanup_manager.perform_cleanup(
-                        project_id=project_id
-                    )
-                    
+                    deleted_count = 0
+                    if self.cleanup_manager:
+                        deleted_count = await self.cleanup_manager.perform_cleanup(
+                            project_id=project_id
+                        )
+
                     if missing_files or deleted_count:
                         logger.info(
                             f"Cleanup: {len(missing_files)} marked, "
@@ -1620,31 +1676,38 @@ class MCPCodeIndexServer:
                     logger.error(f"Error during cleanup: {e}")
             else:
                 # All projects cleanup (for periodic task) - start with global database
+                if not self.db_manager:
+                    logger.error("Database manager not initialized")
+                    return 0
                 projects = await self.db_manager.get_all_projects()
-                
+
                 for project in projects:
                     try:
                         # Skip projects without folder paths in aliases
                         if not project.aliases:
                             continue
-                            
+
                         # Use first alias as folder path
                         folder_path = Path(project.aliases[0])
                         if not folder_path.exists():
                             continue
-                        
+
                         # Get appropriate database manager for this project's folder
-                        project_db_manager = await self.db_factory.get_database_manager(str(folder_path))
+                        project_db_manager = await self.db_factory.get_database_manager(
+                            str(folder_path)
+                        )
                         missing_files = await project_db_manager.cleanup_missing_files(
                             project_id=project.id, project_root=folder_path
                         )
                         total_cleaned += len(missing_files)
-                        
+
                         # Perform permanent cleanup (retention policy)
-                        deleted_count = await self.cleanup_manager.perform_cleanup(
-                            project_id=project.id
-                        )
-                        
+                        deleted_count = 0
+                        if self.cleanup_manager:
+                            deleted_count = await self.cleanup_manager.perform_cleanup(
+                                project_id=project.id
+                            )
+
                         if missing_files or deleted_count:
                             logger.info(
                                 f"Cleanup for {project.name}: "
@@ -1655,10 +1718,10 @@ class MCPCodeIndexServer:
                         logger.error(
                             f"Error during cleanup for project {project.name}: {e}"
                         )
-            
+
             logger.info(f"Cleanup completed: {total_cleaned} files processed")
             return total_cleaned
-            
+
         finally:
             self._cleanup_running = False
 
@@ -1666,8 +1729,7 @@ class MCPCodeIndexServer:
         """Start the background cleanup task."""
         if self._cleanup_task is None or self._cleanup_task.done():
             self._cleanup_task = self.task_manager.create_task(
-                self._periodic_cleanup(),
-                name="periodic_cleanup"
+                self._periodic_cleanup(), name="periodic_cleanup"
             )
             logger.info("Started background cleanup task (6-hour interval)")
 
@@ -1685,10 +1747,11 @@ class MCPCodeIndexServer:
             else:
                 # Fall back to default stdio transport
                 from ..transport.stdio_transport import StdioTransport
+
                 transport = StdioTransport(self)
                 await transport.initialize()
                 await transport._run_with_retry()
-                
+
         except KeyboardInterrupt:
             logger.info("Server stopped by user interrupt")
         except Exception as e:
@@ -1716,12 +1779,13 @@ class MCPCodeIndexServer:
                     await self._cleanup_task
                 except asyncio.CancelledError:
                     pass
-            
+
             # Cancel any running tasks
             self.task_manager.cancel_all()
 
             # Close database connections
-            await self.db_manager.close_pool()
+            if self.db_manager:
+                await self.db_manager.close_pool()
 
             self.logger.info("Server shutdown completed successfully")
 
@@ -1729,7 +1793,7 @@ class MCPCodeIndexServer:
             self.error_handler.log_error(e, context={"phase": "shutdown"})
 
 
-async def main():
+async def main() -> None:
     """Main entry point for the MCP server."""
     import sys
 

mcp_code_indexer/transport/__init__.py

@@ -6,7 +6,7 @@ methods (stdio, HTTP) while maintaining common interface and functionality.
 """
 
 from .base import Transport
-from .stdio_transport import StdioTransport
 from .http_transport import HTTPTransport
+from .stdio_transport import StdioTransport
 
 __all__ = ["Transport", "StdioTransport", "HTTPTransport"]