mcp-code-indexer 3.1.4__py3-none-any.whl → 3.1.6__py3-none-any.whl

mcp_code_indexer/middleware/error_middleware.py

@@ -13,71 +13,82 @@ from typing import Any, Callable, Dict, List
 import aiosqlite
 from mcp import types
 
-from mcp_code_indexer.error_handler import ErrorHandler, MCPError
-from mcp_code_indexer.logging_config import get_logger, log_tool_usage, log_performance_metrics
+from mcp_code_indexer.error_handler import ErrorHandler
+from mcp_code_indexer.logging_config import (
+    get_logger,
+    log_tool_usage,
+    log_performance_metrics,
+)
 
 logger = get_logger(__name__)
 
 
 class ToolMiddleware:
     """Middleware for MCP tool error handling and logging."""
-    
+
     def __init__(self, error_handler: ErrorHandler):
         """Initialize middleware with error handler."""
         self.error_handler = error_handler
-    
+
     def wrap_tool_handler(self, tool_name: str):
         """
         Decorator to wrap tool handlers with error handling and logging.
-        
+
         Args:
             tool_name: Name of the MCP tool
-            
+
         Returns:
             Decorator function
         """
+
         def decorator(func: Callable) -> Callable:
             @functools.wraps(func)
             async def wrapper(arguments: Dict[str, Any]) -> List[types.TextContent]:
                 start_time = time.time()
                 success = False
                 result_size = 0
-                
+
                 try:
                     # Log tool invocation
-                    logger.info(f"Tool {tool_name} called", extra={
-                        "structured_data": {
-                            "tool_invocation": {
-                                "tool_name": tool_name,
-                                "arguments_count": len(arguments)
+                    logger.info(
+                        f"Tool {tool_name} called",
+                        extra={
+                            "structured_data": {
+                                "tool_invocation": {
+                                    "tool_name": tool_name,
+                                    "arguments_count": len(arguments),
+                                }
                             }
-                        }
-                    })
-                    
+                        },
+                    )
+
                     # Call the actual tool handler
                     result = await func(arguments)
-                    
+
                     # Calculate result size
                     if isinstance(result, list):
-                        result_size = sum(len(item.text) if hasattr(item, 'text') else 0 for item in result)
-                    
+                        result_size = sum(
+                            len(item.text) if hasattr(item, "text") else 0
+                            for item in result
+                        )
+
                     success = True
                     duration = time.time() - start_time
-                    
+
                     # Log performance metrics
                     log_performance_metrics(
                         logger,
                         f"tool_{tool_name}",
                         duration,
                         result_size=result_size,
-                        arguments_count=len(arguments)
+                        arguments_count=len(arguments),
                     )
-                    
+
                     return result
-                    
+
                 except Exception as e:
                     duration = time.time() - start_time
-                    
+
                     # Enhanced SQLite error handling
                     if self._is_database_locking_error(e):
                         logger.warning(
@@ -88,26 +99,26 @@ class ToolMiddleware:
                                         "tool_name": tool_name,
                                         "error_type": type(e).__name__,
                                         "error_message": str(e),
-                                        "duration": duration
+                                        "duration": duration,
                                     }
                                 }
-                            }
+                            },
                         )
-                    
+
                     # Log the error
                     self.error_handler.log_error(
                         e,
                         context={"arguments_count": len(arguments)},
-                        tool_name=tool_name
+                        tool_name=tool_name,
                     )
-                    
+
                     # Create error response
                     error_response = self.error_handler.create_mcp_error_response(
                         e, tool_name, arguments
                     )
-                    
+
                     return [error_response]
-                
+
                 finally:
                     # Always log tool usage
                     log_tool_usage(
@@ -116,58 +127,73 @@ class ToolMiddleware:
                         arguments,
                         success,
                         time.time() - start_time,
-                        result_size if success else None
+                        result_size if success else None,
                     )
-            
+
             return wrapper
+
         return decorator
-    
-    def validate_tool_arguments(self, required_fields: List[str], optional_fields: List[str] = None):
+
+    def validate_tool_arguments(
+        self, required_fields: List[str], optional_fields: List[str] = None
+    ):
         """
         Decorator to validate tool arguments.
-        
+
         Args:
             required_fields: List of required argument names
             optional_fields: List of optional argument names
-            
+
         Returns:
             Decorator function
         """
+
         def decorator(func: Callable) -> Callable:
             @functools.wraps(func)
             async def wrapper(arguments: Dict[str, Any]) -> Any:
                 from ..error_handler import ValidationError
-                
+
                 # Check required fields
-                missing_fields = [field for field in required_fields if field not in arguments]
+                missing_fields = [
+                    field for field in required_fields if field not in arguments
+                ]
                 if missing_fields:
                     raise ValidationError(
                         f"Missing required fields: {', '.join(missing_fields)}",
-                        details={"missing_fields": missing_fields, "provided_fields": list(arguments.keys())}
+                        details={
+                            "missing_fields": missing_fields,
+                            "provided_fields": list(arguments.keys()),
+                        },
                     )
-                
+
                 # Check for unexpected fields if optional_fields is provided
                 if optional_fields is not None:
                     all_fields = set(required_fields + optional_fields)
-                    unexpected_fields = [field for field in arguments.keys() if field not in all_fields]
+                    unexpected_fields = [
+                        field for field in arguments.keys() if field not in all_fields
+                    ]
                     if unexpected_fields:
                         raise ValidationError(
                             f"Unexpected fields: {', '.join(unexpected_fields)}",
-                            details={"unexpected_fields": unexpected_fields, "allowed_fields": list(all_fields)}
+                            details={
+                                "unexpected_fields": unexpected_fields,
+                                "allowed_fields": list(all_fields),
+                            },
                         )
-                
+
                 return await func(arguments)
-            
+
             return wrapper
+
         return decorator
-    
+
     def _is_database_locking_error(self, error: Exception) -> bool:
         """
         Check if an error is related to database locking.
-        
+
         Args:
             error: Exception to check
-            
+
         Returns:
             True if this is a database locking error
         """
@@ -179,74 +205,71 @@ class ToolMiddleware:
                 "database is busy",
                 "sqlite_busy",
                 "sqlite_locked",
-                "cannot start a transaction within a transaction"
+                "cannot start a transaction within a transaction",
             ]
             return any(keyword in error_message for keyword in locking_keywords)
-        
+
         return False
 
 
 class AsyncTaskManager:
     """Manages async tasks with proper error handling."""
-    
+
     def __init__(self, error_handler: ErrorHandler):
         """Initialize task manager."""
         self.error_handler = error_handler
         self._tasks: List[asyncio.Task] = []
-    
+
     def create_task(self, coro, name: str = None) -> asyncio.Task:
         """
         Create a managed async task.
-        
+
         Args:
             coro: Coroutine to run
             name: Optional task name for logging
-            
+
         Returns:
             Created task
         """
         task = asyncio.create_task(coro, name=name)
         self._tasks.append(task)
-        
+
         # Add done callback for error handling
         task.add_done_callback(
             lambda t: asyncio.create_task(
                 self._handle_task_completion(t, name or "unnamed_task")
             )
         )
-        
+
         return task
-    
+
     async def _handle_task_completion(self, task: asyncio.Task, task_name: str) -> None:
         """Handle task completion and errors."""
         try:
             if task.done() and not task.cancelled():
                 exception = task.exception()
                 if exception:
-                    await self.error_handler.handle_async_task_error(
-                        task, task_name
-                    )
+                    await self.error_handler.handle_async_task_error(task, task_name)
         except Exception as e:
             logger.error(f"Error handling task completion for {task_name}: {e}")
         finally:
             # Remove completed task from tracking
             if task in self._tasks:
                 self._tasks.remove(task)
-    
+
     async def wait_for_all(self, timeout: float = None) -> None:
         """
         Wait for all managed tasks to complete.
-        
+
         Args:
             timeout: Maximum time to wait in seconds
         """
         if not self._tasks:
             return
-        
+
         try:
             await asyncio.wait_for(
-                asyncio.gather(*self._tasks, return_exceptions=True),
-                timeout=timeout
+                asyncio.gather(*self._tasks, return_exceptions=True), timeout=timeout
             )
         except asyncio.TimeoutError:
             logger.warning(f"Timeout waiting for {len(self._tasks)} tasks")
@@ -256,14 +279,14 @@ class AsyncTaskManager:
                     task.cancel()
         except Exception as e:
             logger.error(f"Error waiting for tasks: {e}")
-    
+
     def cancel_all(self) -> None:
         """Cancel all managed tasks."""
         for task in self._tasks:
             if not task.done():
                 task.cancel()
         self._tasks.clear()
-    
+
     @property
     def active_task_count(self) -> int:
         """Get count of active tasks."""
@@ -273,10 +296,10 @@ class AsyncTaskManager:
 def create_tool_middleware(error_handler: ErrorHandler) -> ToolMiddleware:
     """
     Create tool middleware instance.
-    
+
     Args:
         error_handler: Error handler instance
-        
+
     Returns:
         Configured ToolMiddleware
     """
@@ -285,43 +308,55 @@ def create_tool_middleware(error_handler: ErrorHandler) -> ToolMiddleware:
 
 # Convenience decorators for common patterns
 
+
 def require_fields(*required_fields):
     """Decorator that requires specific fields in arguments."""
+
     def decorator(func):
         @functools.wraps(func)
         async def wrapper(self, arguments: Dict[str, Any]):
             from ..error_handler import ValidationError
-            
+
             missing = [field for field in required_fields if field not in arguments]
             if missing:
                 raise ValidationError(f"Missing required fields: {', '.join(missing)}")
-            
+
             return await func(self, arguments)
+
         return wrapper
+
     return decorator
 
 
 def handle_file_operations(func):
     """Decorator for file operation error handling."""
+
     @functools.wraps(func)
     async def wrapper(*args, **kwargs):
         try:
             return await func(*args, **kwargs)
         except (FileNotFoundError, PermissionError, OSError) as e:
             from ..error_handler import FileSystemError
+
             raise FileSystemError(f"File operation failed: {e}") from e
+
     return wrapper
 
 
 def handle_database_operations(func):
     """Decorator for database operation error handling."""
+
     @functools.wraps(func)
     async def wrapper(*args, **kwargs):
         try:
             return await func(*args, **kwargs)
         except Exception as e:
-            if any(keyword in str(e).lower() for keyword in ["database", "sqlite", "sql"]):
+            if any(
+                keyword in str(e).lower() for keyword in ["database", "sqlite", "sql"]
+            ):
                 from ..error_handler import DatabaseError
+
                 raise DatabaseError(f"Database operation failed: {e}") from e
             raise
+
     return wrapper

mcp_code_indexer/query_preprocessor.py

@@ -6,8 +6,10 @@ to enable multi-word search with case insensitive matching, whole word enforceme
 and proper handling of FTS5 operators as literal search terms.
 
 Key features:
-- Multi-word queries: "grpc proto" becomes "grpc" AND "proto" for order-agnostic matching
-- FTS5 operator escaping: "AND OR" becomes '"AND" AND "OR"' to treat operators as literals
+- Multi-word queries: "grpc proto" becomes "grpc" AND "proto" for
+  order-agnostic matching
+- FTS5 operator escaping: "AND OR" becomes '"AND" AND "OR"' to treat
+  operators as literals
 - Whole word matching: prevents partial matches by relying on proper tokenization
 - Case insensitive: leverages FTS5 default behavior
 - Special character handling: preserves special characters in quoted terms
@@ -23,30 +25,28 @@ logger = logging.getLogger(__name__)
 class QueryPreprocessor:
     """
     Preprocesses user queries for optimal FTS5 search performance.
-    
+
     Handles multi-word queries, operator escaping, and special character preservation
     while maintaining BM25 ranking performance.
     """
-    
+
     # FTS5 operators that need to be escaped when used as literal search terms
-    FTS5_OPERATORS: Set[str] = {
-        'AND', 'OR', 'NOT', 'NEAR'
-    }
-    
+    FTS5_OPERATORS: Set[str] = {"AND", "OR", "NOT", "NEAR"}
+
     def __init__(self):
         """Initialize the query preprocessor."""
         pass
-    
+
     def preprocess_query(self, query: str) -> str:
         """
         Preprocess a user query for FTS5 search.
-        
+
         Args:
             query: Raw user query string
-            
+
         Returns:
             Preprocessed query string optimized for FTS5
-            
+
         Examples:
             >>> preprocessor = QueryPreprocessor()
             >>> preprocessor.preprocess_query("grpc proto")
@@ -58,74 +58,74 @@ class QueryPreprocessor:
         """
         if not query or not query.strip():
             return ""
-        
+
         # Normalize whitespace
         query = query.strip()
-        
+
         # Split into terms while preserving quoted phrases
         terms = self._split_terms(query)
-        
+
         if not terms:
             return ""
-        
+
         # Process each term: escape operators and add quotes
         processed_terms = []
         for term in terms:
             processed_term = self._process_term(term)
             if processed_term:  # Skip empty terms
                 processed_terms.append(processed_term)
-        
+
         if not processed_terms:
             return ""
-        
+
         # Join with AND for multi-word matching
         result = " AND ".join(processed_terms)
-        
+
         logger.debug(f"Preprocessed query: '{query}' -> '{result}'")
         return result
-    
+
     def _split_terms(self, query: str) -> List[str]:
         """
         Split query into terms while preserving quoted phrases.
-        
+
         Args:
             query: Input query string
-            
+
         Returns:
             List of terms and quoted phrases
-            
+
         Examples:
             'grpc proto' -> ['grpc', 'proto']
             'config "file system"' -> ['config', '"file system"']
             'error AND handling' -> ['error', 'AND', 'handling']
         """
         terms = []
-        
+
         # Regex to match quoted phrases or individual words
         # This pattern captures:
         # 1. Double-quoted strings (including the quotes)
         # 2. Single words (sequences of non-whitespace characters)
         pattern = r'"[^"]*"|\S+'
-        
+
         matches = re.findall(pattern, query)
-        
+
         for match in matches:
             # Skip empty matches
             if match.strip():
                 terms.append(match)
-        
+
         return terms
-    
+
     def _process_term(self, term: str) -> str:
         """
         Process a single term: escape operators and ensure proper quoting.
-        
+
         Args:
             term: Single term or quoted phrase
-            
+
         Returns:
             Processed term ready for FTS5
-            
+
         Examples:
             'grpc' -> '"grpc"'
             'AND' -> '"AND"'
@@ -134,31 +134,31 @@ class QueryPreprocessor:
         """
         if not term:
             return ""
-        
+
         # If already quoted, return as-is (user intentional phrase)
         if term.startswith('"') and term.endswith('"') and len(term) >= 2:
             return term
-        
+
         # Check if term is an FTS5 operator (case-insensitive)
         if term.upper() in self.FTS5_OPERATORS:
             # Escape operator by quoting
             escaped_term = f'"{term}"'
             logger.debug(f"Escaped FTS5 operator: '{term}' -> '{escaped_term}'")
             return escaped_term
-        
+
         # Quote all terms to ensure whole-word matching and handle special characters
         return f'"{term}"'
-    
+
     def _escape_quotes_in_term(self, term: str) -> str:
         """
         Escape internal quotes in a term for FTS5 compatibility.
-        
+
         Args:
             term: Term that may contain quotes
-            
+
         Returns:
             Term with escaped quotes
-            
+
         Examples:
             'say "hello"' -> 'say ""hello""'
             "test's file" -> "test's file"
@@ -170,10 +170,10 @@ class QueryPreprocessor:
 def preprocess_search_query(query: str) -> str:
     """
     Convenience function for preprocessing search queries.
-    
+
     Args:
         query: Raw user query
-        
+
     Returns:
         Preprocessed query ready for FTS5
     """