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

mcp_code_indexer/__init__.py

@@ -6,10 +6,12 @@ intelligent codebase navigation through searchable file descriptions,
 token-aware overviews, and advanced merge capabilities.
 """
 
+
 # Delay import to avoid dependency issues during testing
-def get_server():
+def get_server() -> type:
     """Get MCPCodeIndexServer (lazy import)."""
     from .server.mcp_server import MCPCodeIndexServer
+
     return MCPCodeIndexServer
 
 
@@ -27,15 +29,15 @@ def _get_version() -> str:
         for pkg_name in ["mcp-code-indexer", "mcp_code_indexer"]:
             try:
                 return version(pkg_name)
-            except Exception:
+            except Exception:  # nosec B112
                 continue
-    except Exception:
+    except Exception:  # nosec B110
         pass
 
     # Fallback to reading from pyproject.toml (for development)
     try:
-        from pathlib import Path
         import sys
+        from pathlib import Path
 
         if sys.version_info >= (3, 11):
             import tomllib
@@ -48,7 +50,7 @@ def _get_version() -> str:
         pyproject_path = Path(__file__).parent.parent.parent / "pyproject.toml"
         with open(pyproject_path, "rb") as f:
             data = tomllib.load(f)
-        return data["project"]["version"]
+        return str(data["project"]["version"])
     except Exception:
         return "dev"
 

mcp_code_indexer/ask_handler.py

@@ -8,9 +8,9 @@ and sending them to Claude via OpenRouter API for direct responses.
 
 import logging
 from pathlib import Path
-from typing import Dict, Optional, Any
+from typing import Any, Dict, Optional
 
-from .claude_api_handler import ClaudeAPIHandler, ClaudeAPIError
+from .claude_api_handler import ClaudeAPIError, ClaudeAPIHandler
 from .database.database import DatabaseManager
 
 

mcp_code_indexer/claude_api_handler.py

@@ -11,15 +11,15 @@ import json
 import logging
 import os
 from dataclasses import dataclass
-from typing import Dict, List, Optional, Any
 from pathlib import Path
+from typing import Any, Dict, List, Optional
 
 import aiohttp
 from tenacity import (
     retry,
-    wait_exponential,
-    stop_after_attempt,
     retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential,
 )
 
 from .database.database import DatabaseManager
@@ -194,7 +194,6 @@ class ClaudeAPIHandler:
                 async with session.post(
                     self.OPENROUTER_API_URL, headers=headers, json=payload
                 ) as response:
-
                     self.logger.info(f"Claude API response status: {response.status}")
 
                     if response.status == 429:
@@ -240,7 +239,7 @@ class ClaudeAPIHandler:
             raise ClaudeAPIError("Claude API request timed out")
 
     def validate_json_response(
-        self, response_text: str, required_keys: List[str] = None
+        self, response_text: str, required_keys: Optional[List[str]] = None
     ) -> Dict[str, Any]:
         """
         Validate and parse JSON response from Claude.
@@ -297,6 +296,12 @@ class ClaudeAPIHandler:
                     self.logger.debug(f"Extracted JSON from response: {extracted_json}")
                 data = json.loads(extracted_json)
 
+            # Ensure data is a dictionary
+            if not isinstance(data, dict):
+                raise ClaudeValidationError(
+                    f"Expected JSON object, got {type(data).__name__}"
+                )
+
             # Validate required keys if specified
             if required_keys:
                 missing_keys = [key for key in required_keys if key not in data]

mcp_code_indexer/cleanup_manager.py

@@ -8,7 +8,10 @@ and manual cleanup methods.
 
 import logging
 import time
-from typing import List, Optional
+from typing import Any, List, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .database.database import DatabaseManager
 
 logger = logging.getLogger(__name__)
 
@@ -21,7 +24,9 @@ class CleanupManager:
     periodic cleanup to permanently remove old records after the retention period.
     """
 
-    def __init__(self, db_manager, retention_months: int = 6):
+    def __init__(
+        self, db_manager: "DatabaseManager", retention_months: int = 6
+    ) -> None:
         """
         Initialize cleanup manager.
 
@@ -80,7 +85,7 @@ class CleanupManager:
 
         cleanup_timestamp = int(time.time())
 
-        async def batch_operation(conn):
+        async def batch_operation(conn: Any) -> int:
             data = [(cleanup_timestamp, project_id, path) for path in file_paths]
             cursor = await conn.executemany(
                 """
@@ -90,7 +95,7 @@ class CleanupManager:
                 """,
                 data,
             )
-            return cursor.rowcount
+            return int(cursor.rowcount)
 
         marked_count = await self.db_manager.execute_transaction_with_retry(
             batch_operation,
@@ -99,7 +104,7 @@ class CleanupManager:
         )
 
         logger.info(f"Marked {marked_count} files for cleanup in project {project_id}")
-        return marked_count
+        return int(marked_count)
 
     async def restore_file_from_cleanup(self, project_id: str, file_path: str) -> bool:
         """
@@ -177,7 +182,7 @@ class CleanupManager:
         )  # Approximate months to seconds
         cutoff_timestamp = int(time.time()) - cutoff_seconds
 
-        async def cleanup_operation(conn):
+        async def cleanup_operation(conn: Any) -> int:
             if project_id:
                 cursor = await conn.execute(
                     """
@@ -196,7 +201,7 @@ class CleanupManager:
                     (cutoff_timestamp,),
                 )
 
-            return cursor.rowcount
+            return int(cursor.rowcount)
 
         deleted_count = await self.db_manager.execute_transaction_with_retry(
             cleanup_operation,
@@ -208,7 +213,7 @@ class CleanupManager:
             scope = f"project {project_id}" if project_id else "all projects"
             logger.info(f"Permanently deleted {deleted_count} old records from {scope}")
 
-        return deleted_count
+        return int(deleted_count)
 
     async def get_cleanup_stats(self, project_id: Optional[str] = None) -> dict:
         """
@@ -226,7 +231,7 @@ class CleanupManager:
         async with self.db_manager.get_connection() as db:
             if project_id:
                 base_where = "WHERE project_id = ?"
-                params = (project_id,)
+                params: tuple[Any, ...] = (project_id,)
             else:
                 base_where = ""
                 params = ()
@@ -239,7 +244,8 @@ class CleanupManager:
                 ),
                 params,
             )
-            active_count = (await cursor.fetchone())[0]
+            row = await cursor.fetchone()
+            active_count = row[0] if row else 0
 
             # Files marked for cleanup
             cursor = await db.execute(
@@ -249,7 +255,8 @@ class CleanupManager:
                 ),
                 params,
             )
-            marked_count = (await cursor.fetchone())[0]
+            row = await cursor.fetchone()
+            marked_count = row[0] if row else 0
 
             # Files eligible for permanent deletion
             if project_id:
@@ -268,7 +275,8 @@ class CleanupManager:
                     ),
                     (cutoff_timestamp,),
                 )
-            eligible_for_deletion = (await cursor.fetchone())[0]
+            row = await cursor.fetchone()
+            eligible_for_deletion = row[0] if row else 0
 
             return {
                 "active_files": active_count,

mcp_code_indexer/commands/makelocal.py

@@ -11,7 +11,7 @@ from typing import List, Optional
 
 from mcp_code_indexer.database.database import DatabaseManager
 from mcp_code_indexer.database.database_factory import DatabaseFactory
-from mcp_code_indexer.database.models import Project, FileDescription, ProjectOverview
+from mcp_code_indexer.database.models import FileDescription, Project, ProjectOverview
 
 logger = logging.getLogger(__name__)
 
@@ -19,97 +19,118 @@ logger = logging.getLogger(__name__)
 class MakeLocalCommand:
     """
     Command to migrate project data from global to local database.
-    
+
     Extracts all project data, file descriptions, and project overviews
     from the global database and creates a local database in the specified folder.
     """
-    
+
     def __init__(self, db_factory: DatabaseFactory):
         """
         Initialize the make local command.
-        
+
         Args:
             db_factory: Database factory for creating database managers
         """
         self.db_factory = db_factory
-    
-    async def execute(self, folder_path: str, project_name: Optional[str] = None) -> dict:
+
+    async def execute(
+        self, folder_path: str, project_name: Optional[str] = None
+    ) -> dict:
         """
         Execute the make local command.
-        
+
         Args:
             folder_path: Path to the project folder where local DB will be created
             project_name: Optional project name to migrate (if None, tries to find by folder)
-            
+
         Returns:
             Dictionary with operation results
         """
         folder_path_obj = Path(folder_path).resolve()
-        
+
         if not folder_path_obj.exists():
             raise ValueError(f"Folder path does not exist: {folder_path}")
-        
+
         if not folder_path_obj.is_dir():
             raise ValueError(f"Path is not a directory: {folder_path}")
-        
+
         # Get local database folder and path
-        local_db_folder = self.db_factory.get_path_resolver().get_local_database_folder(folder_path)
-        local_db_path = self.db_factory.get_path_resolver().get_local_database_path(folder_path)
-        
+        local_db_folder = self.db_factory.get_path_resolver().get_local_database_folder(
+            folder_path
+        )
+        local_db_path = self.db_factory.get_path_resolver().get_local_database_path(
+            folder_path
+        )
+
         # Check if local database already exists and has data
-        if local_db_folder.exists() and local_db_path.exists() and local_db_path.stat().st_size > 0:
+        if (
+            local_db_folder.exists()
+            and local_db_path.exists()
+            and local_db_path.stat().st_size > 0
+        ):
             # Check if it actually has project data (not just schema)
             from sqlite3 import connect
+
             try:
                 with connect(local_db_path) as conn:
                     cursor = conn.execute("SELECT COUNT(*) FROM projects")
                     project_count = cursor.fetchone()[0]
                     if project_count > 0:
-                        raise ValueError(f"Local database already contains {project_count} project(s): {local_db_path}")
+                        raise ValueError(
+                            f"Local database already contains {project_count} project(s): {local_db_path}"
+                        )
             except Exception:
                 # If we can't check, assume it has data to be safe
                 raise ValueError(f"Local database already exists: {local_db_path}")
-        
+
         # Get global database manager
         global_db_manager = await self.db_factory.get_database_manager()
-        
+
         # Find the project to migrate
-        project = await self._find_project_to_migrate(global_db_manager, folder_path, project_name)
+        project = await self._find_project_to_migrate(
+            global_db_manager, folder_path, project_name
+        )
         if not project:
             if project_name:
-                raise ValueError(f"Project '{project_name}' not found in global database")
+                raise ValueError(
+                    f"Project '{project_name}' not found in global database"
+                )
             else:
                 raise ValueError(f"No project found for folder path: {folder_path}")
-        
+
         logger.info(f"Found project to migrate: {project.name} (ID: {project.id})")
-        
+
         # Get all project data
-        file_descriptions = await global_db_manager.get_all_file_descriptions(project.id)
+        file_descriptions = await global_db_manager.get_all_file_descriptions(
+            project.id
+        )
         project_overview = await global_db_manager.get_project_overview(project.id)
-        
+
         logger.info(f"Found {len(file_descriptions)} file descriptions to migrate")
         if project_overview:
             logger.info("Found project overview to migrate")
-        
+
         # Create local database folder (this ensures it exists)
         local_db_folder.mkdir(parents=True, exist_ok=True)
         logger.info(f"Created local database folder: {local_db_folder}")
-        
+
         # Create local database manager (this will initialize schema)
-        local_db_manager = await self.db_factory.get_database_manager(str(folder_path_obj))
-        
+        local_db_manager = await self.db_factory.get_database_manager(
+            str(folder_path_obj)
+        )
+
         # For local databases, we'll create a project with a machine-independent approach
         # We'll store the current folder path in aliases for reference, but the project
         # will be found by being the single project in the local database
-        
+
         # Migrate data
         await self._migrate_project_data(
             local_db_manager, project, file_descriptions, project_overview
         )
-        
+
         # Remove data from global database
         await self._remove_from_global_database(global_db_manager, project.id)
-        
+
         return {
             "success": True,
             "project_name": project.name,
@@ -119,26 +140,26 @@ class MakeLocalCommand:
             "migrated_files": len(file_descriptions),
             "migrated_overview": project_overview is not None,
         }
-    
+
     async def _find_project_to_migrate(
-        self, 
-        global_db_manager: DatabaseManager, 
-        folder_path: str, 
-        project_name: Optional[str]
+        self,
+        global_db_manager: DatabaseManager,
+        folder_path: str,
+        project_name: Optional[str],
     ) -> Optional[Project]:
         """
         Find the project to migrate from the global database.
-        
+
         Args:
             global_db_manager: Global database manager
             folder_path: Project folder path
             project_name: Optional project name
-            
+
         Returns:
             Project to migrate or None if not found
         """
         all_projects = await global_db_manager.get_all_projects()
-        
+
         if project_name:
             # Search by name
             normalized_name = project_name.lower()
@@ -150,23 +171,23 @@ class MakeLocalCommand:
             for project in all_projects:
                 if folder_path in project.aliases:
                     return project
-        
+
         return None
-    
+
     async def _migrate_project_data(
         self,
         local_db_manager: DatabaseManager,
         project: Project,
         file_descriptions: List[FileDescription],
-        project_overview: Optional[ProjectOverview]
+        project_overview: Optional[ProjectOverview],
     ) -> None:
         """
         Migrate project data to the local database.
-        
+
         For local databases, we update the project aliases to include the current
         folder path since local database projects are found by being the single
         project in the database rather than by path matching.
-        
+
         Args:
             local_db_manager: Local database manager
             project: Project to migrate
@@ -175,53 +196,54 @@ class MakeLocalCommand:
         """
         # Update project aliases to include current folder path for reference
         # Note: This will be machine-specific but that's OK for local databases
-        
+
         # Create project in local database
         await local_db_manager.create_project(project)
         logger.info(f"Created project in local database: {project.name}")
-        
+
         # Migrate file descriptions
         if file_descriptions:
             await local_db_manager.batch_create_file_descriptions(file_descriptions)
             logger.info(f"Migrated {len(file_descriptions)} file descriptions")
-        
+
         # Migrate project overview
         if project_overview:
             await local_db_manager.create_project_overview(project_overview)
             logger.info("Migrated project overview")
-    
+
     async def _remove_from_global_database(
         self, global_db_manager: DatabaseManager, project_id: str
     ) -> None:
         """
         Remove project data from the global database.
-        
+
         Args:
             global_db_manager: Global database manager
             project_id: Project ID to remove
         """
         # Remove file descriptions
-        async with global_db_manager.get_write_connection_with_retry("remove_project_files") as db:
+        async with global_db_manager.get_write_connection_with_retry(
+            "remove_project_files"
+        ) as db:
             await db.execute(
-                "DELETE FROM file_descriptions WHERE project_id = ?",
-                (project_id,)
+                "DELETE FROM file_descriptions WHERE project_id = ?", (project_id,)
             )
             await db.commit()
-        
+
         # Remove project overview
-        async with global_db_manager.get_write_connection_with_retry("remove_project_overview") as db:
+        async with global_db_manager.get_write_connection_with_retry(
+            "remove_project_overview"
+        ) as db:
             await db.execute(
-                "DELETE FROM project_overviews WHERE project_id = ?",
-                (project_id,)
+                "DELETE FROM project_overviews WHERE project_id = ?", (project_id,)
             )
             await db.commit()
-        
+
         # Remove project
-        async with global_db_manager.get_write_connection_with_retry("remove_project") as db:
-            await db.execute(
-                "DELETE FROM projects WHERE id = ?",
-                (project_id,)
-            )
+        async with global_db_manager.get_write_connection_with_retry(
+            "remove_project"
+        ) as db:
+            await db.execute("DELETE FROM projects WHERE id = ?", (project_id,))
             await db.commit()
-        
+
         logger.info(f"Removed project data from global database: {project_id}")

mcp_code_indexer/data/stop_words_english.txt

@@ -848,4 +848,4 @@ widely
 words
 world
 youd
-youre
+youre

mcp_code_indexer/database/connection_health.py

@@ -10,7 +10,10 @@ import logging
 import time
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta
-from typing import Dict, Optional, List
+from typing import Any, Dict, List, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .database import DatabaseManager
 
 logger = logging.getLogger(__name__)
 
@@ -45,11 +48,11 @@ class ConnectionHealthMonitor:
 
     def __init__(
         self,
-        database_manager,
+        database_manager: "DatabaseManager",
         check_interval: float = 30.0,
         failure_threshold: int = 3,
         timeout_seconds: float = 5.0,
-    ):
+    ) -> None:
         """
         Initialize connection health monitor.
 
@@ -147,24 +150,30 @@ class ConnectionHealthMonitor:
         start_time = time.time()
 
         try:
-            # Use a timeout for the health check
-            async with asyncio.timeout(self.timeout_seconds):
+            # Simple timeout wrapper
+            async def perform_check() -> Any:
                 async with self.database_manager.get_connection() as conn:
                     # Simple query to test connectivity
                     cursor = await conn.execute("SELECT 1")
                     result = await cursor.fetchone()
+                    return result
+
+            # Use timeout for the health check
+            result = await asyncio.wait_for(
+                perform_check(), timeout=self.timeout_seconds
+            )
 
-                    if result and result[0] == 1:
-                        response_time = (time.time() - start_time) * 1000
-                        return HealthCheckResult(
-                            is_healthy=True, response_time_ms=response_time
-                        )
-                    else:
-                        return HealthCheckResult(
-                            is_healthy=False,
-                            response_time_ms=(time.time() - start_time) * 1000,
-                            error_message="Unexpected query result",
-                        )
+            if result and result[0] == 1:
+                response_time = (time.time() - start_time) * 1000
+                return HealthCheckResult(
+                    is_healthy=True, response_time_ms=response_time
+                )
+            else:
+                return HealthCheckResult(
+                    is_healthy=False,
+                    response_time_ms=(time.time() - start_time) * 1000,
+                    error_message="Unexpected query result",
+                )
 
         except asyncio.TimeoutError:
             return HealthCheckResult(
@@ -561,10 +570,10 @@ class ConnectionHealthMonitor:
 class DatabaseMetricsCollector:
     """Collects and aggregates database performance metrics."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Initialize metrics collector."""
-        self._operation_metrics = {}
-        self._locking_events = []
+        self._operation_metrics: Dict[str, Any] = {}
+        self._locking_events: List[Dict[str, Any]] = []
         self._max_events_history = 50
 
     def record_operation(
@@ -655,7 +664,7 @@ class DatabaseMetricsCollector:
         ]
 
         # Count by operation
-        operation_counts = {}
+        operation_counts: Dict[str, int] = {}
         for event in self._locking_events:
             op = event["operation_name"]
             operation_counts[op] = operation_counts.get(op, 0) + 1