mcp-code-indexer 4.2.17__py3-none-any.whl → 4.2.19__py3-none-any.whl

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,27 +407,45 @@ 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:
+            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
+                    conn.execute("BEGIN IMMEDIATE"), timeout=actual_timeout
+                )
+                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(
                     (
-                        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,
                             }
                         }
                     },
@@ -444,7 +462,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
@@ -459,7 +477,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
@@ -473,20 +492,42 @@ 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."""
+            import time
+            start_time = time.monotonic()
+            logger.debug(
+                f"[{operation_name}] Starting transaction "
+                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(
+                        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,
-                        timeout_seconds * 1000,  # Convert to ms
+                        actual_timeout * 1000,  # Convert to ms
                         True,
                         len(self._connection_pool),
                     )
@@ -494,29 +535,42 @@ class DatabaseManager:
                 return result
 
             except aiosqlite.OperationalError as e:
-                # Record locking event for metrics
+                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))
 
                 # 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,
+                        actual_timeout * 1000,
                         False,
                         len(self._connection_pool),
                     )
                 raise classified_error
 
             except asyncio.TimeoutError as e:
-                # Timeout on BEGIN IMMEDIATE - this is retryable
+                elapsed = time.monotonic() - start_time
+                logger.warning(
+                    f"[{operation_name}] Timeout after {elapsed*1000:.1f}ms "
+                    f"waiting for database lock (timeout={actual_timeout}s)"
+                )
                 if self._metrics_collector:
                     self._metrics_collector.record_locking_event(
                         operation_name, "timeout waiting for lock"
@@ -555,7 +609,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),
                 )
@@ -574,7 +628,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),
                 )

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/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/server/mcp_server.py

@@ -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:
@@ -1164,17 +1164,22 @@ class MCPCodeIndexServer:
         # Use provided token limit or fall back to server default
         token_limit = arguments.get("tokenLimit", self.token_limit)
 
-        # Calculate total tokens for descriptions
+        # Calculate total tokens for descriptions (offload to executor to avoid blocking)
         logger.info("Calculating total token count...")
-        descriptions_tokens = self.token_counter.calculate_codebase_tokens(
+        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
@@ -1242,7 +1247,7 @@ class MCPCodeIndexServer:
         # Scan directory for files
         logger.info(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,7 +1255,7 @@ 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")
@@ -1268,8 +1273,9 @@ class MCPCodeIndexServer:
             missing_paths = missing_paths[:limit]
             logger.info(f"Applied limit {limit}, returning {len(missing_paths)} files")
 
-        # Get project stats
-        stats = scanner.get_project_stats()
+        # 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.info(f"Project stats: {stats.get('total_files', 0)} total files")
 
         return {
@@ -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(

{mcp_code_indexer-4.2.17.dist-info → mcp_code_indexer-4.2.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-code-indexer
-Version: 4.2.17
+Version: 4.2.19
 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?64)](https://badge.fury.io/py/mcp-code-indexer)
-[![Python](https://img.shields.io/pypi/pyversions/mcp-code-indexer.svg?64)](https://pypi.org/project/mcp-code-indexer/)
+[![PyPI version](https://badge.fury.io/py/mcp-code-indexer.svg?66)](https://badge.fury.io/py/mcp-code-indexer)
+[![Python](https://img.shields.io/pypi/pyversions/mcp-code-indexer.svg?66)](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.17.dist-info → mcp_code_indexer-4.2.19.dist-info}/RECORD

@@ -8,7 +8,7 @@ mcp_code_indexer/commands/makelocal.py,sha256=T_44so96jcs1FNlft9E3nAq0LlOzQLhjLd
 mcp_code_indexer/data/stop_words_english.txt,sha256=feRGP8WG5hQPo-wZN5ralJiSv1CGw4h3010NBJnJ0Z8,6344
 mcp_code_indexer/database/__init__.py,sha256=aPq_aaRp0aSwOBIq9GkuMNjmLxA411zg2vhdrAuHm-w,38
 mcp_code_indexer/database/connection_health.py,sha256=jZr3tCbfjUJujdXe_uxtm1N4c31dMV4euiSY4ulamOE,25497
-mcp_code_indexer/database/database.py,sha256=GcXI6p99E4_fo9oMbbZXHIMpYm4Z7y2TdQJgSnZNvMI,57986
+mcp_code_indexer/database/database.py,sha256=Dp2gArUXAY8q2agzj4QQlF-ZtdT0TRbHpGspZDI1jHg,60619
 mcp_code_indexer/database/database_factory.py,sha256=VMw0tlutGgZoTI7Q_PCuFy5zAimq2xuMtDFAlF_FKtc,4316
 mcp_code_indexer/database/exceptions.py,sha256=zciu7fDwF8y0Z4tkzTBFPPvXCvdnEJiA-Wd-cBLZBWw,10473
 mcp_code_indexer/database/models.py,sha256=w1U9zMGNt0LQeCiifYeXKW_Cia9BKV5uPChbOve-FZY,13467
@@ -16,9 +16,9 @@ mcp_code_indexer/database/path_resolver.py,sha256=1Ubx6Ly5F2dnvhbdN3tqyowBHslABX
 mcp_code_indexer/database/retry_executor.py,sha256=r7eKn_xDc6hKz9qs9z9Dg8gyq4uZgnyrgFmQFTyDhdo,14409
 mcp_code_indexer/deepask_handler.py,sha256=qI9h_Me5WQAbt3hzzDG8XDBMZlnvx-I9R7OsmO_o8aA,18497
 mcp_code_indexer/error_handler.py,sha256=ylciEM-cR7E8Gmd8cfh5olcllJm0FnaYBGH86yayFic,12530
-mcp_code_indexer/file_scanner.py,sha256=OCLnzPTneIiMtGcV3NB5qvnZrO3zxCqPEZXtCk75dfA,15178
+mcp_code_indexer/file_scanner.py,sha256=r8WR1Or1pbB63PmUIno5XYwBrmYg9xr37Ef6zmtt4yQ,15538
 mcp_code_indexer/git_hook_handler.py,sha256=sTtZV3-Yy1Evt06R5NZclELeepM4Ia9OQoR2O6BK3Hk,45517
-mcp_code_indexer/logging_config.py,sha256=M5eVZ5PwfTROib7ISTQ522n2hUSc4hJ_wUgsrJKsTTg,10030
+mcp_code_indexer/logging_config.py,sha256=NNB5iKCc-Hdognf-UdjuEKB9H_e4UIp3QTVnf69Rc2k,10504
 mcp_code_indexer/main.py,sha256=byM0Y9EwDa0616dEkx2p_1rUdJmDNeKAG41o5_AJago,41084
 mcp_code_indexer/middleware/__init__.py,sha256=UCEPzOlZldlqFzYEfrXw1HvCDvY1jpLvyaDGUzVr2aw,368
 mcp_code_indexer/middleware/auth.py,sha256=4HkHMDZBNsyPA1VE8qF7pRNKbqG4xIDZjllENbgynxI,7258
@@ -33,7 +33,7 @@ mcp_code_indexer/migrations/005_remove_git_remotes.sql,sha256=vT84AaV1hyN4zq5W67
 mcp_code_indexer/migrations/006_vector_mode.sql,sha256=kN-UBPGoagqtpxpGEjdz-V3hevPAXxAdNmxF4iIPsY8,7448
 mcp_code_indexer/query_preprocessor.py,sha256=vi23sK2ffs4T5PGY7lHrbCBDL421AlPz2dldqX_3JKA,5491
 mcp_code_indexer/server/__init__.py,sha256=16xMcuriUOBlawRqWNBk6niwrvtv_JD5xvI36X1Vsmk,41
-mcp_code_indexer/server/mcp_server.py,sha256=nkm7R_lOnD_XDxk1mEiZgrT6D-G-QIt0g34VHNb1p5g,84424
+mcp_code_indexer/server/mcp_server.py,sha256=hALcOMxPBD0BD3Zpyfb8ifFXS2y2eoGWJ10foDde8R8,85114
 mcp_code_indexer/tiktoken_cache/9b5ad71b2ce5302211f9c61530b329a4922fc6a4,sha256=Ijkht27pm96ZW3_3OFE-7xAPtR0YyTWXoRO8_-hlsqc,1681126
 mcp_code_indexer/token_counter.py,sha256=e6WsyCEWMMSkMwLbcVtr5e8vEqh-kFqNmiJErCNdqHE,8220
 mcp_code_indexer/tools/__init__.py,sha256=m01mxML2UdD7y5rih_XNhNSCMzQTz7WQ_T1TeOcYlnE,49
@@ -65,8 +65,8 @@ mcp_code_indexer/vector_mode/services/vector_mode_tools_service.py,sha256=K1_STy
 mcp_code_indexer/vector_mode/services/vector_storage_service.py,sha256=JI3VUc2mG8xZ_YqOvfKJivuMi4imeBLr2UFVrWgDWhk,21193
 mcp_code_indexer/vector_mode/types.py,sha256=M4lUF43FzjiVUezoRqozx_u0g1-xrX9qcRcRn-u65yw,1222
 mcp_code_indexer/vector_mode/utils.py,sha256=XtHrpOw0QJ0EjdzJ85jrbkmHy8Slkq_t7hz-q4RP-10,1283
-mcp_code_indexer-4.2.17.dist-info/METADATA,sha256=hlxYys7f-3mK2L00ZbP7UHyVxBa5AQO1xDw8t5HZ3jo,27689
-mcp_code_indexer-4.2.17.dist-info/WHEEL,sha256=kJCRJT_g0adfAJzTx2GUMmS80rTJIVHRCfG0DQgLq3o,88
-mcp_code_indexer-4.2.17.dist-info/entry_points.txt,sha256=UABj7HZ0mC6rvF22gxaz2LLNLGQShTrFmp5u00iUtvo,67
-mcp_code_indexer-4.2.17.dist-info/licenses/LICENSE,sha256=JN9dyPPgYwH9C-UjYM7FLNZjQ6BF7kAzpF3_4PwY4rY,1086
-mcp_code_indexer-4.2.17.dist-info/RECORD,,
+mcp_code_indexer-4.2.19.dist-info/METADATA,sha256=9_qVYC29iCTLIuAV_uLVB4vbq6HEU_ZCo3vdaKZyQ78,27689
+mcp_code_indexer-4.2.19.dist-info/WHEEL,sha256=kJCRJT_g0adfAJzTx2GUMmS80rTJIVHRCfG0DQgLq3o,88
+mcp_code_indexer-4.2.19.dist-info/entry_points.txt,sha256=UABj7HZ0mC6rvF22gxaz2LLNLGQShTrFmp5u00iUtvo,67
+mcp_code_indexer-4.2.19.dist-info/licenses/LICENSE,sha256=JN9dyPPgYwH9C-UjYM7FLNZjQ6BF7kAzpF3_4PwY4rY,1086
+mcp_code_indexer-4.2.19.dist-info/RECORD,,