mcp-code-indexer 2.0.2__py3-none-any.whl → 2.2.0__py3-none-any.whl

mcp_code_indexer/deepask_handler.py

@@ -0,0 +1,465 @@
+#!/usr/bin/env python3
+"""
+DeepAsk Handler for MCP Code Indexer
+
+Handles enhanced question-answering with two-stage processing:
+1. Extract search terms and compress overview
+2. Search file descriptions and provide enhanced answer
+"""
+
+import logging
+from pathlib import Path
+from typing import Dict, List, Optional, Any, Tuple
+
+from .claude_api_handler import ClaudeAPIHandler, ClaudeAPIError
+from .database.database import DatabaseManager
+
+
+class DeepAskError(ClaudeAPIError):
+    """Exception specific to DeepAsk operations."""
+    pass
+
+
+class DeepAskHandler(ClaudeAPIHandler):
+    """
+    Handler for enhanced Q&A operations using two-stage Claude API processing.
+    
+    Stage 1: Extract search terms and compress project overview
+    Stage 2: Search file descriptions and provide enhanced answer with context
+    """
+    
+    def __init__(self, db_manager: DatabaseManager, cache_dir: Path, logger: Optional[logging.Logger] = None):
+        """
+        Initialize DeepAskHandler.
+        
+        Args:
+            db_manager: Database manager instance
+            cache_dir: Cache directory for temporary files
+            logger: Logger instance to use (optional, creates default if not provided)
+        """
+        super().__init__(db_manager, cache_dir, logger)
+        self.logger = logger if logger is not None else logging.getLogger(__name__)
+    
+    async def find_existing_project_by_name(self, project_name: str) -> Optional[Any]:
+        """
+        Find existing project by name for CLI usage.
+        
+        Args:
+            project_name: Name of the project to find
+            
+        Returns:
+            Project object if found, None otherwise
+        """
+        try:
+            all_projects = await self.db_manager.get_all_projects()
+            normalized_name = project_name.lower()
+            
+            for project in all_projects:
+                if project.name.lower() == normalized_name:
+                    self.logger.info(f"Found existing project: {project.name} (ID: {project.id})")
+                    return project
+            
+            self.logger.warning(f"No existing project found with name: {project_name}")
+            return None
+        except Exception as e:
+            self.logger.error(f"Error finding project by name: {e}")
+            return None
+
+    async def deepask_question(
+        self, 
+        project_info: Dict[str, str], 
+        question: str,
+        max_file_results: int = 10
+    ) -> Dict[str, Any]:
+        """
+        Ask an enhanced question about the project using two-stage Claude API processing.
+        
+        Args:
+            project_info: Project information dict with projectName, folderPath, branch, etc.
+            question: User's question about the project
+            max_file_results: Maximum number of file descriptions to include
+            
+        Returns:
+            Dict containing enhanced response and metadata
+        """
+        try:
+            self.logger.info(f"Processing deepask question for project: {project_info['projectName']}")
+            self.logger.info(f"Question: {question}")
+            
+            # Validate inputs
+            if not question or not question.strip():
+                raise DeepAskError("Question cannot be empty")
+            
+            if not project_info.get("projectName"):
+                raise DeepAskError("Project name is required")
+            
+            # Stage 1: Extract search terms and compress overview
+            stage1_result = await self._stage1_extract_search_terms(project_info, question)
+            
+            # Stage 2: Search files and provide enhanced answer
+            stage2_result = await self._stage2_enhanced_answer(
+                project_info, 
+                question, 
+                stage1_result["search_terms"],
+                stage1_result["compressed_overview"],
+                max_file_results
+            )
+            
+            # Combine results
+            result = {
+                "answer": stage2_result["answer"],
+                "project_name": project_info["projectName"],
+                "question": question,
+                "search_terms": stage1_result["search_terms"],
+                "compressed_overview": stage1_result["compressed_overview"],
+                "relevant_files": stage2_result["relevant_files"],
+                "metadata": {
+                    "model": self.config.model,
+                    "stage1_tokens": stage1_result["token_usage"],
+                    "stage2_tokens": stage2_result["token_usage"],
+                    "total_files_found": stage2_result["total_files_found"],
+                    "files_included": len(stage2_result["relevant_files"]),
+                    "branch": project_info.get("branch", "unknown")
+                }
+            }
+            
+            self.logger.info(f"DeepAsk question completed successfully")
+            self.logger.info(f"Search terms: {stage1_result['search_terms']}")
+            self.logger.info(f"Files found: {stage2_result['total_files_found']}")
+            self.logger.info(f"Files included: {len(stage2_result['relevant_files'])}")
+            
+            return result
+            
+        except Exception as e:
+            error_msg = f"Failed to process deepask question: {str(e)}"
+            self.logger.error(error_msg)
+            if isinstance(e, (ClaudeAPIError, DeepAskError)):
+                raise
+            else:
+                raise DeepAskError(error_msg)
+    
+    async def _stage1_extract_search_terms(
+        self, 
+        project_info: Dict[str, str], 
+        question: str
+    ) -> Dict[str, Any]:
+        """
+        Stage 1: Extract search terms and compress project overview.
+        
+        Args:
+            project_info: Project information
+            question: User's question
+            
+        Returns:
+            Dict with search_terms, compressed_overview, and token_usage
+        """
+        self.logger.info("Stage 1: Extracting search terms and compressing overview")
+        
+        # Get project overview
+        overview = await self.get_project_overview(project_info)
+        if not overview:
+            overview = "No project overview available."
+        
+        # Build stage 1 prompt
+        prompt = self._build_stage1_prompt(project_info, question, overview)
+        
+        # Validate token limits for stage 1
+        if not self.validate_token_limit(prompt):
+            raise DeepAskError(
+                f"Stage 1 prompt exceeds token limit of {self.config.token_limit}. "
+                "Project overview may be too large."
+            )
+        
+        # Call Claude API for stage 1
+        system_prompt = self._get_stage1_system_prompt()
+        response = await self._call_claude_api(prompt, system_prompt)
+        
+        # Parse and validate response
+        response_data = self.validate_json_response(
+            response.content, 
+            required_keys=["search_terms", "compressed_overview"]
+        )
+        
+        token_usage = {
+            "prompt_tokens": self.get_token_count(prompt),
+            "response_tokens": response.usage.get("completion_tokens") if response.usage else None,
+            "total_tokens": response.usage.get("total_tokens") if response.usage else None
+        }
+        
+        return {
+            "search_terms": response_data["search_terms"],
+            "compressed_overview": response_data["compressed_overview"],
+            "token_usage": token_usage
+        }
+    
+    async def _stage2_enhanced_answer(
+        self,
+        project_info: Dict[str, str],
+        question: str,
+        search_terms: List[str],
+        compressed_overview: str,
+        max_file_results: int
+    ) -> Dict[str, Any]:
+        """
+        Stage 2: Search file descriptions and provide enhanced answer.
+        
+        Args:
+            project_info: Project information
+            question: User's question
+            search_terms: Search terms from stage 1
+            compressed_overview: Compressed overview from stage 1
+            max_file_results: Maximum number of files to include
+            
+        Returns:
+            Dict with answer, relevant_files, total_files_found, and token_usage
+        """
+        self.logger.info(f"Stage 2: Searching files and generating enhanced answer")
+        self.logger.info(f"Search terms: {search_terms}")
+        
+        # Search for relevant files
+        relevant_files = []
+        total_files_found = 0
+        
+        try:
+            # Find existing project by name only (don't create new ones for Q&A)
+            project = await self.find_existing_project_by_name(project_info["projectName"])
+            
+            if not project:
+                self.logger.warning(f"Project '{project_info['projectName']}' not found in database")
+                return {
+                    "answer": f"Project '{project_info['projectName']}' not found in database. Please check the project name.",
+                    "relevant_files": [],
+                    "total_files_found": 0,
+                    "token_usage": {"prompt_tokens": 0, "response_tokens": 0, "total_tokens": 0}
+                }
+            
+            for search_term in search_terms:
+                try:
+                    search_results = await self.db_manager.search_file_descriptions(
+                        project_id=project.id,
+                        branch=project_info["branch"],
+                        query=search_term,
+                        max_results=max_file_results
+                    )
+                    
+                    total_files_found += len(search_results)
+                    
+                    # Add unique files to relevant_files
+                    for result in search_results:
+                        if not any(f["filePath"] == result.file_path for f in relevant_files):
+                            relevant_files.append({
+                                "filePath": result.file_path,
+                                "description": result.description,
+                                "search_term": search_term,
+                                "relevance_score": result.relevance_score
+                            })
+                            
+                            # Stop if we have enough files
+                            if len(relevant_files) >= max_file_results:
+                                break
+                    
+                    if len(relevant_files) >= max_file_results:
+                        break
+                        
+                except Exception as e:
+                    self.logger.warning(f"Search failed for term '{search_term}': {e}")
+                    continue
+                    
+        except Exception as e:
+            self.logger.warning(f"Failed to search files: {e}")
+            # Continue with empty relevant_files list
+        
+        # Build stage 2 prompt with file context
+        prompt = self._build_stage2_prompt(
+            project_info, 
+            question, 
+            compressed_overview, 
+            relevant_files
+        )
+        
+        # Validate token limits for stage 2
+        if not self.validate_token_limit(prompt):
+            # Try reducing file context
+            self.logger.warning("Stage 2 prompt exceeds token limit, reducing file context")
+            reduced_files = relevant_files[:max_file_results//2]
+            prompt = self._build_stage2_prompt(
+                project_info, 
+                question, 
+                compressed_overview, 
+                reduced_files
+            )
+            
+            if not self.validate_token_limit(prompt):
+                raise DeepAskError(
+                    f"Stage 2 prompt still exceeds token limit even with reduced context. "
+                    "Try a more specific question."
+                )
+            
+            relevant_files = reduced_files
+        
+        # Call Claude API for stage 2
+        system_prompt = self._get_stage2_system_prompt()
+        response = await self._call_claude_api(prompt, system_prompt)
+        
+        token_usage = {
+            "prompt_tokens": self.get_token_count(prompt),
+            "response_tokens": response.usage.get("completion_tokens") if response.usage else None,
+            "total_tokens": response.usage.get("total_tokens") if response.usage else None
+        }
+        
+        return {
+            "answer": response.content,
+            "relevant_files": relevant_files,
+            "total_files_found": total_files_found,
+            "token_usage": token_usage
+        }
+    
+    def _build_stage1_prompt(
+        self, 
+        project_info: Dict[str, str], 
+        question: str, 
+        overview: str
+    ) -> str:
+        """Build stage 1 prompt for extracting search terms."""
+        project_name = project_info["projectName"]
+        branch = project_info.get("branch", "unknown")
+        
+        return f"""I need to answer a question about the codebase "{project_name}" (branch: {branch}). To provide the best answer, I need to search for relevant files and then answer the question.
+
+PROJECT OVERVIEW:
+{overview}
+
+QUESTION:
+{question}
+
+Please analyze the question and project overview, then provide:
+
+1. A list of 3-5 search terms that would help find relevant files to answer this question
+2. A compressed version of the project overview (2-3 sentences max) that captures the most relevant information for this question
+
+Respond with valid JSON in this format:
+{{
+  "search_terms": ["term1", "term2", "term3"],
+  "compressed_overview": "Brief summary focusing on aspects relevant to the question..."
+}}"""
+    
+    def _build_stage2_prompt(
+        self,
+        project_info: Dict[str, str],
+        question: str,
+        compressed_overview: str,
+        relevant_files: List[Dict[str, Any]]
+    ) -> str:
+        """Build stage 2 prompt for enhanced answer."""
+        project_name = project_info["projectName"]
+        branch = project_info.get("branch", "unknown")
+        
+        # Format file descriptions
+        file_context = ""
+        if relevant_files:
+            file_context = "\n\nRELEVANT FILES:\n"
+            for i, file_info in enumerate(relevant_files, 1):
+                file_context += f"\n{i}. {file_info['filePath']}\n"
+                file_context += f"   Description: {file_info['description']}\n"
+                file_context += f"   Found via search: {file_info['search_term']}\n"
+        else:
+            file_context = "\n\nNo relevant files found in the search."
+        
+        return f"""Please answer the following question about the codebase "{project_name}" (branch: {branch}).
+
+PROJECT OVERVIEW (COMPRESSED):
+{compressed_overview}
+{file_context}
+
+QUESTION:
+{question}
+
+Please provide a comprehensive answer based on the project overview and relevant file descriptions above. Reference specific files when appropriate and explain how they relate to the question. If the available information is insufficient, clearly state what additional details would be needed."""
+    
+    def _get_stage1_system_prompt(self) -> str:
+        """Get system prompt for stage 1."""
+        return """You are a technical assistant that analyzes software projects to extract relevant search terms and compress information.
+
+Your task:
+1. Analyze the user's question about a codebase
+2. Extract 3-5 search terms that would help find relevant files to answer the question
+3. Compress the project overview to focus on information relevant to the question
+
+Search terms should be:
+- Technical keywords (function names, class names, concepts)
+- File types or directory names if relevant
+- Domain-specific terminology from the question
+
+The compressed overview should:
+- Be 2-3 sentences maximum
+- Focus only on aspects relevant to answering the question
+- Preserve the most important architectural or functional details
+
+Always respond with valid JSON matching the requested format."""
+    
+    def _get_stage2_system_prompt(self) -> str:
+        """Get system prompt for stage 2."""
+        return """You are a software engineering expert that provides detailed answers about codebases using available context.
+
+When answering:
+1. Use the compressed project overview for high-level context
+2. Reference specific files from the relevant files list when they relate to the question
+3. Explain how different files work together if relevant
+4. Be specific and technical when appropriate
+5. If information is incomplete, clearly state what's missing and suggest next steps
+6. Provide actionable insights when possible
+
+Your answer should be comprehensive but focused on the specific question asked."""
+    
+    def format_response(self, result: Dict[str, Any], format_type: str = "text") -> str:
+        """
+        Format response for CLI output.
+        
+        Args:
+            result: Result from deepask_question
+            format_type: Output format ("text" or "json")
+            
+        Returns:
+            Formatted response string
+        """
+        if format_type == "json":
+            import json
+            return json.dumps(result, indent=2)
+        
+        # Text format
+        answer = result["answer"]
+        metadata = result["metadata"]
+        
+        output = []
+        output.append(f"Question: {result['question']}")
+        output.append(f"Project: {result['project_name']} (branch: {metadata['branch']})")
+        output.append("")
+        output.append("Answer:")
+        output.append(answer)
+        output.append("")
+        
+        # Show search terms used
+        output.append(f"Search terms: {', '.join(result['search_terms'])}")
+        output.append("")
+        
+        # Show relevant files
+        if result["relevant_files"]:
+            output.append("Relevant files analyzed:")
+            for i, file_info in enumerate(result["relevant_files"], 1):
+                output.append(f"  {i}. {file_info['filePath']}")
+        else:
+            output.append("No relevant files found.")
+        output.append("")
+        
+        # Show metadata
+        output.append("Metadata:")
+        output.append(f"  Model: {metadata['model']}")
+        output.append(f"  Total files found: {metadata['total_files_found']}")
+        output.append(f"  Files included: {metadata['files_included']}")
+        
+        stage1_tokens = metadata['stage1_tokens']['total_tokens']
+        stage2_tokens = metadata['stage2_tokens']['total_tokens']
+        if stage1_tokens and stage2_tokens:
+            output.append(f"  Total tokens: {stage1_tokens + stage2_tokens} (Stage 1: {stage1_tokens}, Stage 2: {stage2_tokens})")
+        
+        return "\n".join(output)

mcp_code_indexer/server/mcp_server.py

@@ -54,7 +54,10 @@ class MCPCodeIndexServer:
         db_retry_count: int = 5,
         db_timeout: float = 10.0,
         enable_wal_mode: bool = True,
-        health_check_interval: float = 30.0
+        health_check_interval: float = 30.0,
+        retry_min_wait: float = 0.1,
+        retry_max_wait: float = 2.0,
+        retry_jitter: float = 0.2
     ):
         """
         Initialize the MCP Code Index Server.
@@ -68,6 +71,9 @@ class MCPCodeIndexServer:
             db_timeout: Database transaction timeout in seconds
             enable_wal_mode: Enable WAL mode for better concurrent access
             health_check_interval: Database health check interval in seconds
+            retry_min_wait: Minimum wait time between retries in seconds
+            retry_max_wait: Maximum wait time between retries in seconds
+            retry_jitter: Maximum jitter to add to retry delays in seconds
         """
         self.token_limit = token_limit
         self.db_path = db_path or Path.home() / ".mcp-code-index" / "tracker.db"
@@ -79,7 +85,10 @@ class MCPCodeIndexServer:
             "retry_count": db_retry_count,
             "timeout": db_timeout,
             "enable_wal_mode": enable_wal_mode,
-            "health_check_interval": health_check_interval
+            "health_check_interval": health_check_interval,
+            "retry_min_wait": retry_min_wait,
+            "retry_max_wait": retry_max_wait,
+            "retry_jitter": retry_jitter
         }
         
         # Initialize components
@@ -89,7 +98,10 @@ class MCPCodeIndexServer:
             retry_count=db_retry_count,
             timeout=db_timeout,
             enable_wal_mode=enable_wal_mode,
-            health_check_interval=health_check_interval
+            health_check_interval=health_check_interval,
+            retry_min_wait=retry_min_wait,
+            retry_max_wait=retry_max_wait,
+            retry_jitter=retry_jitter
         )
         self.token_counter = TokenCounter(token_limit)
         self.merge_handler = MergeHandler(self.db_manager)
@@ -312,7 +324,7 @@ class MCPCodeIndexServer:
                 ),
                 types.Tool(
                     name="search_descriptions",
-                    description="Searches through all file descriptions in a project to find files related to specific functionality. Use this for large codebases instead of loading the entire structure.",
+                    description="Searches through all file descriptions in a project to find files related to specific functionality. Use this for large codebases instead of loading the entire structure. Always start with the fewest terms possible; if the tool returns a lot of results (more than 20) or the results are not relevant, then narrow it down by increasing the number of search terms. Start broad, then narrow the focus only if needed!",
                     inputSchema={
                         "type": "object",
                         "properties": {
@@ -1194,21 +1206,76 @@ src/
         }
     
     async def _handle_check_database_health(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
-        """Handle check_database_health tool calls."""
-        # Get comprehensive database health and statistics
-        health_check = await self.db_manager.check_health()
+        """
+        Handle check_database_health tool calls with comprehensive diagnostics.
+        
+        Returns detailed database health information including retry statistics,
+        performance analysis, and resilience indicators.
+        """
+        # Get comprehensive health diagnostics from the enhanced monitor
+        if hasattr(self.db_manager, '_health_monitor') and self.db_manager._health_monitor:
+            comprehensive_diagnostics = self.db_manager._health_monitor.get_comprehensive_diagnostics()
+        else:
+            # Fallback to basic health check if monitor not available
+            health_check = await self.db_manager.check_health()
+            comprehensive_diagnostics = {
+                "basic_health_check": health_check,
+                "note": "Enhanced health monitoring not available"
+            }
+        
+        # Get additional database-level statistics
         database_stats = self.db_manager.get_database_stats()
         
         return {
-            "health_check": health_check,
-            "database_stats": database_stats,
-            "configuration": self.db_config,
+            "comprehensive_diagnostics": comprehensive_diagnostics,
+            "database_statistics": database_stats,
+            "configuration": {
+                **self.db_config,
+                "retry_executor_config": (
+                    self.db_manager._retry_executor.config.__dict__ 
+                    if hasattr(self.db_manager, '_retry_executor') and self.db_manager._retry_executor 
+                    else {}
+                )
+            },
             "server_info": {
                 "token_limit": self.token_limit,
                 "db_path": str(self.db_path),
-                "cache_dir": str(self.cache_dir)
+                "cache_dir": str(self.cache_dir),
+                "health_monitoring_enabled": (
+                    hasattr(self.db_manager, '_health_monitor') and 
+                    self.db_manager._health_monitor is not None
+                )
             },
-            "timestamp": datetime.utcnow().isoformat()
+            "timestamp": datetime.utcnow().isoformat(),
+            "status_summary": self._generate_health_summary(comprehensive_diagnostics)
+        }
+    
+    def _generate_health_summary(self, diagnostics: Dict[str, Any]) -> Dict[str, Any]:
+        """Generate a concise health summary from comprehensive diagnostics."""
+        if "resilience_indicators" not in diagnostics:
+            return {"status": "limited_diagnostics_available"}
+        
+        resilience = diagnostics["resilience_indicators"]
+        performance = diagnostics.get("performance_analysis", {})
+        
+        # Overall status based on health score
+        health_score = resilience.get("overall_health_score", 0)
+        if health_score >= 90:
+            status = "excellent"
+        elif health_score >= 75:
+            status = "good"  
+        elif health_score >= 50:
+            status = "fair"
+        else:
+            status = "poor"
+        
+        return {
+            "overall_status": status,
+            "health_score": health_score,
+            "retry_effectiveness": resilience.get("retry_effectiveness", {}).get("is_effective", False),
+            "connection_stability": resilience.get("connection_stability", {}).get("is_stable", False),
+            "key_recommendations": resilience.get("recommendations", [])[:3],  # Top 3 recommendations
+            "performance_trend": performance.get("health_check_performance", {}).get("recent_performance_trend", "unknown")
         }
     
     async def _run_session_with_retry(self, read_stream, write_stream, initialization_options) -> None:

{mcp_code_indexer-2.0.2.dist-info → mcp_code_indexer-2.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-code-indexer
-Version: 2.0.2
+Version: 2.2.0
 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.
 Author: MCP Code Indexer Contributors
 Maintainer: MCP Code Indexer Contributors
@@ -59,8 +59,8 @@ Dynamic: requires-python
 
 # MCP Code Indexer 🚀
 
-[![PyPI version](https://badge.fury.io/py/mcp-code-indexer.svg?13)](https://badge.fury.io/py/mcp-code-indexer)
-[![Python](https://img.shields.io/pypi/pyversions/mcp-code-indexer.svg?13)](https://pypi.org/project/mcp-code-indexer/)
+[![PyPI version](https://badge.fury.io/py/mcp-code-indexer.svg?15)](https://badge.fury.io/py/mcp-code-indexer)
+[![Python](https://img.shields.io/pypi/pyversions/mcp-code-indexer.svg?15)](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-2.0.2.dist-info → mcp_code_indexer-2.2.0.dist-info}/RECORD

@@ -1,5 +1,8 @@
 mcp_code_indexer/__init__.py,sha256=GhY2NLQ6lH3n5mxqw0t8T1gmZGKhM6KvjhZH8xW5O-A,1686
 mcp_code_indexer/__main__.py,sha256=4Edinoe0ug43hobuLYcjTmGp2YJnlFYN4_8iKvUBJ0Q,213
+mcp_code_indexer/ask_handler.py,sha256=71hwd3FLMBBxplmNMQMki03BFpeCy0sf4HtdTrVe4ks,8598
+mcp_code_indexer/claude_api_handler.py,sha256=s69aZVQx4SUFXuGvqKVBLYtEsSFHY9_uTCzDT-kpgcE,13660
+mcp_code_indexer/deepask_handler.py,sha256=bNwZFuiSzU8s7gYM_TB-3QyY7jRy38k752MRrj-s7_s,18634
 mcp_code_indexer/error_handler.py,sha256=cNSUFFrGBMLDv4qa78c7495L1wSl_dXCRbzCJOidx-Q,11590
 mcp_code_indexer/file_scanner.py,sha256=ctXeZMROgDThEtjzsANTK9TbK-fhTScMBd4iyuleBT4,11734
 mcp_code_indexer/git_hook_handler.py,sha256=k6QpoLI-5D9EvrLQrHWMII2qNu21daRX_jXlk9U6bGI,36976
@@ -9,19 +12,20 @@ mcp_code_indexer/merge_handler.py,sha256=lJR8eVq2qSrF6MW9mR3Fy8UzrNAaQ7RsI2FMNXn
 mcp_code_indexer/token_counter.py,sha256=WrifOkbF99nWWHlRlhCHAB2KN7qr83GOHl7apE-hJcE,8460
 mcp_code_indexer/data/stop_words_english.txt,sha256=7Zdd9ameVgA6tN_zuXROvHXD4hkWeELVywPhb7FJEkw,6343
 mcp_code_indexer/database/__init__.py,sha256=aPq_aaRp0aSwOBIq9GkuMNjmLxA411zg2vhdrAuHm-w,38
-mcp_code_indexer/database/connection_health.py,sha256=XJvUrHRhIroZlIPScVGdKb69lNP67lT9ZTTO67cFSEs,16721
-mcp_code_indexer/database/database.py,sha256=5G_1E-jSVMDJuyFCVki9tbNmoyNvHJa3x7dRIBB2UQE,49603
+mcp_code_indexer/database/connection_health.py,sha256=s2r9L_KipH5NlemAUDnhBQO90Dn4b_0Ht9UDs7F6QPk,24432
+mcp_code_indexer/database/database.py,sha256=86XL1b49cTeTzkJ1mVbkYPq_QyQrVQOy8w_b1MxZR-E,50856
+mcp_code_indexer/database/exceptions.py,sha256=AgpRA9Z5R-GoWYdQSPeSdYvAXDopFCQkLGN3jD7Ha4E,10215
 mcp_code_indexer/database/models.py,sha256=_vCmJnPXZSiInRzyvs4c7QUWuNNW8qsOoDlGX8J-Gnk,7124
-mcp_code_indexer/database/retry_handler.py,sha256=zwwZ0V1PzzS1rtcfVQOI-CXqWnPGF-KGH4L_3d-_h1Y,11932
+mcp_code_indexer/database/retry_executor.py,sha256=QUayjkCk8OsckVMYiJ_HBQ9NTUss-H8GQeUIUbbw4_U,13419
 mcp_code_indexer/middleware/__init__.py,sha256=p-mP0pMsfiU2yajCPvokCUxUEkh_lu4XJP1LyyMW2ug,220
 mcp_code_indexer/middleware/error_middleware.py,sha256=5agJTAkkPogfPGnja1V9JtG9RG-BiOALIJYctK3byJQ,11730
 mcp_code_indexer/server/__init__.py,sha256=16xMcuriUOBlawRqWNBk6niwrvtv_JD5xvI36X1Vsmk,41
-mcp_code_indexer/server/mcp_server.py,sha256=tQTZFnAnASStkbnQOsj2-3eH1DYSmY97q1pwo7geFXI,66934
+mcp_code_indexer/server/mcp_server.py,sha256=KJAGkhYIR3MVJZECKWL9rpMP3Yb8uO9k7gj5dQ3Wpbc,70436
 mcp_code_indexer/tiktoken_cache/9b5ad71b2ce5302211f9c61530b329a4922fc6a4,sha256=Ijkht27pm96ZW3_3OFE-7xAPtR0YyTWXoRO8_-hlsqc,1681126
 mcp_code_indexer/tools/__init__.py,sha256=m01mxML2UdD7y5rih_XNhNSCMzQTz7WQ_T1TeOcYlnE,49
-mcp_code_indexer-2.0.2.dist-info/licenses/LICENSE,sha256=JN9dyPPgYwH9C-UjYM7FLNZjQ6BF7kAzpF3_4PwY4rY,1086
-mcp_code_indexer-2.0.2.dist-info/METADATA,sha256=BsEhIKscok46a5pfTyigsaMIHjMHZgmg-7-O_OyTrZY,20165
-mcp_code_indexer-2.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcp_code_indexer-2.0.2.dist-info/entry_points.txt,sha256=8HqWOw1Is7jOP1bvIgaSwouvT9z_Boe-9hd4NzyJOhY,68
-mcp_code_indexer-2.0.2.dist-info/top_level.txt,sha256=yKYCM-gMGt-cnupGfAhnZaoEsROLB6DQ1KFUuyKx4rw,17
-mcp_code_indexer-2.0.2.dist-info/RECORD,,
+mcp_code_indexer-2.2.0.dist-info/licenses/LICENSE,sha256=JN9dyPPgYwH9C-UjYM7FLNZjQ6BF7kAzpF3_4PwY4rY,1086
+mcp_code_indexer-2.2.0.dist-info/METADATA,sha256=r40SpRrTsPmIGQu2z-2I0tEBzXQUM5U3qqAXnWBPbbE,20165
+mcp_code_indexer-2.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcp_code_indexer-2.2.0.dist-info/entry_points.txt,sha256=8HqWOw1Is7jOP1bvIgaSwouvT9z_Boe-9hd4NzyJOhY,68
+mcp_code_indexer-2.2.0.dist-info/top_level.txt,sha256=yKYCM-gMGt-cnupGfAhnZaoEsROLB6DQ1KFUuyKx4rw,17
+mcp_code_indexer-2.2.0.dist-info/RECORD,,