mcp-code-indexer 2.0.1__py3-none-any.whl → 2.1.0__py3-none-any.whl

mcp_code_indexer/server/mcp_server.py

@@ -54,7 +54,10 @@ class MCPCodeIndexServer:
         db_retry_count: int = 5,
         db_timeout: float = 10.0,
         enable_wal_mode: bool = True,
-        health_check_interval: float = 30.0
+        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 MCP Code Index Server.
@@ -68,6 +71,9 @@ class MCPCodeIndexServer:
             db_timeout: Database transaction timeout in seconds
             enable_wal_mode: Enable WAL mode for better concurrent access
             health_check_interval: Database health check interval in seconds
+            retry_min_wait: Minimum wait time between retries in seconds
+            retry_max_wait: Maximum wait time between retries in seconds
+            retry_jitter: Maximum jitter to add to retry delays in seconds
         """
         self.token_limit = token_limit
         self.db_path = db_path or Path.home() / ".mcp-code-index" / "tracker.db"
@@ -79,7 +85,10 @@ class MCPCodeIndexServer:
             "retry_count": db_retry_count,
             "timeout": db_timeout,
             "enable_wal_mode": enable_wal_mode,
-            "health_check_interval": health_check_interval
+            "health_check_interval": health_check_interval,
+            "retry_min_wait": retry_min_wait,
+            "retry_max_wait": retry_max_wait,
+            "retry_jitter": retry_jitter
         }
         
         # Initialize components
@@ -89,7 +98,10 @@ class MCPCodeIndexServer:
             retry_count=db_retry_count,
             timeout=db_timeout,
             enable_wal_mode=enable_wal_mode,
-            health_check_interval=health_check_interval
+            health_check_interval=health_check_interval,
+            retry_min_wait=retry_min_wait,
+            retry_max_wait=retry_max_wait,
+            retry_jitter=retry_jitter
         )
         self.token_counter = TokenCounter(token_limit)
         self.merge_handler = MergeHandler(self.db_manager)
@@ -312,7 +324,7 @@ class MCPCodeIndexServer:
                 ),
                 types.Tool(
                     name="search_descriptions",
-                    description="Searches through all file descriptions in a project to find files related to specific functionality. Use this for large codebases instead of loading the entire structure.",
+                    description="Searches through all file descriptions in a project to find files related to specific functionality. Use this for large codebases instead of loading the entire structure. Always start with the fewest terms possible; if the tool returns a lot of results (more than 20) or the results are not relevant, then narrow it down by increasing the number of search terms. Start broad, then narrow the focus only if needed!",
                     inputSchema={
                         "type": "object",
                         "properties": {
@@ -1194,21 +1206,76 @@ src/
         }
     
     async def _handle_check_database_health(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
-        """Handle check_database_health tool calls."""
-        # Get comprehensive database health and statistics
-        health_check = await self.db_manager.check_health()
+        """
+        Handle check_database_health tool calls with comprehensive diagnostics.
+        
+        Returns detailed database health information including retry statistics,
+        performance analysis, and resilience indicators.
+        """
+        # Get comprehensive health diagnostics from the enhanced monitor
+        if hasattr(self.db_manager, '_health_monitor') and self.db_manager._health_monitor:
+            comprehensive_diagnostics = self.db_manager._health_monitor.get_comprehensive_diagnostics()
+        else:
+            # 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"
+            }
+        
+        # Get additional database-level statistics
         database_stats = self.db_manager.get_database_stats()
         
         return {
-            "health_check": health_check,
-            "database_stats": database_stats,
-            "configuration": self.db_config,
+            "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 {}
+                )
+            },
             "server_info": {
                 "token_limit": self.token_limit,
                 "db_path": str(self.db_path),
-                "cache_dir": str(self.cache_dir)
+                "cache_dir": str(self.cache_dir),
+                "health_monitoring_enabled": (
+                    hasattr(self.db_manager, '_health_monitor') and 
+                    self.db_manager._health_monitor is not None
+                )
             },
-            "timestamp": datetime.utcnow().isoformat()
+            "timestamp": datetime.utcnow().isoformat(),
+            "status_summary": self._generate_health_summary(comprehensive_diagnostics)
+        }
+    
+    def _generate_health_summary(self, diagnostics: Dict[str, Any]) -> Dict[str, Any]:
+        """Generate a concise health summary from comprehensive diagnostics."""
+        if "resilience_indicators" not in diagnostics:
+            return {"status": "limited_diagnostics_available"}
+        
+        resilience = diagnostics["resilience_indicators"]
+        performance = diagnostics.get("performance_analysis", {})
+        
+        # Overall status based on health score
+        health_score = resilience.get("overall_health_score", 0)
+        if health_score >= 90:
+            status = "excellent"
+        elif health_score >= 75:
+            status = "good"  
+        elif health_score >= 50:
+            status = "fair"
+        else:
+            status = "poor"
+        
+        return {
+            "overall_status": status,
+            "health_score": health_score,
+            "retry_effectiveness": resilience.get("retry_effectiveness", {}).get("is_effective", False),
+            "connection_stability": resilience.get("connection_stability", {}).get("is_stable", False),
+            "key_recommendations": resilience.get("recommendations", [])[:3],  # Top 3 recommendations
+            "performance_trend": performance.get("health_check_performance", {}).get("recent_performance_trend", "unknown")
         }
     
     async def _run_session_with_retry(self, read_stream, write_stream, initialization_options) -> None:

{mcp_code_indexer-2.0.1.dist-info → mcp_code_indexer-2.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-code-indexer
-Version: 2.0.1
+Version: 2.1.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.
 Author: MCP Code Indexer Contributors
 Maintainer: MCP Code Indexer Contributors
@@ -59,8 +59,8 @@ Dynamic: requires-python
 
 # MCP Code Indexer 🚀
 
-[![PyPI version](https://badge.fury.io/py/mcp-code-indexer.svg?12)](https://badge.fury.io/py/mcp-code-indexer)
-[![Python](https://img.shields.io/pypi/pyversions/mcp-code-indexer.svg?12)](https://pypi.org/project/mcp-code-indexer/)
+[![PyPI version](https://badge.fury.io/py/mcp-code-indexer.svg?14)](https://badge.fury.io/py/mcp-code-indexer)
+[![Python](https://img.shields.io/pypi/pyversions/mcp-code-indexer.svg?14)](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-2.0.1.dist-info → mcp_code_indexer-2.1.0.dist-info}/RECORD

@@ -9,19 +9,20 @@ mcp_code_indexer/merge_handler.py,sha256=lJR8eVq2qSrF6MW9mR3Fy8UzrNAaQ7RsI2FMNXn
 mcp_code_indexer/token_counter.py,sha256=WrifOkbF99nWWHlRlhCHAB2KN7qr83GOHl7apE-hJcE,8460
 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=XJvUrHRhIroZlIPScVGdKb69lNP67lT9ZTTO67cFSEs,16721
-mcp_code_indexer/database/database.py,sha256=E1442Y__-zBm-L29Ck3cKieslqlRZri025msZ9IL1hA,49699
+mcp_code_indexer/database/connection_health.py,sha256=s2r9L_KipH5NlemAUDnhBQO90Dn4b_0Ht9UDs7F6QPk,24432
+mcp_code_indexer/database/database.py,sha256=86XL1b49cTeTzkJ1mVbkYPq_QyQrVQOy8w_b1MxZR-E,50856
+mcp_code_indexer/database/exceptions.py,sha256=AgpRA9Z5R-GoWYdQSPeSdYvAXDopFCQkLGN3jD7Ha4E,10215
 mcp_code_indexer/database/models.py,sha256=_vCmJnPXZSiInRzyvs4c7QUWuNNW8qsOoDlGX8J-Gnk,7124
-mcp_code_indexer/database/retry_handler.py,sha256=zwwZ0V1PzzS1rtcfVQOI-CXqWnPGF-KGH4L_3d-_h1Y,11932
+mcp_code_indexer/database/retry_executor.py,sha256=QUayjkCk8OsckVMYiJ_HBQ9NTUss-H8GQeUIUbbw4_U,13419
 mcp_code_indexer/middleware/__init__.py,sha256=p-mP0pMsfiU2yajCPvokCUxUEkh_lu4XJP1LyyMW2ug,220
 mcp_code_indexer/middleware/error_middleware.py,sha256=5agJTAkkPogfPGnja1V9JtG9RG-BiOALIJYctK3byJQ,11730
 mcp_code_indexer/server/__init__.py,sha256=16xMcuriUOBlawRqWNBk6niwrvtv_JD5xvI36X1Vsmk,41
-mcp_code_indexer/server/mcp_server.py,sha256=tQTZFnAnASStkbnQOsj2-3eH1DYSmY97q1pwo7geFXI,66934
+mcp_code_indexer/server/mcp_server.py,sha256=KJAGkhYIR3MVJZECKWL9rpMP3Yb8uO9k7gj5dQ3Wpbc,70436
 mcp_code_indexer/tiktoken_cache/9b5ad71b2ce5302211f9c61530b329a4922fc6a4,sha256=Ijkht27pm96ZW3_3OFE-7xAPtR0YyTWXoRO8_-hlsqc,1681126
 mcp_code_indexer/tools/__init__.py,sha256=m01mxML2UdD7y5rih_XNhNSCMzQTz7WQ_T1TeOcYlnE,49
-mcp_code_indexer-2.0.1.dist-info/licenses/LICENSE,sha256=JN9dyPPgYwH9C-UjYM7FLNZjQ6BF7kAzpF3_4PwY4rY,1086
-mcp_code_indexer-2.0.1.dist-info/METADATA,sha256=JPMMfXoxy-VV013tSyMFIrWs8O4KKKSCV9Oiij2klH8,20165
-mcp_code_indexer-2.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcp_code_indexer-2.0.1.dist-info/entry_points.txt,sha256=8HqWOw1Is7jOP1bvIgaSwouvT9z_Boe-9hd4NzyJOhY,68
-mcp_code_indexer-2.0.1.dist-info/top_level.txt,sha256=yKYCM-gMGt-cnupGfAhnZaoEsROLB6DQ1KFUuyKx4rw,17
-mcp_code_indexer-2.0.1.dist-info/RECORD,,
+mcp_code_indexer-2.1.0.dist-info/licenses/LICENSE,sha256=JN9dyPPgYwH9C-UjYM7FLNZjQ6BF7kAzpF3_4PwY4rY,1086
+mcp_code_indexer-2.1.0.dist-info/METADATA,sha256=YA7MXrDtBNK3Hja15CNGJIx4HcwIti__ccb3V5as3So,20165
+mcp_code_indexer-2.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcp_code_indexer-2.1.0.dist-info/entry_points.txt,sha256=8HqWOw1Is7jOP1bvIgaSwouvT9z_Boe-9hd4NzyJOhY,68
+mcp_code_indexer-2.1.0.dist-info/top_level.txt,sha256=yKYCM-gMGt-cnupGfAhnZaoEsROLB6DQ1KFUuyKx4rw,17
+mcp_code_indexer-2.1.0.dist-info/RECORD,,

mcp_code_indexer/database/retry_handler.py

@@ -1,344 +0,0 @@
-"""
-Database retry handling for SQLite locking scenarios.
-
-This module provides specialized retry logic for database operations that may
-encounter locking issues in high-concurrency environments.
-"""
-
-import asyncio
-import logging
-import random
-import time
-from contextlib import asynccontextmanager
-from dataclasses import dataclass
-from typing import Any, AsyncIterator, Callable, Optional, Type, Union
-from datetime import datetime
-
-import aiosqlite
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class RetryConfig:
-    """Configuration for database retry logic."""
-    max_attempts: int = 5
-    initial_delay: float = 0.1  # seconds
-    max_delay: float = 2.0      # seconds
-    backoff_multiplier: float = 2.0
-    jitter: bool = True
-    retry_on_error_types: tuple = (aiosqlite.OperationalError,)
-
-
-class DatabaseLockError(Exception):
-    """Exception for database locking issues."""
-    
-    def __init__(self, message: str, retry_count: int = 0, last_attempt: Optional[datetime] = None):
-        self.message = message
-        self.retry_count = retry_count
-        self.last_attempt = last_attempt or datetime.utcnow()
-        super().__init__(message)
-
-
-class RetryHandler:
-    """Handles database operation retries with exponential backoff."""
-    
-    def __init__(self, config: Optional[RetryConfig] = None):
-        """
-        Initialize retry handler.
-        
-        Args:
-            config: Retry configuration, uses defaults if None
-        """
-        self.config = config or RetryConfig()
-        self._retry_stats = {
-            "total_attempts": 0,
-            "successful_retries": 0,
-            "failed_operations": 0,
-            "avg_retry_delay": 0.0
-        }
-    
-    @asynccontextmanager
-    async def with_retry(self, operation_name: str = "database_operation") -> AsyncIterator[None]:
-        """
-        Context manager that provides retry logic for database operations.
-        
-        Args:
-            operation_name: Name of the operation for logging
-            
-        Usage:
-            async with retry_handler.with_retry("create_project"):
-                # Your database operation here
-                await db.execute(...)
-        """
-        last_error = None
-        total_delay = 0.0
-        
-        for attempt in range(1, self.config.max_attempts + 1):
-            self._retry_stats["total_attempts"] += 1
-            
-            try:
-                yield
-                
-                # Success - log if this was a retry
-                if attempt > 1:
-                    self._retry_stats["successful_retries"] += 1
-                    logger.info(
-                        f"Database operation '{operation_name}' succeeded on attempt {attempt}",
-                        extra={
-                            "structured_data": {
-                                "retry_success": {
-                                    "operation": operation_name,
-                                    "attempt": attempt,
-                                    "total_delay": total_delay
-                                }
-                            }
-                        }
-                    )
-                return
-                
-            except Exception as e:
-                last_error = e
-                
-                # Check if this is a retryable error
-                if not self._is_retryable_error(e):
-                    logger.error(
-                        f"Non-retryable error in '{operation_name}': {e}",
-                        extra={
-                            "structured_data": {
-                                "non_retryable_error": {
-                                    "operation": operation_name,
-                                    "error_type": type(e).__name__,
-                                    "error_message": str(e)
-                                }
-                            }
-                        }
-                    )
-                    raise
-                
-                # If this is the last attempt, give up
-                if attempt >= self.config.max_attempts:
-                    self._retry_stats["failed_operations"] += 1
-                    logger.error(
-                        f"Database operation '{operation_name}' failed after {attempt} attempts",
-                        extra={
-                            "structured_data": {
-                                "retry_exhausted": {
-                                    "operation": operation_name,
-                                    "max_attempts": self.config.max_attempts,
-                                    "total_delay": total_delay,
-                                    "final_error": str(e)
-                                }
-                            }
-                        }
-                    )
-                    raise DatabaseLockError(
-                        f"Database operation failed after {attempt} attempts: {e}",
-                        retry_count=attempt,
-                        last_attempt=datetime.utcnow()
-                    )
-                
-                # Calculate delay for next attempt
-                delay = self._calculate_delay(attempt)
-                total_delay += delay
-                
-                logger.warning(
-                    f"Database operation '{operation_name}' failed on attempt {attempt}, retrying in {delay:.2f}s",
-                    extra={
-                        "structured_data": {
-                            "retry_attempt": {
-                                "operation": operation_name,
-                                "attempt": attempt,
-                                "delay_seconds": delay,
-                                "error_type": type(e).__name__,
-                                "error_message": str(e)
-                            }
-                        }
-                    }
-                )
-                
-                # Wait before retry
-                await asyncio.sleep(delay)
-    
-    def _is_retryable_error(self, error: Exception) -> bool:
-        """
-        Determine if an error is retryable.
-        
-        Args:
-            error: Exception to check
-            
-        Returns:
-            True if the error should trigger a retry
-        """
-        # Check error type
-        if not isinstance(error, self.config.retry_on_error_types):
-            return False
-        
-        # Check specific SQLite error messages
-        error_message = str(error).lower()
-        retryable_messages = [
-            "database is locked",
-            "database is busy",
-            "cannot start a transaction within a transaction",
-            "sqlite_busy",
-            "sqlite_locked"
-        ]
-        
-        return any(msg in error_message for msg in retryable_messages)
-    
-    def _calculate_delay(self, attempt: int) -> float:
-        """
-        Calculate delay for retry attempt with exponential backoff and jitter.
-        
-        Args:
-            attempt: Current attempt number (1-based)
-            
-        Returns:
-            Delay in seconds
-        """
-        # Exponential backoff: initial_delay * (multiplier ^ (attempt - 1))
-        delay = self.config.initial_delay * (self.config.backoff_multiplier ** (attempt - 1))
-        
-        # Cap at max delay
-        delay = min(delay, self.config.max_delay)
-        
-        # Add jitter to prevent thundering herd
-        if self.config.jitter:
-            jitter_range = delay * 0.1  # 10% jitter
-            delay += random.uniform(-jitter_range, jitter_range)
-        
-        # Ensure delay is positive
-        return max(0.0, delay)
-    
-    def get_retry_stats(self) -> dict:
-        """
-        Get retry statistics.
-        
-        Returns:
-            Dictionary with retry statistics
-        """
-        if self._retry_stats["successful_retries"] > 0:
-            self._retry_stats["avg_retry_delay"] = (
-                self._retry_stats["total_attempts"] / self._retry_stats["successful_retries"]
-            )
-        
-        return self._retry_stats.copy()
-    
-    def reset_stats(self) -> None:
-        """Reset retry statistics."""
-        self._retry_stats = {
-            "total_attempts": 0,
-            "successful_retries": 0,
-            "failed_operations": 0,
-            "avg_retry_delay": 0.0
-        }
-
-
-class ConnectionRecoveryManager:
-    """Manages database connection recovery for persistent failures."""
-    
-    def __init__(self, database_manager):
-        """
-        Initialize connection recovery manager.
-        
-        Args:
-            database_manager: DatabaseManager instance to manage
-        """
-        self.database_manager = database_manager
-        self._recovery_stats = {
-            "pool_refreshes": 0,
-            "last_refresh": None,
-            "consecutive_failures": 0
-        }
-        self._failure_threshold = 3  # Refresh pool after 3 consecutive failures
-    
-    async def handle_persistent_failure(self, operation_name: str, error: Exception) -> bool:
-        """
-        Handle persistent database failures by attempting pool refresh.
-        
-        Args:
-            operation_name: Name of the failing operation
-            error: The persistent error
-            
-        Returns:
-            True if pool refresh was attempted, False otherwise
-        """
-        self._recovery_stats["consecutive_failures"] += 1
-        
-        # Only refresh if we've hit the threshold
-        if self._recovery_stats["consecutive_failures"] >= self._failure_threshold:
-            logger.warning(
-                f"Attempting connection pool refresh after {self._recovery_stats['consecutive_failures']} failures",
-                extra={
-                    "structured_data": {
-                        "pool_recovery": {
-                            "operation": operation_name,
-                            "consecutive_failures": self._recovery_stats["consecutive_failures"],
-                            "trigger_error": str(error)
-                        }
-                    }
-                }
-            )
-            
-            await self._refresh_connection_pool()
-            return True
-        
-        return False
-    
-    def reset_failure_count(self) -> None:
-        """Reset consecutive failure count after successful operation."""
-        self._recovery_stats["consecutive_failures"] = 0
-    
-    async def _refresh_connection_pool(self) -> None:
-        """
-        Refresh the database connection pool by closing all connections.
-        
-        This forces creation of new connections on next access.
-        """
-        try:
-            # Close existing pool
-            await self.database_manager.close_pool()
-            
-            # Update stats
-            self._recovery_stats["pool_refreshes"] += 1
-            self._recovery_stats["last_refresh"] = datetime.utcnow()
-            self._recovery_stats["consecutive_failures"] = 0
-            
-            logger.info("Database connection pool refreshed successfully")
-            
-        except Exception as e:
-            logger.error(f"Failed to refresh connection pool: {e}")
-            raise
-    
-    def get_recovery_stats(self) -> dict:
-        """
-        Get connection recovery statistics.
-        
-        Returns:
-            Dictionary with recovery statistics
-        """
-        return self._recovery_stats.copy()
-
-
-def create_retry_handler(
-    max_attempts: int = 5,
-    initial_delay: float = 0.1,
-    max_delay: float = 2.0
-) -> RetryHandler:
-    """
-    Create a configured retry handler for database operations.
-    
-    Args:
-        max_attempts: Maximum retry attempts
-        initial_delay: Initial delay in seconds
-        max_delay: Maximum delay in seconds
-        
-    Returns:
-        Configured RetryHandler instance
-    """
-    config = RetryConfig(
-        max_attempts=max_attempts,
-        initial_delay=initial_delay,
-        max_delay=max_delay
-    )
-    return RetryHandler(config)