mcp-code-indexer 2.3.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

mcp_code_indexer/server/mcp_server.py

@@ -32,7 +32,7 @@ from mcp_code_indexer.database.models import (
 from mcp_code_indexer.error_handler import setup_error_handling, ErrorHandler
 from mcp_code_indexer.middleware.error_middleware import create_tool_middleware, AsyncTaskManager
 from mcp_code_indexer.logging_config import get_logger
-from mcp_code_indexer.merge_handler import MergeHandler
+
 
 logger = logging.getLogger(__name__)
 
@@ -104,7 +104,6 @@ class MCPCodeIndexServer:
             retry_jitter=retry_jitter
         )
         self.token_counter = TokenCounter(token_limit)
-        self.merge_handler = MergeHandler(self.db_manager)
         
         # Setup error handling
         self.logger = get_logger(__name__)
@@ -248,10 +247,7 @@ class MCPCodeIndexServer:
                                 "type": "string", 
                                 "description": "Absolute path to the project folder on disk"
                             },
-                            "branch": {
-                                "type": "string",
-                                "description": "Git branch name (e.g., 'main', 'develop')"
-                            },
+
                             "remoteOrigin": {
                                 "type": "string",
                                 "description": "Git remote origin URL if available"
@@ -265,7 +261,7 @@ class MCPCodeIndexServer:
                                 "description": "Relative path to the file from project root"
                             }
                         },
-                        "required": ["projectName", "folderPath", "branch", "filePath"],
+                        "required": ["projectName", "folderPath", "filePath"],
                         "additionalProperties": False
                     }
                 ),
@@ -277,31 +273,29 @@ class MCPCodeIndexServer:
                         "properties": {
                             "projectName": {"type": "string", "description": "The name of the project"},
                             "folderPath": {"type": "string", "description": "Absolute path to the project folder on disk"},
-                            "branch": {"type": "string", "description": "Git branch name"},
                             "remoteOrigin": {"type": "string", "description": "Git remote origin URL if available"},
                             "upstreamOrigin": {"type": "string", "description": "Upstream repository URL if this is a fork"},
                             "filePath": {"type": "string", "description": "Relative path to the file from project root"},
                             "description": {"type": "string", "description": "Detailed description of the file's contents"},
                             "fileHash": {"type": "string", "description": "SHA-256 hash of the file contents (optional)"}
                         },
-                        "required": ["projectName", "folderPath", "branch", "filePath", "description"],
+                        "required": ["projectName", "folderPath", "filePath", "description"],
                         "additionalProperties": False
                     }
                 ),
                 types.Tool(
                     name="check_codebase_size",
-                    description="Checks the total token count of a codebase's file structure and descriptions - if you're in a git repo be sure to run `git rev-parse --abbrev-ref HEAD` to see what branch you're on before running this tool. Returns whether the codebase is 'large' and recommends using search instead of the full overview.",
+                    description="Checks the total token count of a codebase's file structure and descriptions. Returns whether the codebase is 'large' and recommends using search instead of the full overview.",
                     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"},
-                            "branch": {"type": "string", "description": "Git branch name"},
                             "remoteOrigin": {"type": "string", "description": "Git remote origin URL if available"},
                             "upstreamOrigin": {"type": "string", "description": "Upstream repository URL if this is a fork"},
                             "tokenLimit": {"type": "integer", "description": "Optional token limit override (defaults to server configuration)"}
                         },
-                        "required": ["projectName", "folderPath", "branch"],
+                        "required": ["projectName", "folderPath"],
                         "additionalProperties": False
                     }
                 ),
@@ -313,12 +307,11 @@ class MCPCodeIndexServer:
                         "properties": {
                             "projectName": {"type": "string", "description": "The name of the project"},
                             "folderPath": {"type": "string", "description": "Absolute path to the project folder on disk"},
-                            "branch": {"type": "string", "description": "Git branch name"},
                             "remoteOrigin": {"type": "string", "description": "Git remote origin URL if available"},
                             "upstreamOrigin": {"type": "string", "description": "Upstream repository URL if this is a fork"},
                             "limit": {"type": "integer", "description": "Maximum number of missing files to return (optional)"}
                         },
-                        "required": ["projectName", "folderPath", "branch"],
+                        "required": ["projectName", "folderPath"],
                         "additionalProperties": False
                     }
                 ),
@@ -330,13 +323,12 @@ class MCPCodeIndexServer:
                         "properties": {
                             "projectName": {"type": "string", "description": "The name of the project"},
                             "folderPath": {"type": "string", "description": "Absolute path to the project folder on disk"},
-                            "branch": {"type": "string", "description": "Git branch to search in"},
                             "remoteOrigin": {"type": "string", "description": "Git remote origin URL if available"},
                             "upstreamOrigin": {"type": "string", "description": "Upstream repository URL if this is a fork"},
                             "query": {"type": "string", "description": "Search query (e.g., 'authentication middleware', 'database models')"},
                             "maxResults": {"type": "integer", "default": 20, "description": "Maximum number of results to return"}
                         },
-                        "required": ["projectName", "folderPath", "branch", "query"],
+                        "required": ["projectName", "folderPath", "query"],
                         "additionalProperties": False
                     }
                 ),
@@ -348,57 +340,25 @@ class MCPCodeIndexServer:
                         "properties": {
                             "projectName": {"type": "string", "description": "The name of the project"},
                             "folderPath": {"type": "string", "description": "Absolute path to the project folder on disk"},
-                            "branch": {"type": "string", "description": "Git branch name"},
                             "remoteOrigin": {"type": "string", "description": "Git remote origin URL if available"},
                             "upstreamOrigin": {"type": "string", "description": "Upstream repository URL if this is a fork"}
                         },
-                        "required": ["projectName", "folderPath", "branch"],
-                        "additionalProperties": False
-                    }
-                ),
-                types.Tool(
-                    name="merge_branch_descriptions",
-                    description="Merges file descriptions from one branch to another. This is a two-stage process: first call without resolutions returns conflicts where the same file has different descriptions in each branch. Second call with resolutions completes the merge.",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "projectName": {"type": "string", "description": "The name of the project"},
-                            "folderPath": {"type": "string", "description": "Absolute path to the project folder"},
-                            "remoteOrigin": {"type": "string", "description": "Git remote origin URL"},
-                            "upstreamOrigin": {"type": "string", "description": "Upstream repository URL if this is a fork"},
-                            "sourceBranch": {"type": "string", "description": "Branch to merge from (e.g., 'feature/new-ui')"},
-                            "targetBranch": {"type": "string", "description": "Branch to merge into (e.g., 'main')"},
-                            "conflictResolutions": {
-                                "type": ["array", "null"],
-                                "description": "Array of resolved conflicts (only for second stage)",
-                                "items": {
-                                    "type": "object",
-                                    "properties": {
-                                        "conflictId": {"type": "string", "description": "ID of the conflict to resolve"},
-                                        "resolvedDescription": {"type": "string", "description": "Final description to use after merge"}
-                                    },
-                                    "required": ["conflictId", "resolvedDescription"],
-                                    "additionalProperties": False
-                                }
-                            }
-                        },
-                        "required": ["projectName", "folderPath", "sourceBranch", "targetBranch"],
+                        "required": ["projectName", "folderPath"],
                         "additionalProperties": False
                     }
                 ),
                 types.Tool(
                     name="get_codebase_overview",
-                    description="Returns a condensed, interpretive overview of the entire codebase - if you're in a git repo be sure to run `git rev-parse --abbrev-ref HEAD` to see what branch you're on before running this tool. This is a single comprehensive narrative that captures the architecture, key components, relationships, and design patterns. Unlike get_all_descriptions which lists every file, this provides a holistic view suitable for understanding the codebase's structure and purpose. If no overview exists, returns empty string.",
+                    description="Returns a condensed, interpretive overview of the entire codebase. This is a single comprehensive narrative that captures the architecture, key components, relationships, and design patterns. Unlike get_all_descriptions which lists every file, this provides a holistic view suitable for understanding the codebase's structure and purpose. If no overview exists, returns empty string.",
                     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"},
-                            "branch": {"type": "string", "description": "Git branch name"},
                             "remoteOrigin": {"type": "string", "description": "Git remote origin URL if available"},
                             "upstreamOrigin": {"type": "string", "description": "Upstream repository URL if this is a fork"}
                         },
-                        "required": ["projectName", "folderPath", "branch"],
+                        "required": ["projectName", "folderPath"],
                         "additionalProperties": False
                     }
                 ),
@@ -444,29 +404,27 @@ src/
                         "properties": {
                             "projectName": {"type": "string", "description": "The name of the project"},
                             "folderPath": {"type": "string", "description": "Absolute path to the project folder on disk"},
-                            "branch": {"type": "string", "description": "Git branch name"},
                             "remoteOrigin": {"type": "string", "description": "Git remote origin URL if available"},
                             "upstreamOrigin": {"type": "string", "description": "Upstream repository URL if this is a fork"},
                             "overview": {"type": "string", "description": "Comprehensive narrative overview of the codebase (10-30k tokens recommended)"}
                         },
-                        "required": ["projectName", "folderPath", "branch", "overview"],
+                        "required": ["projectName", "folderPath", "overview"],
                         "additionalProperties": False
                     }
                 ),
                 types.Tool(
                     name="get_word_frequency",
-                    description="Analyzes all file descriptions to find the most frequently used technical terms - if you're in a git repo be sure to run `git rev-parse --abbrev-ref HEAD` to see what branch you're on before running this tool. Filters out common English stop words and symbols, returning the top 200 meaningful terms. Useful for understanding the codebase's domain vocabulary and finding all functions/files related to specific concepts.",
+                    description="Analyzes all file descriptions to find the most frequently used technical terms. Filters out common English stop words and symbols, returning the top 200 meaningful terms. Useful for understanding the codebase's domain vocabulary and finding all functions/files related to specific concepts.",
                     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"},
-                            "branch": {"type": "string", "description": "Git branch name"},
                             "remoteOrigin": {"type": "string", "description": "Git remote origin URL if available"},
                             "upstreamOrigin": {"type": "string", "description": "Upstream repository URL if this is a fork"},
                             "limit": {"type": "integer", "default": 200, "description": "Number of top terms to return"}
                         },
-                        "required": ["projectName", "folderPath", "branch"],
+                        "required": ["projectName", "folderPath"],
                         "additionalProperties": False
                     }
                 ),
@@ -478,6 +436,22 @@ src/
                         "properties": {},
                         "additionalProperties": False
                     }
+                ),
+                types.Tool(
+                    name="search_codebase_overview",
+                    description="Search for a single word in the codebase overview and return 2 sentences before and after where the word is found. Useful for quickly finding specific information in large overviews.",
+                    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"},
+                            "remoteOrigin": {"type": "string", "description": "Git remote origin URL if available"},
+                            "upstreamOrigin": {"type": "string", "description": "Upstream repository URL if this is a fork"},
+                            "searchWord": {"type": "string", "description": "Single word to search for in the overview"}
+                        },
+                        "required": ["projectName", "folderPath", "searchWord"],
+                        "additionalProperties": False
+                    }
                 )
             ]
         
@@ -501,8 +475,9 @@ src/
                 "get_codebase_overview": self._handle_get_condensed_overview,
                 "update_codebase_overview": self._handle_update_codebase_overview,
                 "get_word_frequency": self._handle_get_word_frequency,
-                "merge_branch_descriptions": self._handle_merge_branch_descriptions,
+
                 "check_database_health": self._handle_check_database_health,
+                "search_codebase_overview": self._handle_search_codebase_overview,
             }
             
             if name not in tool_handlers:
@@ -556,7 +531,7 @@ src/
         remote_origin = arguments.get("remoteOrigin")
         upstream_origin = arguments.get("upstreamOrigin")
         folder_path = arguments["folderPath"]
-        branch = arguments.get("branch", "main")
+
         
         # Normalize project name for case-insensitive matching
         normalized_name = project_name.lower()
@@ -572,7 +547,7 @@ src/
             # Check if upstream inheritance is needed
             if upstream_origin and await self.db_manager.check_upstream_inheritance_needed(project):
                 try:
-                    inherited_count = await self.db_manager.inherit_from_upstream(project, branch)
+                    inherited_count = await self.db_manager.inherit_from_upstream(project)
                     if inherited_count > 0:
                         logger.info(f"Auto-inherited {inherited_count} descriptions from upstream for {normalized_name}")
                 except Exception as e:
@@ -595,7 +570,7 @@ src/
             # Auto-inherit from upstream if needed
             if upstream_origin:
                 try:
-                    inherited_count = await self.db_manager.inherit_from_upstream(project, branch)
+                    inherited_count = await self.db_manager.inherit_from_upstream(project)
                     if inherited_count > 0:
                         logger.info(f"Auto-inherited {inherited_count} descriptions from upstream for {normalized_name}")
                 except Exception as e:
@@ -689,7 +664,7 @@ src/
                 return False
             
             # Get files already indexed for this project
-            indexed_files = await self.db_manager.get_all_file_descriptions(project.id, "main")
+            indexed_files = await self.db_manager.get_all_file_descriptions(project.id)
             indexed_basenames = {Path(fd.file_path).name for fd in indexed_files}
             
             if not indexed_basenames:
@@ -746,65 +721,14 @@ src/
             await self.db_manager.update_project(project)
             logger.debug(f"Updated project metadata for {project.name}")
     
-    async def _resolve_branch(self, project_id: str, requested_branch: str) -> str:
-        """
-        Resolve the actual branch to use for operations.
-        
-        For new projects or branches with no existing files, uses the requested branch.
-        For existing projects, tries to find a consistent branch to avoid data fragmentation.
-        
-        Returns the resolved branch name.
-        """
-        try:
-            # Get all branches and their file counts for this project
-            branch_counts = await self.db_manager.get_branch_file_counts(project_id)
-            
-            # If no existing data, use the requested branch
-            if not branch_counts:
-                return requested_branch
-            
-            # If requested branch has files, use it
-            if requested_branch in branch_counts and branch_counts[requested_branch] > 0:
-                return requested_branch
-            
-            # Try common branch name variations to find existing data
-            common_variations = {
-                'main': ['master', 'develop', 'development', 'dev'],
-                'master': ['main', 'develop', 'development', 'dev'], 
-                'develop': ['development', 'main', 'master', 'dev'],
-                'development': ['develop', 'main', 'master', 'dev'],
-                'dev': ['develop', 'development', 'main', 'master']
-            }
-            
-            # Try variations of the requested branch
-            if requested_branch.lower() in common_variations:
-                for variation in common_variations[requested_branch.lower()]:
-                    if variation in branch_counts and branch_counts[variation] > 0:
-                        logger.info(f"Resolved branch '{requested_branch}' to existing branch '{variation}' with {branch_counts[variation]} files")
-                        return variation
-            
-            # If no variations found, check if we should use the main data branch
-            # (to avoid fragmenting data across multiple branches)
-            best_branch = max(branch_counts.items(), key=lambda x: x[1])
-            if best_branch[1] > 10:  # Only if there's substantial existing data
-                logger.info(f"Using primary branch '{best_branch[0]}' instead of '{requested_branch}' to avoid data fragmentation")
-                return best_branch[0]
-            
-            # Fall back to requested branch for new/small projects
-            return requested_branch
-            
-        except Exception as e:
-            logger.warning(f"Error resolving branch: {e}")
-            return requested_branch
+
     
     async def _handle_get_file_description(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
         """Handle get_file_description tool calls."""
         project_id = await self._get_or_create_project_id(arguments)
-        resolved_branch = await self._resolve_branch(project_id, arguments["branch"])
         
         file_desc = await self.db_manager.get_file_description(
             project_id=project_id,
-            branch=resolved_branch,
             file_path=arguments["filePath"]
         )
         
@@ -826,19 +750,16 @@ src/
         """Handle update_file_description tool calls."""
         logger.info(f"Updating file description for: {arguments['filePath']}")
         logger.info(f"Project: {arguments.get('projectName', 'Unknown')}")
-        logger.info(f"Branch: {arguments.get('branch', 'Unknown')}")
         
         description_length = len(arguments.get("description", ""))
         logger.info(f"Description length: {description_length} characters")
         
         project_id = await self._get_or_create_project_id(arguments)
-        resolved_branch = await self._resolve_branch(project_id, arguments["branch"])
         
-        logger.info(f"Resolved project_id: {project_id}, branch: {resolved_branch}")
+        logger.info(f"Resolved project_id: {project_id}")
         
         file_desc = FileDescription(
             project_id=project_id,
-            branch=resolved_branch,
             file_path=arguments["filePath"],
             description=arguments["description"],
             file_hash=arguments.get("fileHash"),
@@ -861,46 +782,52 @@ src/
         """Handle check_codebase_size tool calls."""
         logger.info(f"Checking codebase size for: {arguments.get('projectName', 'Unknown')}")
         logger.info(f"Folder path: {arguments.get('folderPath', 'Unknown')}")
-        logger.info(f"Branch: {arguments.get('branch', 'Unknown')}")
         
         project_id = await self._get_or_create_project_id(arguments)
-        resolved_branch = await self._resolve_branch(project_id, arguments["branch"])
         folder_path = Path(arguments["folderPath"])
         
-        logger.info(f"Resolved project_id: {project_id}, branch: {resolved_branch}")
+        logger.info(f"Resolved project_id: {project_id}")
         
         # Clean up descriptions for files that no longer exist
         logger.info("Cleaning up descriptions for missing files...")
         cleaned_up_files = await self.db_manager.cleanup_missing_files(
             project_id=project_id,
-            branch=resolved_branch,
             project_root=folder_path
         )
         logger.info(f"Cleaned up {len(cleaned_up_files)} missing files")
         
-        # Get file descriptions for this project/branch (after cleanup)
+        # Get file descriptions for this project (after cleanup)
         logger.info("Retrieving file descriptions...")
         file_descriptions = await self.db_manager.get_all_file_descriptions(
-            project_id=project_id,
-            branch=resolved_branch
+            project_id=project_id
         )
         logger.info(f"Found {len(file_descriptions)} file descriptions")
         
         # Use provided token limit or fall back to server default
         token_limit = arguments.get("tokenLimit", self.token_limit)
         
-        # Calculate total tokens
+        # Calculate total tokens for descriptions
         logger.info("Calculating total token count...")
-        total_tokens = self.token_counter.calculate_codebase_tokens(file_descriptions)
+        descriptions_tokens = self.token_counter.calculate_codebase_tokens(file_descriptions)
+        
+        # Get overview tokens if available
+        overview = await self.db_manager.get_project_overview(project_id)
+        overview_tokens = 0
+        if overview and overview.overview:
+            overview_tokens = self.token_counter.count_tokens(overview.overview)
+        
+        total_tokens = descriptions_tokens + overview_tokens
         is_large = total_tokens > token_limit
         recommendation = "use_search" if is_large else "use_overview"
         
-        logger.info(f"Codebase analysis complete: {total_tokens} tokens, {len(file_descriptions)} files")
+        logger.info(f"Codebase analysis complete: {total_tokens} tokens total ({descriptions_tokens} descriptions + {overview_tokens} overview), {len(file_descriptions)} files")
         logger.info(f"Size assessment: {'LARGE' if is_large else 'SMALL'} (limit: {token_limit})")
         logger.info(f"Recommendation: {recommendation}")
         
         return {
             "totalTokens": total_tokens,
+            "descriptionsTokens": descriptions_tokens,
+            "overviewTokens": overview_tokens,
             "isLarge": is_large,
             "recommendation": recommendation,
             "tokenLimit": token_limit,
@@ -915,16 +842,14 @@ src/
         logger.info(f"Folder path: {arguments.get('folderPath', 'Unknown')}")
         
         project_id = await self._get_or_create_project_id(arguments)
-        resolved_branch = await self._resolve_branch(project_id, arguments["branch"])
         folder_path = Path(arguments["folderPath"])
         
-        logger.info(f"Resolved project_id: {project_id}, branch: {resolved_branch}")
+        logger.info(f"Resolved project_id: {project_id}")
         
         # Get existing file descriptions
         logger.info("Retrieving existing file descriptions...")
         existing_descriptions = await self.db_manager.get_all_file_descriptions(
-            project_id=project_id,
-            branch=resolved_branch
+            project_id=project_id
         )
         existing_paths = {desc.file_path for desc in existing_descriptions}
         logger.info(f"Found {len(existing_paths)} existing descriptions")
@@ -965,13 +890,11 @@ src/
     async def _handle_search_descriptions(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
         """Handle search_descriptions tool calls."""
         project_id = await self._get_or_create_project_id(arguments)
-        resolved_branch = await self._resolve_branch(project_id, arguments["branch"])
         max_results = arguments.get("maxResults", 20)
         
         # Perform search
         search_results = await self.db_manager.search_file_descriptions(
             project_id=project_id,
-            branch=resolved_branch,
             query=arguments["query"],
             max_results=max_results
         )
@@ -995,12 +918,10 @@ src/
     async def _handle_get_codebase_overview(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
         """Handle get_codebase_overview tool calls."""
         project_id = await self._get_or_create_project_id(arguments)
-        resolved_branch = await self._resolve_branch(project_id, arguments["branch"])
         
         # Get all file descriptions
         file_descriptions = await self.db_manager.get_all_file_descriptions(
-            project_id=project_id,
-            branch=resolved_branch
+            project_id=project_id
         )
         
         # Calculate total tokens
@@ -1012,8 +933,6 @@ src/
         
         return {
             "projectName": arguments["projectName"],
-            "branch": resolved_branch,
-            "requestedBranch": arguments["branch"] if arguments["branch"] != resolved_branch else None,
             "totalFiles": len(file_descriptions),
             "totalTokens": total_tokens,
             "isLarge": is_large,
@@ -1064,77 +983,14 @@ src/
         
         return convert_structure(root)
     
-    async def _handle_merge_branch_descriptions(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
-        """Handle merge_branch_descriptions tool calls."""
-        project_id = await self._get_or_create_project_id(arguments)
-        source_branch = arguments["sourceBranch"]
-        target_branch = arguments["targetBranch"]
-        conflict_resolutions = arguments.get("conflictResolutions")
-        
-        if conflict_resolutions is None:
-            # Phase 1: Detect conflicts
-            session = await self.merge_handler.start_merge_phase1(
-                project_id, source_branch, target_branch
-            )
-            
-            if session.get_conflict_count() == 0:
-                # No conflicts, can merge immediately
-                return {
-                    "phase": "completed",
-                    "conflicts": [],
-                    "message": f"No conflicts detected. Merge from {source_branch} to {target_branch} can proceed automatically.",
-                    "sourceBranch": source_branch,
-                    "targetBranch": target_branch,
-                    "conflictCount": 0
-                }
-            else:
-                # Return conflicts for resolution
-                return {
-                    "phase": "conflicts_detected",
-                    "sessionId": session.session_id,
-                    "conflicts": [conflict.to_dict() for conflict in session.conflicts],
-                    "conflictCount": session.get_conflict_count(),
-                    "sourceBranch": source_branch,
-                    "targetBranch": target_branch,
-                    "message": f"Found {session.get_conflict_count()} conflicts that need resolution."
-                }
-        else:
-            # Phase 2: Apply resolutions
-            # Find the session ID from conflict resolutions
-            if not conflict_resolutions:
-                from ..error_handler import ValidationError
-                raise ValidationError("Conflict resolutions required for phase 2")
-            
-            # For simplicity, create a new session and resolve immediately
-            # In a production system, you'd want to track session IDs properly
-            session = await self.merge_handler.start_merge_phase1(
-                project_id, source_branch, target_branch
-            )
-            
-            if session.get_conflict_count() == 0:
-                return {
-                    "phase": "completed",
-                    "message": "No conflicts to resolve",
-                    "sourceBranch": source_branch,
-                    "targetBranch": target_branch
-                }
-            
-            result = await self.merge_handler.complete_merge_phase2(
-                session.session_id, conflict_resolutions
-            )
-            
-            return {
-                "phase": "completed",
-                **result
-            }
+
     
     async def _handle_get_condensed_overview(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
         """Handle get_codebase_overview tool calls for condensed overviews."""
         project_id = await self._get_or_create_project_id(arguments)
-        resolved_branch = await self._resolve_branch(project_id, arguments["branch"])
         
         # Try to get existing overview
-        overview = await self.db_manager.get_project_overview(project_id, resolved_branch)
+        overview = await self.db_manager.get_project_overview(project_id)
         
         if overview:
             return {
@@ -1154,13 +1010,11 @@ src/
     async def _handle_update_codebase_overview(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
         """Handle update_codebase_overview tool calls."""
         project_id = await self._get_or_create_project_id(arguments)
-        resolved_branch = await self._resolve_branch(project_id, arguments["branch"])
         folder_path = Path(arguments["folderPath"])
         
         # Get current file count and total tokens for context
         file_descriptions = await self.db_manager.get_all_file_descriptions(
-            project_id=project_id,
-            branch=resolved_branch
+            project_id=project_id
         )
         
         total_files = len(file_descriptions)
@@ -1169,7 +1023,6 @@ src/
         # Create overview record
         overview = ProjectOverview(
             project_id=project_id,
-            branch=resolved_branch,
             overview=arguments["overview"],
             last_modified=datetime.utcnow(),
             total_files=total_files,
@@ -1189,13 +1042,11 @@ src/
     async def _handle_get_word_frequency(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
         """Handle get_word_frequency tool calls."""
         project_id = await self._get_or_create_project_id(arguments)
-        resolved_branch = await self._resolve_branch(project_id, arguments["branch"])
         limit = arguments.get("limit", 200)
         
         # Analyze word frequency
         result = await self.db_manager.analyze_word_frequency(
             project_id=project_id,
-            branch=resolved_branch,
             limit=limit
         )
         
@@ -1205,6 +1056,53 @@ src/
             "totalUniqueTerms": result.total_unique_terms
         }
     
+    async def _handle_search_codebase_overview(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle search_codebase_overview tool calls."""
+        project_id = await self._get_or_create_project_id(arguments)
+        search_word = arguments["searchWord"].lower()
+        
+        # Get the overview
+        overview = await self.db_manager.get_project_overview(project_id)
+        
+        if not overview or not overview.overview:
+            return {
+                "found": False,
+                "message": "No overview found for this project",
+                "searchWord": arguments["searchWord"]
+            }
+        
+        # Split overview into sentences
+        import re
+        sentences = re.split(r'[.!?]+', overview.overview)
+        sentences = [s.strip() for s in sentences if s.strip()]
+        
+        # Find matches
+        matches = []
+        for i, sentence in enumerate(sentences):
+            if search_word in sentence.lower():
+                # Get context: 2 sentences before and after
+                start_idx = max(0, i - 2)
+                end_idx = min(len(sentences), i + 3)
+                
+                context_sentences = sentences[start_idx:end_idx]
+                context = '. '.join(context_sentences) + '.'
+                
+                matches.append({
+                    "matchIndex": i,
+                    "matchSentence": sentence,
+                    "context": context,
+                    "contextStartIndex": start_idx,
+                    "contextEndIndex": end_idx - 1
+                })
+        
+        return {
+            "found": len(matches) > 0,
+            "searchWord": arguments["searchWord"],
+            "matches": matches,
+            "totalMatches": len(matches),
+            "totalSentences": len(sentences)
+        }
+
     async def _handle_check_database_health(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
         """
         Handle check_database_health tool calls with comprehensive diagnostics.