mcp-code-indexer 4.2.16__tar.gz → 4.2.18__tar.gz

{mcp_code_indexer-4.2.16 → mcp_code_indexer-4.2.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-code-indexer
-Version: 4.2.16
+Version: 4.2.18
 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
 License-File: LICENSE
@@ -49,8 +49,8 @@ Description-Content-Type: text/markdown
 
 # MCP Code Indexer 🚀
 
-[![PyPI version](https://badge.fury.io/py/mcp-code-indexer.svg?63)](https://badge.fury.io/py/mcp-code-indexer)
-[![Python](https://img.shields.io/pypi/pyversions/mcp-code-indexer.svg?63)](https://pypi.org/project/mcp-code-indexer/)
+[![PyPI version](https://badge.fury.io/py/mcp-code-indexer.svg?65)](https://badge.fury.io/py/mcp-code-indexer)
+[![Python](https://img.shields.io/pypi/pyversions/mcp-code-indexer.svg?65)](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-4.2.16 → mcp_code_indexer-4.2.18}/README.md

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

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "mcp-code-indexer"
-version = "4.2.16"
+version = "4.2.18"
 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-4.2.16 → mcp_code_indexer-4.2.18}/src/mcp_code_indexer/database/database.py

@@ -35,7 +35,10 @@ from mcp_code_indexer.database.models import (
     WordFrequencyResult,
     WordFrequencyTerm,
 )
-from mcp_code_indexer.database.retry_executor import create_retry_executor
+from mcp_code_indexer.database.retry_executor import (
+    create_retry_executor,
+    DatabaseLockError,
+)
 from mcp_code_indexer.query_preprocessor import preprocess_search_query
 
 logger = logging.getLogger(__name__)
@@ -54,7 +57,7 @@ class DatabaseManager:
         db_path: Path,
         pool_size: int = 3,
         retry_count: int = 5,
-        timeout: float = 10.0,
+        timeout: float = 30.0,
         enable_wal_mode: bool = True,
         health_check_interval: float = 30.0,
         retry_min_wait: float = 0.1,
@@ -222,7 +225,7 @@ class DatabaseManager:
                 "PRAGMA cache_size = -64000",  # 64MB cache
                 "PRAGMA temp_store = MEMORY",  # Use memory for temp tables
                 "PRAGMA mmap_size = 268435456",  # 256MB memory mapping
-                "PRAGMA busy_timeout = 10000",  # 10s timeout (reduced from 30s)
+                f"PRAGMA busy_timeout = {int(self.timeout * 1000)}",  # Use configured timeout
                 "PRAGMA optimize",  # Enable query planner optimizations
             ]
         )
@@ -406,14 +409,30 @@ class DatabaseManager:
             operation_name: Name of the operation for monitoring
             timeout_seconds: Transaction timeout in seconds
         """
+        import time
+        acquire_start = time.monotonic()
         async with self.get_write_connection_with_retry(operation_name) as conn:
+            write_lock_time = time.monotonic() - acquire_start
+            logger.debug(
+                f"[{operation_name}] Write lock acquired in {write_lock_time*1000:.1f}ms"
+            )
             try:
                 # Start immediate transaction with timeout
+                begin_start = time.monotonic()
                 await asyncio.wait_for(
                     conn.execute("BEGIN IMMEDIATE"), timeout=timeout_seconds
                 )
+                begin_time = time.monotonic() - begin_start
+                logger.debug(
+                    f"[{operation_name}] BEGIN IMMEDIATE completed in {begin_time*1000:.1f}ms"
+                )
                 yield conn
+                commit_start = time.monotonic()
                 await conn.commit()
+                commit_time = time.monotonic() - commit_start
+                logger.debug(
+                    f"[{operation_name}] COMMIT completed in {commit_time*1000:.1f}ms"
+                )
             except asyncio.TimeoutError:
                 logger.warning(
                     (
@@ -473,13 +492,34 @@ class DatabaseManager:
 
         async def execute_transaction() -> Any:
             """Inner function to execute transaction - retried by executor."""
+            import time
+            start_time = time.monotonic()
+            logger.debug(
+                f"[{operation_name}] Starting transaction "
+                f"(timeout={timeout_seconds}s, pool_size={len(self._connection_pool)})"
+            )
             try:
                 async with self.get_immediate_transaction(
                     operation_name, timeout_seconds
                 ) as conn:
+                    lock_acquired_time = time.monotonic()
+                    logger.debug(
+                        f"[{operation_name}] Lock acquired in "
+                        f"{(lock_acquired_time - start_time)*1000:.1f}ms"
+                    )
                     result = await operation_func(conn)
+                    exec_time = time.monotonic()
+                    logger.debug(
+                        f"[{operation_name}] Operation executed in "
+                        f"{(exec_time - lock_acquired_time)*1000:.1f}ms"
+                    )
 
                 # Record successful operation metrics
+                total_time = time.monotonic() - start_time
+                logger.debug(
+                    f"[{operation_name}] Transaction completed successfully "
+                    f"in {total_time*1000:.1f}ms"
+                )
                 if self._metrics_collector:
                     self._metrics_collector.record_operation(
                         operation_name,
@@ -490,26 +530,52 @@ class DatabaseManager:
 
                 return result
 
-            except (aiosqlite.OperationalError, asyncio.TimeoutError) as e:
-                # Record locking event for metrics
-                if self._metrics_collector and "locked" in str(e).lower():
+            except aiosqlite.OperationalError as e:
+                elapsed = time.monotonic() - start_time
+                error_msg = str(e).lower()
+                logger.debug(
+                    f"[{operation_name}] OperationalError after {elapsed*1000:.1f}ms: {e}"
+                )
+                if self._metrics_collector and "locked" in error_msg:
                     self._metrics_collector.record_locking_event(operation_name, str(e))
 
-                # Classify the error for better handling
-                classified_error = classify_sqlite_error(e, operation_name)
-
-                # Record failed operation metrics for non-retryable errors
-                if not is_retryable_error(classified_error):
-                    if self._metrics_collector:
-                        self._metrics_collector.record_operation(
-                            operation_name,
-                            timeout_seconds * 1000,
-                            False,
-                            len(self._connection_pool),
-                        )
+                # For retryable errors (locked/busy), re-raise the ORIGINAL error
+                # so tenacity can retry. Only classify non-retryable errors.
+                if "locked" in error_msg or "busy" in error_msg:
+                    logger.debug(
+                        f"[{operation_name}] Retryable error, will retry: {e}"
+                    )
+                    raise  # Let tenacity retry this
 
+                # Non-retryable OperationalError - classify and raise
+                logger.warning(
+                    f"[{operation_name}] Non-retryable OperationalError: {e}"
+                )
+                classified_error = classify_sqlite_error(e, operation_name)
+                if self._metrics_collector:
+                    self._metrics_collector.record_operation(
+                        operation_name,
+                        timeout_seconds * 1000,
+                        False,
+                        len(self._connection_pool),
+                    )
                 raise classified_error
 
+            except asyncio.TimeoutError as e:
+                elapsed = time.monotonic() - start_time
+                logger.warning(
+                    f"[{operation_name}] Timeout after {elapsed*1000:.1f}ms "
+                    f"waiting for database lock (timeout={timeout_seconds}s)"
+                )
+                if self._metrics_collector:
+                    self._metrics_collector.record_locking_event(
+                        operation_name, "timeout waiting for lock"
+                    )
+                # Re-raise as OperationalError so tenacity can retry
+                raise aiosqlite.OperationalError(
+                    f"Timeout waiting for database lock: {e}"
+                ) from e
+
         try:
             # Create a temporary retry executor with custom max_retries if different
             # from default
@@ -534,8 +600,27 @@ class DatabaseManager:
                     execute_transaction, operation_name
                 )
 
+        except DatabaseLockError as e:
+            # Retries exhausted - record metrics and convert to DatabaseError
+            if self._metrics_collector:
+                self._metrics_collector.record_operation(
+                    operation_name,
+                    timeout_seconds * 1000,
+                    False,
+                    len(self._connection_pool),
+                )
+            # Convert to a proper DatabaseError for consistent error handling
+            raise DatabaseError(
+                f"Database operation failed after retries: {e.message}",
+                error_context={
+                    "operation": operation_name,
+                    "retry_count": e.retry_count,
+                    "retryable": False,  # Retries already exhausted
+                },
+            ) from e
+
         except DatabaseError:
-            # Record failed operation metrics for final failure
+            # Non-retryable DatabaseError from classification
             if self._metrics_collector:
                 self._metrics_collector.record_operation(
                     operation_name,
@@ -721,7 +806,7 @@ class DatabaseManager:
             cursor = await db.execute("SELECT changes()")
             changes = await cursor.fetchone()
             if changes[0] == 0:
-                raise ValueError(f"Project not found: {project_id}")
+                raise DatabaseError(f"Project not found: {project_id}")
 
             await db.commit()
             logger.debug(f"Set vector_mode={enabled} for project: {project_id}")
@@ -737,12 +822,18 @@ class DatabaseManager:
             projects = []
             for row in rows:
                 aliases = json.loads(row[2]) if row[2] else []
+                created = row[3]
+                last_accessed = row[4]
+                if isinstance(created, str):
+                    created = datetime.fromisoformat(created)
+                if isinstance(last_accessed, str):
+                    last_accessed = datetime.fromisoformat(last_accessed)
                 project = Project(
                     id=row[0],
                     name=row[1],
                     aliases=aliases,
-                    created=row[3],
-                    last_accessed=row[4],
+                    created=created,
+                    last_accessed=last_accessed,
                     vector_mode=bool(row[5]),
                 )
                 projects.append(project)
@@ -760,12 +851,18 @@ class DatabaseManager:
             projects = []
             for row in rows:
                 aliases = json.loads(row[2]) if row[2] else []
+                created = row[3]
+                last_accessed = row[4]
+                if isinstance(created, str):
+                    created = datetime.fromisoformat(created)
+                if isinstance(last_accessed, str):
+                    last_accessed = datetime.fromisoformat(last_accessed)
                 project = Project(
                     id=row[0],
                     name=row[1],
                     aliases=aliases,
-                    created=row[3],
-                    last_accessed=row[4],
+                    created=created,
+                    last_accessed=last_accessed,
                     vector_mode=bool(row[5]),
                 )
                 projects.append(project)
@@ -776,9 +873,7 @@ class DatabaseManager:
 
     async def create_file_description(self, file_desc: FileDescription) -> None:
         """Create or update a file description."""
-        async with self.get_write_connection_with_retry(
-            "create_file_description"
-        ) as db:
+        async def operation(db: aiosqlite.Connection) -> None:
             await db.execute(
                 """
                 INSERT INTO file_descriptions
@@ -806,8 +901,12 @@ class DatabaseManager:
                     file_desc.to_be_cleaned,
                 ),
             )
-            await db.commit()
-            logger.debug(f"Saved file description: {file_desc.file_path}")
+
+        await self.execute_transaction_with_retry(
+            operation,
+            "create_file_description"
+        )
+        logger.debug(f"Saved file description: {file_desc.file_path}")
 
     async def get_file_description(
         self, project_id: str, file_path: str
@@ -1018,7 +1117,7 @@ class DatabaseManager:
 
     async def create_project_overview(self, overview: ProjectOverview) -> None:
         """Create or update a project overview."""
-        async with self.get_write_connection() as db:
+        async def operation(db: aiosqlite.Connection) -> None:
             await db.execute(
                 """
                 INSERT OR REPLACE INTO project_overviews
@@ -1033,8 +1132,12 @@ class DatabaseManager:
                     overview.total_tokens,
                 ),
             )
-            await db.commit()
-            logger.debug(f"Created/updated overview for project {overview.project_id}")
+
+        await self.execute_transaction_with_retry(
+            operation,
+            "create_project_overview"
+        )
+        logger.debug(f"Created/updated overview for project {overview.project_id}")
 
     async def get_project_overview(self, project_id: str) -> Optional[ProjectOverview]:
         """Get project overview by ID."""
@@ -1373,7 +1476,7 @@ class DatabaseManager:
             cursor = await db.execute("SELECT changes()")
             changes = await cursor.fetchone()
             if changes[0] == 0:
-                raise ValueError(
+                raise DatabaseError(
                     f"Index metadata not found for project: {index_meta.project_id}"
                 )
 

{mcp_code_indexer-4.2.16 → mcp_code_indexer-4.2.18}/src/mcp_code_indexer/database/database_factory.py

@@ -28,7 +28,7 @@ class DatabaseFactory:
         global_db_path: Path,
         pool_size: int = 3,
         retry_count: int = 5,
-        timeout: float = 10.0,
+        timeout: float = 30.0,
         enable_wal_mode: bool = True,
         health_check_interval: float = 30.0,
         retry_min_wait: float = 0.1,

{mcp_code_indexer-4.2.16 → mcp_code_indexer-4.2.18}/src/mcp_code_indexer/database/exceptions.py

@@ -236,7 +236,7 @@ def classify_sqlite_error(error: Exception, operation_name: str = "") -> Databas
         for msg in [
             "no such table",
             "no such column",
-            "table already exists",
+            "already exists",
             "syntax error",
         ]
     ):

{mcp_code_indexer-4.2.16 → mcp_code_indexer-4.2.18}/src/mcp_code_indexer/logging_config.py

@@ -81,22 +81,29 @@ def setup_logging(
             root_logger.warning(f"Failed to set up file logging: {e}")
 
     # Configure specific loggers
+    effective_level = getattr(logging, log_level.upper())
 
-    # Quiet down noisy libraries
+    # Quiet down noisy libraries (always WARNING+)
     logging.getLogger("aiosqlite").setLevel(logging.WARNING)
     logging.getLogger("tiktoken").setLevel(logging.WARNING)
 
-    # MCP specific loggers
+    # MCP specific loggers - respect the configured log level
     mcp_logger = logging.getLogger("mcp")
-    mcp_logger.setLevel(logging.INFO)
+    mcp_logger.setLevel(effective_level)
 
-    # Database logger
-    db_logger = logging.getLogger("src.database")
-    db_logger.setLevel(logging.INFO)
+    # Database logger - respect the configured log level
+    db_logger = logging.getLogger("mcp_code_indexer.database")
+    db_logger.setLevel(effective_level)
 
-    # Server logger
-    server_logger = logging.getLogger("src.server")
-    server_logger.setLevel(logging.INFO)
+    # Also set the old logger names for backwards compatibility
+    logging.getLogger("src.database").setLevel(effective_level)
+
+    # Server logger - respect the configured log level
+    server_logger = logging.getLogger("mcp_code_indexer.server")
+    server_logger.setLevel(effective_level)
+
+    # Also set the old logger names for backwards compatibility  
+    logging.getLogger("src.server").setLevel(effective_level)
 
     return root_logger
 

{mcp_code_indexer-4.2.16 → mcp_code_indexer-4.2.18}/src/mcp_code_indexer/server/mcp_server.py

@@ -13,7 +13,7 @@ import random
 import re
 import time
 import uuid
-from datetime import datetime
+from datetime import datetime, timedelta
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Callable, cast
 
@@ -56,7 +56,7 @@ class MCPCodeIndexServer:
         cache_dir: Optional[Path] = None,
         db_pool_size: int = 3,
         db_retry_count: int = 5,
-        db_timeout: float = 10.0,
+        db_timeout: float = 30.0,
         enable_wal_mode: bool = True,
         health_check_interval: float = 30.0,
         retry_min_wait: float = 0.1,
@@ -882,8 +882,11 @@ class MCPCodeIndexServer:
             all_projects = await db_manager.get_all_projects()
             if all_projects:
                 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)
+
+                # Update last accessed time only if older than 5 minutes
+                if datetime.utcnow() - project.last_accessed > timedelta(minutes=5):
+                    await db_manager.update_project_access_time(project.id)
+
                 logger.info(
                     f"Using existing local project: {project.name} (ID: {project.id})"
                 )
@@ -1040,8 +1043,9 @@ class MCPCodeIndexServer:
         db_manager: DatabaseManager,
     ) -> None:
         """Update an existing project with new metadata and folder alias."""
-        # Update last accessed time
-        await db_manager.update_project_access_time(project.id)
+        # Update last accessed time only if older than 5 minutes
+        if datetime.utcnow() - project.last_accessed > timedelta(minutes=5):
+            await db_manager.update_project_access_time(project.id)
 
         should_update = False