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

mcp_code_indexer/server/mcp_server.py

@@ -13,7 +13,7 @@ import random
 import re
 import time
 import uuid
-from datetime import datetime
+from datetime import datetime, timedelta
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Callable, cast
 
@@ -56,7 +56,7 @@ class MCPCodeIndexServer:
         cache_dir: Optional[Path] = None,
         db_pool_size: int = 3,
         db_retry_count: int = 5,
-        db_timeout: float = 10.0,
+        db_timeout: float = 30.0,
         enable_wal_mode: bool = True,
         health_check_interval: float = 30.0,
         retry_min_wait: float = 0.1,
@@ -684,6 +684,104 @@ class MCPCodeIndexServer:
                         "additionalProperties": False,
                     },
                 ),
+                types.Tool(
+                    name="enabled_vector_mode",
+                    description=(
+                        "Enables or disables vector mode for a project. Vector mode "
+                        "provides semantic search capabilities with embeddings for "
+                        "enhanced code navigation and discovery."
+                    ),
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "projectName": {
+                                "type": "string",
+                                "description": "The name of the project",
+                            },
+                            "folderPath": {
+                                "type": "string",
+                                "description": (
+                                    "Absolute path to the project folder on disk"
+                                ),
+                            },
+                            "enabled": {
+                                "type": "boolean",
+                                "description": (
+                                    "Whether to enable (true) or disable (false) vector mode"
+                                ),
+                            },
+                        },
+                        "required": ["projectName", "folderPath", "enabled"],
+                        "additionalProperties": False,
+                    },
+                ),
+                types.Tool(
+                    name="find_similar_code",
+                    description=(
+                        "Find code similar to a given code snippet or file section using "
+                        "vector-based semantic search. This tool uses AI embeddings to "
+                        "understand code context and meaning, providing more intelligent "
+                        "similarity detection than text-based matching. Requires vector "
+                        "mode to be enabled for the project."
+                    ),
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "projectName": {
+                                "type": "string",
+                                "description": "The name of the project",
+                            },
+                            "folderPath": {
+                                "type": "string",
+                                "description": (
+                                    "Absolute path to the project folder on disk"
+                                ),
+                            },
+                            "code_snippet": {
+                                "type": "string",
+                                "description": (
+                                    "Direct code snippet to search for similarities (mutually "
+                                    "exclusive with file_path)"
+                                ),
+                            },
+                            "file_path": {
+                                "type": "string",
+                                "description": (
+                                    "Path to file containing code to analyze (mutually "
+                                    "exclusive with code_snippet)"
+                                ),
+                            },
+                            "line_start": {
+                                "type": "integer",
+                                "description": (
+                                    "Starting line number for file section (1-indexed, "
+                                    "used with file_path)"
+                                ),
+                            },
+                            "line_end": {
+                                "type": "integer",
+                                "description": (
+                                    "Ending line number for file section (1-indexed, "
+                                    "used with file_path)"
+                                ),
+                            },
+                            "similarity_threshold": {
+                                "type": "number",
+                                "description": (
+                                    "Minimum similarity score (0.0-1.0, optional)"
+                                ),
+                            },
+                            "max_results": {
+                                "type": "integer",
+                                "description": (
+                                    "Maximum number of results to return (optional)"
+                                ),
+                            },
+                        },
+                        "required": ["projectName", "folderPath"],
+                        "additionalProperties": False,
+                    },
+                ),
             ]
 
         @self.server.call_tool()  # type: ignore[misc]
@@ -711,6 +809,8 @@ class MCPCodeIndexServer:
                 "get_word_frequency": self._handle_get_word_frequency,
                 "check_database_health": self._handle_check_database_health,
                 "search_codebase_overview": self._handle_search_codebase_overview,
+                "enabled_vector_mode": self._handle_enabled_vector_mode,
+                "find_similar_code": self._handle_find_similar_code,
             }
 
             if name not in tool_handlers:
@@ -782,8 +882,11 @@ class MCPCodeIndexServer:
             all_projects = await db_manager.get_all_projects()
             if all_projects:
                 project = all_projects[0]  # Use the first (and should be only) project
-                # Update last accessed time
-                await db_manager.update_project_access_time(project.id)
+
+                # Update last accessed time only if older than 5 minutes
+                if datetime.utcnow() - project.last_accessed > timedelta(minutes=5):
+                    await db_manager.update_project_access_time(project.id)
+
                 logger.info(
                     f"Using existing local project: {project.name} (ID: {project.id})"
                 )
@@ -834,7 +937,9 @@ class MCPCodeIndexServer:
                 )
 
             if project is None:
-                raise RuntimeError("Project should always be set in if/else branches above")
+                raise RuntimeError(
+                    "Project should always be set in if/else branches above"
+                )
             return project.id
 
     async def _find_matching_project(
@@ -938,8 +1043,9 @@ class MCPCodeIndexServer:
         db_manager: DatabaseManager,
     ) -> None:
         """Update an existing project with new metadata and folder alias."""
-        # Update last accessed time
-        await db_manager.update_project_access_time(project.id)
+        # Update last accessed time only if older than 5 minutes
+        if datetime.utcnow() - project.last_accessed > timedelta(minutes=5):
+            await db_manager.update_project_access_time(project.id)
 
         should_update = False
 
@@ -1103,6 +1209,7 @@ class MCPCodeIndexServer:
             "isLarge": is_large,
             "recommendation": recommendation,
             "tokenLimit": token_limit,
+            "totalTokens": total_tokens,
             "totalFiles": len(file_descriptions),
             "cleanedUpCount": cleaned_up_count,
         }
@@ -1481,6 +1588,93 @@ class MCPCodeIndexServer:
             "status_summary": self._generate_health_summary(comprehensive_diagnostics),
         }
 
+    async def _handle_enabled_vector_mode(
+        self, arguments: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Handle enabled_vector_mode tool calls."""
+        folder_path = arguments["folderPath"]
+        db_manager = await self.db_factory.get_database_manager(folder_path)
+        project_id = await self._get_or_create_project_id(arguments)
+        enabled = arguments["enabled"]
+
+        try:
+            await db_manager.set_project_vector_mode(project_id, enabled)
+
+            return {
+                "success": True,
+                "message": f"Vector mode {'enabled' if enabled else 'disabled'} for project",
+                "project_id": project_id,
+                "vector_mode": enabled,
+            }
+        except ValueError as e:
+            return {
+                "success": False,
+                "error": str(e),
+                "project_id": project_id,
+                "vector_mode": None,
+            }
+
+    async def _handle_find_similar_code(
+        self, arguments: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Handle find_similar_code tool calls."""
+        try:
+            from mcp_code_indexer.vector_mode.services.vector_mode_tools_service import (
+                VectorModeToolsService,
+            )
+
+            # Initialize the tools service (handles all vector mode setup internally)
+            tools_service = VectorModeToolsService()
+
+            # Extract project info
+            project_name = arguments["projectName"]
+            folder_path = arguments["folderPath"]
+
+            logger.info(
+                "Processing find_similar_code request",
+                extra={
+                    "structured_data": {
+                        "project_name": project_name,
+                        "has_code_snippet": "code_snippet" in arguments,
+                        "has_file_path": "file_path" in arguments,
+                    }
+                },
+            )
+
+            # Call the service method
+            result = await tools_service.find_similar_code(
+                project_name=project_name,
+                folder_path=folder_path,
+                code_snippet=arguments.get("code_snippet"),
+                file_path=arguments.get("file_path"),
+                line_start=arguments.get("line_start"),
+                line_end=arguments.get("line_end"),
+                similarity_threshold=arguments.get("similarity_threshold"),
+                max_results=arguments.get("max_results"),
+            )
+
+            # Add success indicator to the result
+            result["success"] = True
+            return result
+
+        except Exception as e:
+            logger.error(
+                "Failed to execute find_similar_code",
+                extra={
+                    "structured_data": {
+                        "error": str(e),
+                        "project_name": arguments.get("projectName", "unknown"),
+                    }
+                },
+                exc_info=True,
+            )
+            return {
+                "success": False,
+                "error": str(e),
+                "results": [],
+                "total_results": 0,
+            }
+
     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: