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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-code-indexer
-Version: 4.2.18
+Version: 4.2.20
 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?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/)
+[![PyPI version](https://badge.fury.io/py/mcp-code-indexer.svg?67)](https://badge.fury.io/py/mcp-code-indexer)
+[![Python](https://img.shields.io/pypi/pyversions/mcp-code-indexer.svg?67)](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.18 → mcp_code_indexer-4.2.20}/README.md

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

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

@@ -51,10 +51,8 @@ class CleanupManager:
         """
         cleanup_timestamp = int(time.time())
 
-        async with self.db_manager.get_write_connection_with_retry(
-            "mark_file_for_cleanup"
-        ) as db:
-            cursor = await db.execute(
+        async def operation(conn: Any) -> bool:
+            cursor = await conn.execute(
                 """
                 UPDATE file_descriptions
                 SET to_be_cleaned = ?
@@ -62,11 +60,13 @@ class CleanupManager:
                 """,
                 (cleanup_timestamp, project_id, file_path),
             )
-            await db.commit()
-
             # Check if any rows were affected
             return cursor.rowcount > 0
 
+        return await self.db_manager.execute_transaction_with_retry(
+            operation, "mark_file_for_cleanup"
+        )
+
     async def mark_files_for_cleanup(
         self, project_id: str, file_paths: List[str]
     ) -> int:
@@ -117,10 +117,8 @@ class CleanupManager:
         Returns:
             True if file was restored, False if file not found
         """
-        async with self.db_manager.get_write_connection_with_retry(
-            "restore_file_from_cleanup"
-        ) as db:
-            cursor = await db.execute(
+        async def operation(conn: Any) -> bool:
+            cursor = await conn.execute(
                 """
                 UPDATE file_descriptions
                 SET to_be_cleaned = NULL
@@ -128,10 +126,12 @@ class CleanupManager:
                 """,
                 (project_id, file_path),
             )
-            await db.commit()
-
             return cursor.rowcount > 0
 
+        return await self.db_manager.execute_transaction_with_retry(
+            operation, "restore_file_from_cleanup"
+        )
+
     async def get_files_to_be_cleaned(self, project_id: str) -> List[dict]:
         """
         Get list of files marked for cleanup in a project.

{mcp_code_indexer-4.2.18 → mcp_code_indexer-4.2.20}/src/mcp_code_indexer/database/database.py

@@ -396,7 +396,7 @@ class DatabaseManager:
     async def get_immediate_transaction(
         self,
         operation_name: str = "immediate_transaction",
-        timeout_seconds: float = 10.0,
+        timeout_seconds: Optional[float] = None,
     ) -> AsyncIterator[aiosqlite.Connection]:
         """
         Get a database connection with BEGIN IMMEDIATE transaction and
@@ -407,8 +407,10 @@ class DatabaseManager:
 
         Args:
             operation_name: Name of the operation for monitoring
-            timeout_seconds: Transaction timeout in seconds
+            timeout_seconds: Transaction timeout in seconds (defaults to
+                self.timeout if None)
         """
+        actual_timeout = timeout_seconds if timeout_seconds is not None else self.timeout
         import time
         acquire_start = time.monotonic()
         async with self.get_write_connection_with_retry(operation_name) as conn:
@@ -420,7 +422,7 @@ class DatabaseManager:
                 # Start immediate transaction with timeout
                 begin_start = time.monotonic()
                 await asyncio.wait_for(
-                    conn.execute("BEGIN IMMEDIATE"), timeout=timeout_seconds
+                    conn.execute("BEGIN IMMEDIATE"), timeout=actual_timeout
                 )
                 begin_time = time.monotonic() - begin_start
                 logger.debug(
@@ -436,23 +438,35 @@ class DatabaseManager:
             except asyncio.TimeoutError:
                 logger.warning(
                     (
-                        f"Transaction timeout after {timeout_seconds}s for "
+                        f"Transaction timeout after {actual_timeout}s for "
                         f"{operation_name}"
                     ),
                     extra={
                         "structured_data": {
                             "transaction_timeout": {
                                 "operation": operation_name,
-                                "timeout_seconds": timeout_seconds,
+                                "timeout_seconds": actual_timeout,
                             }
                         }
                     },
                 )
-                await conn.rollback()
+                # Shield rollback from cancellation to prevent leaked transactions
+                await asyncio.shield(conn.rollback())
                 raise
-            except Exception as e:
-                logger.error(f"Transaction failed for {operation_name}: {e}")
-                await conn.rollback()
+            except BaseException as e:
+                # Catch BaseException to handle asyncio.CancelledError and ensure
+                # proper rollback on task cancellation. Shield the rollback to
+                # prevent cancellation from interrupting cleanup.
+                if isinstance(e, asyncio.CancelledError):
+                    logger.warning(f"Transaction cancelled for {operation_name}")
+                else:
+                    logger.error(f"Transaction failed for {operation_name}: {e}")
+                try:
+                    await asyncio.shield(conn.rollback())
+                except Exception as rollback_error:
+                    logger.error(
+                        f"Rollback failed for {operation_name}: {rollback_error}"
+                    )
                 raise
 
     async def execute_transaction_with_retry(
@@ -460,7 +474,7 @@ class DatabaseManager:
         operation_func: Callable[[aiosqlite.Connection], Any],
         operation_name: str = "transaction_operation",
         max_retries: int = 3,
-        timeout_seconds: float = 10.0,
+        timeout_seconds: Optional[float] = None,
     ) -> Any:
         """
         Execute a database operation within a transaction with automatic
@@ -475,7 +489,8 @@ class DatabaseManager:
             operation_name: Name of the operation for logging
             max_retries: Maximum retry attempts (overrides default retry
                 executor config)
-            timeout_seconds: Transaction timeout in seconds
+            timeout_seconds: Transaction timeout in seconds (defaults to
+                self.timeout if None)
 
         Returns:
             Result from operation_func
@@ -489,6 +504,7 @@ class DatabaseManager:
                 my_operation, "insert_data"
             )
         """
+        actual_timeout = timeout_seconds if timeout_seconds is not None else self.timeout
 
         async def execute_transaction() -> Any:
             """Inner function to execute transaction - retried by executor."""
@@ -496,11 +512,11 @@ class DatabaseManager:
             start_time = time.monotonic()
             logger.debug(
                 f"[{operation_name}] Starting transaction "
-                f"(timeout={timeout_seconds}s, pool_size={len(self._connection_pool)})"
+                f"(timeout={actual_timeout}s, pool_size={len(self._connection_pool)})"
             )
             try:
                 async with self.get_immediate_transaction(
-                    operation_name, timeout_seconds
+                    operation_name, actual_timeout
                 ) as conn:
                     lock_acquired_time = time.monotonic()
                     logger.debug(
@@ -523,7 +539,7 @@ class DatabaseManager:
                 if self._metrics_collector:
                     self._metrics_collector.record_operation(
                         operation_name,
-                        timeout_seconds * 1000,  # Convert to ms
+                        actual_timeout * 1000,  # Convert to ms
                         True,
                         len(self._connection_pool),
                     )
@@ -555,7 +571,7 @@ class DatabaseManager:
                 if self._metrics_collector:
                     self._metrics_collector.record_operation(
                         operation_name,
-                        timeout_seconds * 1000,
+                        actual_timeout * 1000,
                         False,
                         len(self._connection_pool),
                     )
@@ -565,7 +581,7 @@ class DatabaseManager:
                 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)"
+                    f"waiting for database lock (timeout={actual_timeout}s)"
                 )
                 if self._metrics_collector:
                     self._metrics_collector.record_locking_event(
@@ -605,7 +621,7 @@ class DatabaseManager:
             if self._metrics_collector:
                 self._metrics_collector.record_operation(
                     operation_name,
-                    timeout_seconds * 1000,
+                    actual_timeout * 1000,
                     False,
                     len(self._connection_pool),
                 )
@@ -624,7 +640,7 @@ class DatabaseManager:
             if self._metrics_collector:
                 self._metrics_collector.record_operation(
                     operation_name,
-                    timeout_seconds * 1000,
+                    actual_timeout * 1000,
                     False,
                     len(self._connection_pool),
                 )
@@ -634,8 +650,8 @@ class DatabaseManager:
 
     async def create_project(self, project: Project) -> None:
         """Create a new project record."""
-        async with self.get_write_connection_with_retry("create_project") as db:
-            await db.execute(
+        async def operation(conn: aiosqlite.Connection) -> None:
+            await conn.execute(
                 """
                 INSERT INTO projects (id, name, aliases, created, last_accessed)
                 VALUES (?, ?, ?, ?, ?)
@@ -648,8 +664,9 @@ class DatabaseManager:
                     project.last_accessed,
                 ),
             )
-            await db.commit()
-            logger.debug(f"Created project: {project.id}")
+
+        await self.execute_transaction_with_retry(operation, "create_project")
+        logger.debug(f"Created project: {project.id}")
 
     async def get_project(self, project_id: str) -> Optional[Project]:
         """Get project by ID."""
@@ -764,19 +781,20 @@ class DatabaseManager:
 
     async def update_project_access_time(self, project_id: str) -> None:
         """Update the last accessed time for a project."""
-        async with self.get_write_connection_with_retry(
-            "update_project_access_time"
-        ) as db:
-            await db.execute(
+        async def operation(conn: aiosqlite.Connection) -> None:
+            await conn.execute(
                 "UPDATE projects SET last_accessed = ? WHERE id = ?",
                 (datetime.utcnow(), project_id),
             )
-            await db.commit()
+
+        await self.execute_transaction_with_retry(
+            operation, "update_project_access_time"
+        )
 
     async def update_project(self, project: Project) -> None:
         """Update an existing project record."""
-        async with self.get_write_connection_with_retry("update_project") as db:
-            await db.execute(
+        async def operation(conn: aiosqlite.Connection) -> None:
+            await conn.execute(
                 """
                 UPDATE projects
                 SET name = ?, aliases = ?, last_accessed = ?
@@ -789,27 +807,28 @@ class DatabaseManager:
                     project.id,
                 ),
             )
-            await db.commit()
-            logger.debug(f"Updated project: {project.id}")
+
+        await self.execute_transaction_with_retry(operation, "update_project")
+        logger.debug(f"Updated project: {project.id}")
 
     async def set_project_vector_mode(self, project_id: str, enabled: bool) -> None:
         """Set the vector_mode for a specific project."""
-        async with self.get_write_connection_with_retry(
-            "set_project_vector_mode"
-        ) as db:
-            await db.execute(
+        async def operation(conn: aiosqlite.Connection) -> None:
+            await conn.execute(
                 "UPDATE projects SET vector_mode = ? WHERE id = ?",
                 (int(enabled), project_id),
             )
 
             # Check if the project was actually updated
-            cursor = await db.execute("SELECT changes()")
+            cursor = await conn.execute("SELECT changes()")
             changes = await cursor.fetchone()
             if changes[0] == 0:
                 raise DatabaseError(f"Project not found: {project_id}")
 
-            await db.commit()
-            logger.debug(f"Set vector_mode={enabled} for project: {project_id}")
+        await self.execute_transaction_with_retry(
+            operation, "set_project_vector_mode"
+        )
+        logger.debug(f"Set vector_mode={enabled} for project: {project_id}")
 
     async def get_all_projects(self) -> List[Project]:
         """Get all projects in the database."""
@@ -1080,23 +1099,25 @@ class DatabaseManager:
         """Cache token count with TTL."""
         expires = datetime.utcnow() + timedelta(hours=ttl_hours)
 
-        async with self.get_write_connection() as db:
-            await db.execute(
+        async def operation(conn: aiosqlite.Connection) -> None:
+            await conn.execute(
                 """
                 INSERT OR REPLACE INTO token_cache (cache_key, token_count, expires)
                 VALUES (?, ?, ?)
                 """,
                 (cache_key, token_count, expires),
             )
-            await db.commit()
+
+        await self.execute_transaction_with_retry(operation, "cache_token_count")
 
     async def cleanup_expired_cache(self) -> None:
         """Remove expired cache entries."""
-        async with self.get_write_connection() as db:
-            await db.execute(
+        async def operation(conn: aiosqlite.Connection) -> None:
+            await conn.execute(
                 "DELETE FROM token_cache WHERE expires < ?", (datetime.utcnow(),)
             )
-            await db.commit()
+
+        await self.execute_transaction_with_retry(operation, "cleanup_expired_cache")
 
     # Utility operations
 
@@ -1316,9 +1337,9 @@ class DatabaseManager:
         Returns:
             Number of projects removed
         """
-        async with self.get_write_connection() as db:
+        async def operation(conn: aiosqlite.Connection) -> int:
             # Find projects with no descriptions and no overview
-            cursor = await db.execute(
+            cursor = await conn.execute(
                 """
                 SELECT p.id, p.name
                 FROM projects p
@@ -1339,14 +1360,17 @@ class DatabaseManager:
                 project_name = project["name"]
 
                 # Remove from projects table (cascading will handle related data)
-                await db.execute("DELETE FROM projects WHERE id = ?", (project_id,))
+                await conn.execute("DELETE FROM projects WHERE id = ?", (project_id,))
                 removed_count += 1
 
                 logger.info(f"Removed empty project: {project_name} (ID: {project_id})")
 
-            await db.commit()
             return removed_count
 
+        return await self.execute_transaction_with_retry(
+            operation, "cleanup_empty_projects"
+        )
+
     async def get_project_map_data(
         self, project_identifier: str
     ) -> Optional[Dict[str, Any]]:

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

@@ -191,6 +191,7 @@ def classify_sqlite_error(error: Exception, operation_name: str = "") -> Databas
             "database is locked",
             "sqlite_locked",
             "attempt to write a readonly database",
+            "timeout waiting for database lock",
         ]
     ):
         lock_type = (
@@ -297,6 +298,7 @@ def is_retryable_error(error: Exception) -> bool:
         "sqlite_busy",
         "sqlite_locked",
         "cannot start a transaction within a transaction",
+        "timeout waiting for database lock",
     ]
 
     return any(pattern in error_message for pattern in retryable_patterns)

{mcp_code_indexer-4.2.18 → mcp_code_indexer-4.2.20}/src/mcp_code_indexer/database/retry_executor.py

@@ -354,6 +354,7 @@ class RetryExecutor:
             "cannot start a transaction within a transaction",
             "sqlite_busy",
             "sqlite_locked",
+            "timeout waiting for database lock",
         ]
 
         return any(msg in error_message for msg in retryable_messages)

{mcp_code_indexer-4.2.18 → mcp_code_indexer-4.2.20}/src/mcp_code_indexer/file_scanner.py

@@ -499,3 +499,13 @@ class FileScanner:
         """
         loop = asyncio.get_running_loop()
         return await loop.run_in_executor(None, self.find_missing_files, existing_paths)
+
+    async def is_valid_project_directory_async(self) -> bool:
+        """
+        Async version of is_valid_project_directory running in a thread.
+
+        Returns:
+            True if the directory exists and is accessible
+        """
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(None, self.is_valid_project_directory)

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

@@ -34,16 +34,21 @@ def setup_logging(
     Returns:
         Configured root logger
     """
-    # Get root logger
+    # Get root logger - set to DEBUG so all logs reach handlers.
+    # Each handler filters to its own level.
     root_logger = logging.getLogger()
-    root_logger.setLevel(getattr(logging, log_level.upper()))
+    root_logger.setLevel(logging.DEBUG)
 
     # Clear existing handlers
     root_logger.handlers.clear()
 
     # Console handler (stderr to avoid interfering with MCP stdout)
     console_handler = logging.StreamHandler(sys.stderr)
-    console_handler.setLevel(getattr(logging, log_level.upper()))
+    # Force console logging to at least WARNING to prevent stderr buffer blocking
+    # when MCP clients don't consume stderr fast enough. File logging captures
+    # everything (DEBUG+) for detailed diagnostics.
+    requested_level = getattr(logging, log_level.upper())
+    console_handler.setLevel(max(requested_level, logging.WARNING))
 
     # Use structured formatter for all handlers
     structured_formatter = StructuredFormatter()

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

@@ -240,10 +240,10 @@ class MCPCodeIndexServer:
             try:
                 result = json.loads(repaired)
                 if isinstance(result, dict):
-                    logger.info(
+                    logger.debug(
                         f"Successfully repaired JSON. Original: {json_str[:100]}..."
                     )
-                    logger.info(f"Repaired: {repaired[:100]}...")
+                    logger.debug(f"Repaired: {repaired[:100]}...")
                     return result
                 else:
                     raise ValueError(
@@ -793,8 +793,8 @@ class MCPCodeIndexServer:
 
             start_time = time.time()
 
-            logger.info(f"=== MCP Tool Call: {name} ===")
-            logger.info(f"Arguments: {', '.join(arguments.keys())}")
+            logger.debug(f"=== MCP Tool Call: {name} ===")
+            logger.debug(f"Arguments: {', '.join(arguments.keys())}")
 
             # Map tool names to handler methods
             tool_handlers = {
@@ -828,7 +828,7 @@ class MCPCodeIndexServer:
                 result = await wrapped_handler(arguments)
 
                 elapsed_time = time.time() - start_time
-                logger.info(
+                logger.debug(
                     f"MCP Tool '{name}' completed successfully in {elapsed_time:.2f}s"
                 )
 
@@ -887,7 +887,7 @@ class MCPCodeIndexServer:
                 if datetime.utcnow() - project.last_accessed > timedelta(minutes=5):
                     await db_manager.update_project_access_time(project.id)
 
-                logger.info(
+                logger.debug(
                     f"Using existing local project: {project.name} (ID: {project.id})"
                 )
                 return project.id
@@ -904,7 +904,7 @@ class MCPCodeIndexServer:
                     last_accessed=datetime.utcnow(),
                 )
                 await db_manager.create_project(project)
-                logger.info(
+                logger.debug(
                     f"Created new local project: {project_name} (ID: {project_id})"
                 )
                 return project_id
@@ -932,7 +932,7 @@ class MCPCodeIndexServer:
                     last_accessed=datetime.utcnow(),
                 )
                 await db_manager.create_project(project)
-                logger.info(
+                logger.debug(
                     f"Created new global project: {normalized_name} (ID: {project_id})"
                 )
 
@@ -975,7 +975,7 @@ class MCPCodeIndexServer:
                 if score > best_score:
                     best_score = score
                     best_match = project
-                    logger.info(
+                    logger.debug(
                         f"Match for project {project.name} "
                         f"(score: {score}, factors: {match_factors})"
                     )
@@ -983,7 +983,7 @@ class MCPCodeIndexServer:
             # If only name matches, check file similarity for potential matches
             elif score == 1 and "name" in match_factors:
                 if await self._check_file_similarity(project, folder_path):
-                    logger.info(
+                    logger.debug(
                         f"File similarity match for project {project.name} "
                         f"(factor: {match_factors[0]})"
                     )
@@ -1002,10 +1002,10 @@ class MCPCodeIndexServer:
         try:
             # Get files currently in the folder
             scanner = FileScanner(Path(folder_path))
-            if not scanner.is_valid_project_directory():
+            if not await scanner.is_valid_project_directory_async():
                 return False
 
-            current_files = scanner.scan_directory()
+            current_files = await scanner.scan_directory_async()
             current_basenames = {f.name for f in current_files}
 
             if not current_basenames:
@@ -1060,7 +1060,7 @@ class MCPCodeIndexServer:
             project_aliases.append(folder_path)
             project.aliases = project_aliases
             should_update = True
-            logger.info(
+            logger.debug(
                 f"Added new folder alias to project {project.name}: {folder_path}"
             )
 
@@ -1098,17 +1098,17 @@ class MCPCodeIndexServer:
         self, arguments: Dict[str, Any]
     ) -> Dict[str, Any]:
         """Handle update_file_description tool calls."""
-        logger.info(f"Updating file description for: {arguments['filePath']}")
-        logger.info(f"Project: {arguments.get('projectName', 'Unknown')}")
+        logger.debug(f"Updating file description for: {arguments['filePath']}")
+        logger.debug(f"Project: {arguments.get('projectName', 'Unknown')}")
 
         description_length = len(arguments.get("description", ""))
-        logger.info(f"Description length: {description_length} characters")
+        logger.debug(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}")
+        logger.debug(f"Resolved project_id: {project_id}")
 
         file_desc = FileDescription(
             id=None,  # Will be set by database
@@ -1124,7 +1124,7 @@ class MCPCodeIndexServer:
 
         await db_manager.create_file_description(file_desc)
 
-        logger.info(f"Successfully updated description for: {arguments['filePath']}")
+        logger.debug(f"Successfully updated description for: {arguments['filePath']}")
 
         return {
             "success": True,
@@ -1137,17 +1137,17 @@ class MCPCodeIndexServer:
         self, arguments: Dict[str, Any]
     ) -> Dict[str, Any]:
         """Handle check_codebase_size tool calls."""
-        logger.info(
+        logger.debug(
             f"Checking codebase size for: {arguments.get('projectName', 'Unknown')}"
         )
-        logger.info(f"Folder path: {arguments.get('folderPath', 'Unknown')}")
+        logger.debug(f"Folder path: {arguments.get('folderPath', 'Unknown')}")
 
         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)
         folder_path_obj = Path(folder_path)
 
-        logger.info(f"Resolved project_id: {project_id}")
+        logger.debug(f"Resolved project_id: {project_id}")
 
         # Run cleanup if needed (respects 30-minute cooldown)
         cleaned_up_count = await self._run_cleanup_if_needed(
@@ -1155,26 +1155,31 @@ class MCPCodeIndexServer:
         )
 
         # Get file descriptions for this project (after cleanup)
-        logger.info("Retrieving file descriptions...")
+        logger.debug("Retrieving file descriptions...")
         file_descriptions = await db_manager.get_all_file_descriptions(
             project_id=project_id
         )
-        logger.info(f"Found {len(file_descriptions)} file descriptions")
+        logger.debug(f"Found {len(file_descriptions)} file descriptions")
 
         # Use provided token limit or fall back to server default
         token_limit = arguments.get("tokenLimit", self.token_limit)
 
-        # Calculate total tokens for descriptions
-        logger.info("Calculating total token count...")
-        descriptions_tokens = self.token_counter.calculate_codebase_tokens(
+        # Calculate total tokens for descriptions (offload to executor to avoid blocking)
+        logger.debug("Calculating total token count...")
+        loop = asyncio.get_running_loop()
+        descriptions_tokens = await loop.run_in_executor(
+            None,
+            self.token_counter.calculate_codebase_tokens,
             file_descriptions
         )
 
-        # Get overview tokens if available
+        # Get overview tokens if available (offload to executor to avoid blocking)
         overview = await db_manager.get_project_overview(project_id)
         overview_tokens = 0
         if overview and overview.overview:
-            overview_tokens = self.token_counter.count_tokens(overview.overview)
+            overview_tokens = await loop.run_in_executor(
+                None, self.token_counter.count_tokens, overview.overview
+            )
 
         total_tokens = descriptions_tokens + overview_tokens
         is_large = total_tokens > token_limit
@@ -1192,16 +1197,16 @@ class MCPCodeIndexServer:
         else:
             recommendation = "use_search"
 
-        logger.info(
+        logger.debug(
             f"Codebase analysis complete: {total_tokens} tokens total "
             f"({descriptions_tokens} descriptions + {overview_tokens} overview), "
             f"{len(file_descriptions)} files"
         )
-        logger.info(
+        logger.debug(
             f"Size assessment: {'LARGE' if is_large else 'SMALL'} "
             f"(limit: {token_limit})"
         )
-        logger.info(f"Recommendation: {recommendation}")
+        logger.debug(f"Recommendation: {recommendation}")
 
         return {
             "fileDescriptionTokens": descriptions_tokens,
@@ -1218,31 +1223,31 @@ class MCPCodeIndexServer:
         self, arguments: Dict[str, Any]
     ) -> Dict[str, Any]:
         """Handle find_missing_descriptions tool calls."""
-        logger.info(
+        logger.debug(
             f"Finding missing descriptions for: "
             f"{arguments.get('projectName', 'Unknown')}"
         )
-        logger.info(f"Folder path: {arguments.get('folderPath', 'Unknown')}")
+        logger.debug(f"Folder path: {arguments.get('folderPath', 'Unknown')}")
 
         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)
         folder_path_obj = Path(folder_path)
 
-        logger.info(f"Resolved project_id: {project_id}")
+        logger.debug(f"Resolved project_id: {project_id}")
 
         # Get existing file descriptions
-        logger.info("Retrieving existing file descriptions...")
+        logger.debug("Retrieving existing file descriptions...")
         existing_descriptions = await db_manager.get_all_file_descriptions(
             project_id=project_id
         )
         existing_paths = {desc.file_path for desc in existing_descriptions}
-        logger.info(f"Found {len(existing_paths)} existing descriptions")
+        logger.debug(f"Found {len(existing_paths)} existing descriptions")
 
         # Scan directory for files
-        logger.info(f"Scanning project directory: {folder_path_obj}")
+        logger.debug(f"Scanning project directory: {folder_path_obj}")
         scanner = FileScanner(folder_path_obj)
-        if not scanner.is_valid_project_directory():
+        if not await scanner.is_valid_project_directory_async():
             logger.error(
                 f"Invalid or inaccessible project directory: {folder_path_obj}"
             )
@@ -1250,27 +1255,28 @@ class MCPCodeIndexServer:
                 "error": f"Invalid or inaccessible project directory: {folder_path_obj}"
             }
 
-        missing_files = scanner.find_missing_files(existing_paths)
+        missing_files = await scanner.find_missing_files_async(existing_paths)
         missing_paths = [scanner.get_relative_path(f) for f in missing_files]
 
-        logger.info(f"Found {len(missing_paths)} files without descriptions")
+        logger.debug(f"Found {len(missing_paths)} files without descriptions")
 
         # Apply randomization if specified
         randomize = arguments.get("randomize", False)
         if randomize:
             random.shuffle(missing_paths)
-            logger.info("Randomized file order for parallel processing")
+            logger.debug("Randomized file order for parallel processing")
 
         # Apply limit if specified
         limit = arguments.get("limit")
         total_missing = len(missing_paths)
         if limit is not None and isinstance(limit, int) and limit > 0:
             missing_paths = missing_paths[:limit]
-            logger.info(f"Applied limit {limit}, returning {len(missing_paths)} files")
+            logger.debug(f"Applied limit {limit}, returning {len(missing_paths)} files")
 
-        # Get project stats
-        stats = scanner.get_project_stats()
-        logger.info(f"Project stats: {stats.get('total_files', 0)} total files")
+        # Get project stats (offload to executor to avoid blocking)
+        loop = asyncio.get_running_loop()
+        stats = await loop.run_in_executor(None, scanner.get_project_stats)
+        logger.debug(f"Project stats: {stats.get('total_files', 0)} total files")
 
         return {
             "missingFiles": missing_paths,
@@ -1325,8 +1331,13 @@ class MCPCodeIndexServer:
             project_id=project_id
         )
 
-        # Calculate total tokens
-        total_tokens = self.token_counter.calculate_codebase_tokens(file_descriptions)
+        # Calculate total tokens (offload to executor to avoid blocking)
+        loop = asyncio.get_running_loop()
+        total_tokens = await loop.run_in_executor(
+            None,
+            self.token_counter.calculate_codebase_tokens,
+            file_descriptions
+        )
         is_large = self.token_counter.is_large_codebase(total_tokens)
 
         # Always build and return the folder structure - if the AI called this
@@ -1422,7 +1433,12 @@ class MCPCodeIndexServer:
         )
 
         total_files = len(file_descriptions)
-        total_tokens = self.token_counter.calculate_codebase_tokens(file_descriptions)
+        loop = asyncio.get_running_loop()
+        total_tokens = await loop.run_in_executor(
+            None,
+            self.token_counter.calculate_codebase_tokens,
+            file_descriptions
+        )
 
         # Create overview record
         overview = ProjectOverview(
@@ -1630,7 +1646,7 @@ class MCPCodeIndexServer:
             project_name = arguments["projectName"]
             folder_path = arguments["folderPath"]
 
-            logger.info(
+            logger.debug(
                 "Processing find_similar_code request",
                 extra={
                     "structured_data": {