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

mcp_code_indexer/database/retry_executor.py

@@ -10,16 +10,26 @@ import logging
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
-from typing import Any, AsyncIterator, Callable, Dict, Optional, TypeVar
+from typing import (
+    Any,
+    AsyncContextManager,
+    AsyncIterator,
+    Awaitable,
+    Callable,
+    Dict,
+    Optional,
+    TypeVar,
+)
 
 import aiosqlite
 from tenacity import (
     AsyncRetrying,
+    RetryCallState,
     RetryError,
+    after_log,
+    before_sleep_log,
     stop_after_attempt,
     wait_exponential_jitter,
-    before_sleep_log,
-    after_log,
 )
 
 logger = logging.getLogger(__name__)
@@ -100,7 +110,7 @@ class RetryExecutor:
     It replaces the broken async context manager retry pattern.
     """
 
-    def __init__(self, config: Optional[RetryConfig] = None):
+    def __init__(self, config: Optional[RetryConfig] = None) -> None:
         """
         Initialize retry executor.
 
@@ -126,7 +136,9 @@ class RetryExecutor:
         )
 
     async def execute_with_retry(
-        self, operation: Callable[[], T], operation_name: str = "database_operation"
+        self,
+        operation: Callable[[], Awaitable[T]],
+        operation_name: str = "database_operation",
     ) -> T:
         """
         Execute an operation with retry logic.
@@ -198,10 +210,7 @@ class RetryExecutor:
 
             original_error = e.last_attempt.exception()
             logger.error(
-                (
-                    f"Operation '{operation_name}' failed after "
-                    f"{attempt_count} attempts"
-                ),
+                (f"Operation '{operation_name}' failed after {attempt_count} attempts"),
                 extra={
                     "structured_data": {
                         "retry_exhausted": {
@@ -245,10 +254,14 @@ class RetryExecutor:
             # Clean up tracking
             self._operation_start_times.pop(operation_name, None)
 
+        # This should never be reached due to tenacity's retry logic
+        # but MyPy requires it for completeness
+        raise RuntimeError("Unexpected end of retry logic")
+
     @asynccontextmanager
     async def get_connection_with_retry(
         self,
-        connection_factory: Callable[[], AsyncIterator[aiosqlite.Connection]],
+        connection_factory: Callable[[], AsyncContextManager[aiosqlite.Connection]],
         operation_name: str = "database_connection",
     ) -> AsyncIterator[aiosqlite.Connection]:
         """
@@ -267,24 +280,25 @@ class RetryExecutor:
             Database connection
         """
 
-        async def get_connection():
+        async def acquire_connection() -> aiosqlite.Connection:
             # This function will be retried by execute_with_retry
-            async with connection_factory() as conn:
-                # Store connection for the outer context manager
-                return conn
+            # Get the async context manager and enter it
+            ctx_manager = connection_factory()
+            conn = await ctx_manager.__aenter__()
+            return conn
 
         # Use execute_with_retry to handle the retry logic
         # We create a connection and store it for the context manager
-        connection = await self.execute_with_retry(get_connection, operation_name)
+        connection = await self.execute_with_retry(acquire_connection, operation_name)
 
         try:
             yield connection
         finally:
-            # Connection cleanup is handled by the original context manager
-            # in the connection_factory, so nothing to do here
-            pass
+            # Close the connection properly
+            if hasattr(connection, "close"):
+                await connection.close()
 
-    def _should_retry_exception(self, retry_state) -> bool:
+    def _should_retry_exception(self, retry_state: RetryCallState) -> bool:
         """
         Determine if an exception should trigger a retry.
 
@@ -303,6 +317,10 @@ class RetryExecutor:
         if exception is None:
             return False
 
+        # Only retry if it's an Exception (not BaseException)
+        if not isinstance(exception, Exception):
+            return False
+
         return self._is_sqlite_retryable_error(exception)
 
     def _is_sqlite_retryable_error(self, error: Exception) -> bool:

mcp_code_indexer/deepask_handler.py

@@ -9,9 +9,9 @@ Handles enhanced question-answering with two-stage processing:
 
 import logging
 from pathlib import Path
-from typing import Dict, List, Optional, Any
+from typing import Any, Dict, List, Optional
 
-from .claude_api_handler import ClaudeAPIHandler, ClaudeAPIError
+from .claude_api_handler import ClaudeAPIError, ClaudeAPIHandler
 from .database.database import DatabaseManager
 
 
@@ -228,7 +228,7 @@ class DeepAskHandler(ClaudeAPIHandler):
         self.logger.info(f"Search terms: {search_terms}")
 
         # Search for relevant files
-        relevant_files = []
+        relevant_files: List[Dict[str, Any]] = []
         total_files_found = 0
 
         try:

mcp_code_indexer/error_handler.py

@@ -10,7 +10,8 @@ import logging
 import traceback
 from datetime import datetime
 from enum import Enum
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Callable
+from functools import wraps
 
 from mcp import types
 
@@ -146,14 +147,14 @@ class ErrorHandler:
             error_data["tool_name"] = tool_name
 
         if context:
-            error_data["context"] = context
+            error_data["context"] = str(context)
 
         if isinstance(error, MCPError):
             error_data.update(
                 {
                     "category": error.category.value,
-                    "code": error.code,
-                    "details": error.details,
+                    "code": str(error.code),
+                    "details": str(error.details),
                 }
             )
 
@@ -243,11 +244,19 @@ class ErrorHandler:
             if task.done() and not task.cancelled():
                 exception = task.exception()
                 if exception:
-                    self.log_error(
-                        exception,
-                        context={**(context or {}), "task_name": task_name},
-                        tool_name="async_task",
-                    )
+                    # Convert BaseException to Exception for log_error
+                    if isinstance(exception, Exception):
+                        self.log_error(
+                            exception,
+                            context={**(context or {}), "task_name": task_name},
+                            tool_name="async_task",
+                        )
+                    else:
+                        self.log_error(
+                            Exception(str(exception)),
+                            context={**(context or {}), "task_name": task_name},
+                            tool_name="async_task",
+                        )
         except Exception as e:
             self.logger.error(f"Error handling task error for {task_name}: {e}")
 
@@ -258,6 +267,7 @@ class StructuredFormatter(logging.Formatter):
     def format(self, record: logging.LogRecord) -> str:
         """Format log record as structured JSON."""
         import json
+
         from . import __version__
 
         log_data = {
@@ -295,12 +305,21 @@ def setup_error_handling(logger: logging.Logger) -> ErrorHandler:
     error_handler = ErrorHandler(logger)
 
     # Set up asyncio exception handler
-    def asyncio_exception_handler(loop, context):
+    def asyncio_exception_handler(
+        loop: asyncio.AbstractEventLoop, context: Dict[str, Any]
+    ) -> None:
         exception = context.get("exception")
         if exception:
-            error_handler.log_error(
-                exception, context={"asyncio_context": context, "loop": str(loop)}
-            )
+            # Convert BaseException to Exception for log_error
+            if isinstance(exception, Exception):
+                error_handler.log_error(
+                    exception, context={"asyncio_context": context, "loop": str(loop)}
+                )
+            else:
+                error_handler.log_error(
+                    Exception(str(exception)),
+                    context={"asyncio_context": context, "loop": str(loop)},
+                )
         else:
             logger.error(f"Asyncio error: {context}")
 
@@ -318,10 +337,11 @@ def setup_error_handling(logger: logging.Logger) -> ErrorHandler:
 # Decorators for common error handling patterns
 
 
-def handle_database_errors(func):
+def handle_database_errors(func: Callable) -> Callable:
     """Decorator to handle database errors."""
 
-    async def wrapper(*args, **kwargs):
+    @wraps(func)
+    async def wrapper(*args: Any, **kwargs: Any) -> Any:
         try:
             return await func(*args, **kwargs)
         except Exception as e:
@@ -332,10 +352,11 @@ def handle_database_errors(func):
     return wrapper
 
 
-def handle_file_errors(func):
+def handle_file_errors(func: Callable) -> Callable:
     """Decorator to handle file system errors."""
 
-    async def wrapper(*args, **kwargs):
+    @wraps(func)
+    async def wrapper(*args: Any, **kwargs: Any) -> Any:
         try:
             return await func(*args, **kwargs)
         except (FileNotFoundError, PermissionError, OSError) as e:
@@ -346,11 +367,16 @@ def handle_file_errors(func):
     return wrapper
 
 
-def validate_arguments(required_fields: list, optional_fields: list = None):
+def validate_arguments(
+    required_fields: list, optional_fields: Optional[list] = None
+) -> Callable:
     """Decorator to validate tool arguments."""
 
-    def decorator(func):
-        async def wrapper(self, arguments: Dict[str, Any], *args, **kwargs):
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        async def wrapper(
+            self: Any, arguments: Dict[str, Any], *args: Any, **kwargs: Any
+        ) -> Any:
             # Check required fields
             missing_fields = [
                 field for field in required_fields if field not in arguments

mcp_code_indexer/file_scanner.py

@@ -6,10 +6,10 @@ while respecting .gitignore patterns and common ignore patterns. It enables
 efficient discovery of files that need description tracking.
 """
 
+import fnmatch
 import logging
 from pathlib import Path
-from typing import List, Set, Optional, Generator
-import fnmatch
+from typing import Dict, Generator, List, Optional, Set, Union, Any, cast
 
 try:
     from gitignore_parser import parse_gitignore
@@ -148,7 +148,7 @@ class FileScanner:
             project_root: Root directory of the project to scan
         """
         self.project_root = Path(project_root).resolve()
-        self._gitignore_cache: dict = {}
+        self._gitignore_cache: Dict[str, Any] = {}
         self._load_gitignore_patterns()
 
     def _load_gitignore_patterns(self) -> None:
@@ -348,19 +348,19 @@ class FileScanner:
             return (
                 self.project_root.exists()
                 and self.project_root.is_dir()
-                and self.project_root.stat().st_mode & 0o444  # Readable
+                and bool(self.project_root.stat().st_mode & 0o444)  # Readable
             )
         except (OSError, PermissionError):
             return False
 
-    def get_project_stats(self) -> dict:
+    def get_project_stats(self) -> Dict[str, Union[int, Dict[str, int]]]:
         """
         Get statistics about the project directory.
 
         Returns:
             Dictionary with project statistics for trackable files only
         """
-        stats = {
+        stats: Dict[str, Union[int, Dict[str, int]]] = {
             "total_files": 0,
             "trackable_files": 0,
             "ignored_files": 0,
@@ -375,24 +375,27 @@ class FileScanner:
 
                 # Check if trackable first
                 if self.should_ignore_file(file_path):
-                    stats["ignored_files"] += 1
+                    ignored_files = cast(int, stats["ignored_files"])
+                    stats["ignored_files"] = ignored_files + 1
                     continue
 
                 # Only process trackable files for detailed stats
-                stats["trackable_files"] += 1
+                trackable_files = cast(int, stats["trackable_files"])
+                stats["trackable_files"] = trackable_files + 1
 
                 # Track file size
                 try:
                     file_size = file_path.stat().st_size
-                    stats["largest_file_size"] = max(
-                        stats["largest_file_size"], file_size
-                    )
+                    largest_file_size = cast(int, stats["largest_file_size"])
+                    stats["largest_file_size"] = max(largest_file_size, file_size)
                 except OSError:
                     pass
 
                 # Track extensions for trackable files only
                 ext = file_path.suffix.lower()
-                stats["file_extensions"][ext] = stats["file_extensions"].get(ext, 0) + 1
+                file_extensions = stats["file_extensions"]
+                if isinstance(file_extensions, dict):
+                    file_extensions[ext] = file_extensions.get(ext, 0) + 1
 
             # Total files is just trackable files
             stats["total_files"] = stats["trackable_files"]