hanzo-mcp 0.5.1__py3-none-any.whl → 0.6.1__py3-none-any.whl

hanzo_mcp/tools/filesystem/unified_search.py

@@ -1,30 +1,31 @@
-"""Unified search tool that combines grep, vector, AST, and semantic search.
+"""Unified search tool that runs multiple search types in parallel.
 
-This tool provides an intelligent multi-search approach that:
-1. Always starts with fast grep/regex search 
-2. Enhances with vector similarity, AST context, and symbol search
-3. Returns comprehensive results with function/method context
-4. Optimizes performance through intelligent caching and batching
+This tool consolidates all search capabilities and runs them concurrently:
+- grep: Fast pattern/regex search using ripgrep
+- grep_ast: AST-aware code search with structural context
+- vector_search: Semantic similarity search
+- git_search: Search through git history
+- symbol_search: Find symbols (functions, classes) in code
+
+Results are combined, deduplicated, and ranked for comprehensive search coverage.
 """
 
 import asyncio
-import json
 import re
-from dataclasses import dataclass, asdict
+from dataclasses import dataclass
 from pathlib import Path
-from typing import Dict, List, Optional, Set, Tuple, Any, Union
+from typing import Annotated, Dict, List, Optional, Set, Tuple, TypedDict, Unpack, final, override
 from enum import Enum
 
-from fastmcp import Context as MCPContext
-from fastmcp import FastMCP
+from mcp.server.fastmcp import Context as MCPContext
+from mcp.server import FastMCP
 from pydantic import Field
-from typing_extensions import Annotated, TypedDict, Unpack, final, override
 
 from hanzo_mcp.tools.filesystem.base import FilesystemBaseTool
 from hanzo_mcp.tools.filesystem.grep import Grep
-from hanzo_mcp.tools.filesystem.grep_ast_tool import GrepAstTool
+from hanzo_mcp.tools.filesystem.symbols import SymbolsTool
+from hanzo_mcp.tools.filesystem.git_search import GitSearchTool
 from hanzo_mcp.tools.vector.vector_search import VectorSearchTool
-from hanzo_mcp.tools.vector.ast_analyzer import ASTAnalyzer, Symbol
 from hanzo_mcp.tools.common.permissions import PermissionManager
 from hanzo_mcp.tools.vector.project_manager import ProjectVectorManager
 
@@ -32,60 +33,103 @@ from hanzo_mcp.tools.vector.project_manager import ProjectVectorManager
 class SearchType(Enum):
     """Types of searches that can be performed."""
     GREP = "grep"
-    VECTOR = "vector" 
-    AST = "ast"
-    SYMBOL = "symbol"
+    GREP_AST = "grep_ast"
+    VECTOR = "vector"
+    GIT = "git"
+    SYMBOL = "symbol"  # Searches for function/class definitions
 
 
-@dataclass 
+@dataclass
 class SearchResult:
-    """Unified search result combining different search types."""
+    """Unified search result from any search type."""
     file_path: str
     line_number: Optional[int]
     content: str
     search_type: SearchType
     score: float  # Relevance score (0-1)
-    context: Optional[str] = None  # AST/function context
-    symbol_info: Optional[Symbol] = None
-    project: Optional[str] = None
-    
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary for JSON serialization."""
-        result = asdict(self)
-        result['search_type'] = self.search_type.value
-        if self.symbol_info:
-            result['symbol_info'] = asdict(self.symbol_info)
-        return result
+    context: Optional[str] = None  # Function/class context
+    match_count: int = 1  # Number of matches in this location
 
 
-@dataclass
-class UnifiedSearchResults:
-    """Container for all unified search results."""
-    query: str
-    total_results: int
-    results_by_type: Dict[SearchType, List[SearchResult]]
-    combined_results: List[SearchResult]
-    search_time_ms: float
-    
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary for JSON serialization."""
-        return {
-            'query': self.query,
-            'total_results': self.total_results,
-            'results_by_type': {k.value: [r.to_dict() for r in v] for k, v in self.results_by_type.items()},
-            'combined_results': [r.to_dict() for r in self.combined_results],
-            'search_time_ms': self.search_time_ms,
-        }
+Pattern = Annotated[
+    str,
+    Field(
+        description="The search pattern (supports regex for grep, natural language for vector search)",
+        min_length=1,
+    ),
+]
+
+SearchPath = Annotated[
+    str,
+    Field(
+        description="The directory to search in. Defaults to current directory.",
+        default=".",
+    ),
+]
 
+Include = Annotated[
+    str,
+    Field(
+        description='File pattern to include (e.g. "*.js", "*.{ts,tsx}")',
+        default="*",
+    ),
+]
 
-Pattern = Annotated[str, Field(description="The search pattern/query", min_length=1)]
-SearchPath = Annotated[str, Field(description="Path to search in", default=".")]
-Include = Annotated[str, Field(description="File pattern to include", default="*")]
-MaxResults = Annotated[int, Field(description="Maximum results per search type", default=20)]
-EnableVector = Annotated[bool, Field(description="Enable vector/semantic search", default=True)]
-EnableAST = Annotated[bool, Field(description="Enable AST context search", default=True)]
-EnableSymbol = Annotated[bool, Field(description="Enable symbol search", default=True)]
-IncludeContext = Annotated[bool, Field(description="Include function/method context", default=True)]
+MaxResults = Annotated[
+    int,
+    Field(
+        description="Maximum number of results to return",
+        default=50,
+    ),
+]
+
+EnableGrep = Annotated[
+    bool,
+    Field(
+        description="Enable fast pattern/regex search",
+        default=True,
+    ),
+]
+
+EnableGrepAst = Annotated[
+    bool,
+    Field(
+        description="Enable AST-aware search with code structure context",
+        default=True,
+    ),
+]
+
+EnableVector = Annotated[
+    bool,
+    Field(
+        description="Enable semantic similarity search",
+        default=True,
+    ),
+]
+
+EnableGit = Annotated[
+    bool,
+    Field(
+        description="Enable git history search",
+        default=True,
+    ),
+]
+
+EnableSymbol = Annotated[
+    bool,
+    Field(
+        description="Enable symbol search (functions, classes)",
+        default=True,
+    ),
+]
+
+IncludeContext = Annotated[
+    bool,
+    Field(
+        description="Include function/class context for matches",
+        default=True,
+    ),
+]
 
 
 class UnifiedSearchParams(TypedDict):
@@ -94,35 +138,38 @@ class UnifiedSearchParams(TypedDict):
     path: SearchPath
     include: Include
     max_results: MaxResults
+    enable_grep: EnableGrep
+    enable_grep_ast: EnableGrepAst
     enable_vector: EnableVector
-    enable_ast: EnableAST
+    enable_git: EnableGit
     enable_symbol: EnableSymbol
     include_context: IncludeContext
 
 
 @final
 class UnifiedSearchTool(FilesystemBaseTool):
-    """Unified search tool combining multiple search strategies."""
+    """Unified search tool that runs multiple search types in parallel."""
     
     def __init__(self, permission_manager: PermissionManager, 
                  project_manager: Optional[ProjectVectorManager] = None):
-        """Initialize the unified search tool."""
+        """Initialize the unified search tool.
+        
+        Args:
+            permission_manager: Permission manager for access control
+            project_manager: Optional project manager for vector search
+        """
         super().__init__(permission_manager)
         self.project_manager = project_manager
         
-        # Initialize component search tools
+        # Initialize component tools
         self.grep_tool = Grep(permission_manager)
-        self.grep_ast_tool = GrepAstTool(permission_manager)
-        self.ast_analyzer = ASTAnalyzer()
+        self.grep_ast_tool = SymbolsTool(permission_manager)
+        self.git_search_tool = GitSearchTool(permission_manager)
         
         # Vector search is optional
         self.vector_tool = None
         if project_manager:
             self.vector_tool = VectorSearchTool(permission_manager, project_manager)
-        
-        # Cache for AST analysis results
-        self._ast_cache: Dict[str, Any] = {}
-        self._symbol_cache: Dict[str, List[Symbol]] = {}
     
     @property
     @override
@@ -130,114 +177,158 @@ class UnifiedSearchTool(FilesystemBaseTool):
         """Get the tool name."""
         return "unified_search"
     
-    @property  
+    @property
     @override
     def description(self) -> str:
         """Get the tool description."""
-        return """Intelligent unified search combining grep, vector similarity, AST context, and symbol search.
+        return """Unified search that runs multiple search strategies in parallel.
 
-This tool provides the most comprehensive search experience by:
-1. Starting with fast grep/regex search for immediate results
-2. Enhancing with vector similarity for semantic matches
-3. Adding AST context to show structural information
-4. Including symbol search for code definitions
-5. Providing function/method body context when relevant
+Automatically runs the most appropriate search types based on your pattern:
+- Pattern matching (grep) for exact text/regex
+- AST search for code structure understanding  
+- Semantic search for concepts and meaning
+- Git history for tracking changes
+- Symbol search for finding definitions
 
-The tool intelligently combines results and provides relevance scoring across all search types.
-Use this when you need comprehensive search results or aren't sure which search type is best."""
+All searches run concurrently for maximum speed. Results are combined,
+deduplicated, and ranked by relevance.
 
-    def _detect_search_intent(self, pattern: str) -> Tuple[bool, bool, bool]:
-        """Analyze pattern to determine which search types to enable.
+Examples:
+- Search for TODO comments: pattern="TODO"
+- Find error handling: pattern="error handling implementation"
+- Locate function: pattern="processPayment"
+- Track changes: pattern="bug fix" (searches git history too)
+
+This is the recommended search tool for comprehensive results."""
+    
+    def _analyze_pattern(self, pattern: str) -> Dict[str, bool]:
+        """Analyze the pattern to determine optimal search strategies.
         
+        Args:
+            pattern: The search pattern
+            
         Returns:
-            Tuple of (should_use_vector, should_use_ast, should_use_symbol)
+            Dictionary of search type recommendations
         """
-        # Default to all enabled
-        use_vector = True  
-        use_ast = True
-        use_symbol = True
-        
-        # If pattern looks like regex, focus on text search
-        regex_indicators = ['.*', '\\w', '\\d', '\\s', '[', ']', '(', ')', '|', '^', '$']
-        if any(indicator in pattern for indicator in regex_indicators):
-            use_vector = False  # Regex patterns don't work well with vector search
-        
-        # If pattern looks like a function/class name, prioritize symbol search
-        if re.match(r'^[a-zA-Z_][a-zA-Z0-9_]*$', pattern):
-            use_symbol = True
-            use_ast = True
-        
-        # If pattern contains natural language, prioritize vector search  
+        # Check if pattern looks like regex
+        regex_chars = r'[.*+?^${}()|[\]\\]'
+        has_regex = bool(re.search(regex_chars, pattern))
+        
+        # Check if pattern looks like a symbol name
+        is_symbol = bool(re.match(r'^[a-zA-Z_][a-zA-Z0-9_]*$', pattern))
+        
+        # Check if pattern is natural language
         words = pattern.split()
-        if len(words) > 2 and not any(c in pattern for c in ['(', ')', '{', '}', '[', ']']):
-            use_vector = True
-            
-        return use_vector, use_ast, use_symbol
+        is_natural_language = len(words) > 2 and not has_regex
+        
+        return {
+            'use_grep': True,  # Always useful
+            'use_grep_ast': not has_regex,  # AST doesn't handle regex well
+            'use_vector': is_natural_language or len(pattern) > 10,
+            'use_git': True,  # Always check history
+            'use_symbol': is_symbol or 'def' in pattern or 'class' in pattern
+        }
     
-    async def _run_grep_search(self, pattern: str, path: str, include: str, 
+    async def _run_grep_search(self, pattern: str, path: str, include: str,
                               tool_ctx, max_results: int) -> List[SearchResult]:
-        """Run grep search and convert results."""
-        await tool_ctx.info(f"Running grep search for: {pattern}")
-        
+        """Run grep search and parse results."""
         try:
-            # Use the existing grep tool
-            grep_result = await self.grep_tool.call(
+            result = await self.grep_tool.call(
                 tool_ctx.mcp_context,
                 pattern=pattern,
-                path=path, 
+                path=path,
                 include=include
             )
             
             results = []
-            if "Found" in grep_result and "matches" in grep_result:
-                # Parse grep results
-                lines = grep_result.split('\n')
-                for line in lines[2:]:  # Skip header lines
-                    if ':' in line and len(line.strip()) > 0:
+            if "Found" in result and "matches" in result:
+                lines = result.split('\n')
+                for line in lines[2:]:  # Skip header
+                    if ':' in line and line.strip():
                         try:
                             parts = line.split(':', 2)
                             if len(parts) >= 3:
-                                file_path = parts[0]
-                                line_num = int(parts[1])
-                                content = parts[2].strip()
-                                
-                                result = SearchResult(
-                                    file_path=file_path,
-                                    line_number=line_num,
-                                    content=content,
+                                results.append(SearchResult(
+                                    file_path=parts[0],
+                                    line_number=int(parts[1]),
+                                    content=parts[2].strip(),
                                     search_type=SearchType.GREP,
-                                    score=1.0,  # Grep results are exact matches
-                                )
-                                results.append(result)
-                                
+                                    score=1.0  # Exact matches get perfect score
+                                ))
                                 if len(results) >= max_results:
                                     break
-                        except (ValueError, IndexError):
+                        except ValueError:
                             continue
             
-            await tool_ctx.info(f"Grep search found {len(results)} results")
+            await tool_ctx.info(f"Grep found {len(results)} results")
             return results
-                        
+            
+        except Exception as e:
+            await tool_ctx.error(f"Grep search failed: {e}")
+            return []
+    
+    async def _run_grep_ast_search(self, pattern: str, path: str,
+                                  tool_ctx, max_results: int) -> List[SearchResult]:
+        """Run AST-aware search and parse results."""
+        try:
+            result = await self.grep_ast_tool.call(
+                tool_ctx.mcp_context,
+                pattern=pattern,
+                path=path,
+                ignore_case=True,
+                line_number=True
+            )
+            
+            results = []
+            if result and not result.startswith("No matches"):
+                current_file = None
+                current_context = []
+                
+                for line in result.split('\n'):
+                    if line.endswith(':') and '/' in line:
+                        current_file = line[:-1]
+                        current_context = []
+                    elif current_file and ':' in line:
+                        try:
+                            # Try to parse line with number
+                            parts = line.split(':', 1)
+                            line_num = int(parts[0].strip())
+                            content = parts[1].strip() if len(parts) > 1 else ""
+                            
+                            results.append(SearchResult(
+                                file_path=current_file,
+                                line_number=line_num,
+                                content=content,
+                                search_type=SearchType.GREP_AST,
+                                score=0.95,  # High score for AST matches
+                                context=" > ".join(current_context) if current_context else None
+                            ))
+                            
+                            if len(results) >= max_results:
+                                break
+                        except ValueError:
+                            # This might be context info
+                            if line.strip():
+                                current_context.append(line.strip())
+            
+            await tool_ctx.info(f"AST search found {len(results)} results")
+            return results
+            
         except Exception as e:
-            await tool_ctx.error(f"Grep search failed: {str(e)}")
+            await tool_ctx.error(f"AST search failed: {e}")
             return []
     
-    async def _run_vector_search(self, pattern: str, path: str, tool_ctx, 
-                                max_results: int) -> List[SearchResult]:
-        """Run vector search and convert results."""
+    async def _run_vector_search(self, pattern: str, path: str,
+                                tool_ctx, max_results: int) -> List[SearchResult]:
+        """Run semantic vector search."""
         if not self.vector_tool:
             return []
             
-        await tool_ctx.info(f"Running vector search for: {pattern}")
-        
         try:
-            # Determine search scope based on path
-            if path == ".":
-                search_scope = "current"
-            else:
-                search_scope = "all"  # Could be enhanced to detect project
+            # Determine search scope
+            search_scope = "current" if path == "." else "all"
             
-            vector_result = await self.vector_tool.call(
+            result = await self.vector_tool.call(
                 tool_ctx.mcp_context,
                 query=pattern,
                 limit=max_results,
@@ -247,37 +338,32 @@ Use this when you need comprehensive search results or aren't sure which search
             )
             
             results = []
-            # Parse vector search results - this would need to be enhanced
-            # based on the actual format returned by vector_tool
-            if "Found" in vector_result:
-                # This is a simplified parser - would need to match actual format
-                lines = vector_result.split('\n')
+            if "Found" in result:
+                # Parse vector search results
+                lines = result.split('\n')
                 current_file = None
                 current_score = 0.0
                 
                 for line in lines:
                     if "Result" in line and "Score:" in line:
-                        # Extract score
+                        # Extract score and file
                         score_match = re.search(r'Score: ([\d.]+)%', line)
                         if score_match:
                             current_score = float(score_match.group(1)) / 100.0
                         
-                        # Extract file path
-                        if " - " in line:
-                            parts = line.split(" - ")
-                            if len(parts) > 1:
-                                current_file = parts[-1].strip()
+                        file_match = re.search(r' - ([^\s]+)$', line)
+                        if file_match:
+                            current_file = file_match.group(1)
                     
                     elif current_file and line.strip() and not line.startswith('-'):
-                        # This is content
-                        result = SearchResult(
+                        # Content line
+                        results.append(SearchResult(
                             file_path=current_file,
                             line_number=None,
-                            content=line.strip(),
+                            content=line.strip()[:200],  # Limit content length
                             search_type=SearchType.VECTOR,
-                            score=current_score,
-                        )
-                        results.append(result)
+                            score=current_score
+                        ))
                         
                         if len(results) >= max_results:
                             break
@@ -286,227 +372,162 @@ Use this when you need comprehensive search results or aren't sure which search
             return results
             
         except Exception as e:
-            await tool_ctx.error(f"Vector search failed: {str(e)}")
+            await tool_ctx.error(f"Vector search failed: {e}")
             return []
     
-    async def _run_ast_search(self, pattern: str, path: str, include: str,
+    async def _run_git_search(self, pattern: str, path: str,
                              tool_ctx, max_results: int) -> List[SearchResult]:
-        """Run AST-aware search and convert results.""" 
-        await tool_ctx.info(f"Running AST search for: {pattern}")
-        
+        """Run git history search."""
         try:
-            ast_result = await self.grep_ast_tool.call(
-                tool_ctx.mcp_context,
-                pattern=pattern,
-                path=path,
-                ignore_case=False,
-                line_number=True
-            )
+            # Search in both content and commits
+            tasks = [
+                self.git_search_tool.call(
+                    tool_ctx.mcp_context,
+                    pattern=pattern,
+                    path=path,
+                    search_type="content",
+                    max_count=max_results // 2
+                ),
+                self.git_search_tool.call(
+                    tool_ctx.mcp_context,
+                    pattern=pattern,
+                    path=path,
+                    search_type="commits",
+                    max_count=max_results // 2
+                )
+            ]
+            
+            git_results = await asyncio.gather(*tasks, return_exceptions=True)
             
             results = []
-            if ast_result and not ast_result.startswith("No matches"):
-                # Parse AST results - they include structural context
-                current_file = None
-                context_lines = []
-                
-                for line in ast_result.split('\n'):
-                    if line.endswith(':') and '/' in line:
-                        # This is a file header
-                        current_file = line[:-1]
-                        context_lines = []
-                    elif current_file and line.strip():
-                        if ':' in line and line.strip()[0].isdigit():
-                            # This looks like a line with number
-                            try:
-                                parts = line.split(':', 1)
-                                line_num = int(parts[0].strip())
-                                content = parts[1].strip() if len(parts) > 1 else ""
-                                
-                                result = SearchResult(
-                                    file_path=current_file,
-                                    line_number=line_num,
-                                    content=content,
-                                    search_type=SearchType.AST,
-                                    score=0.9,  # High score for AST matches
-                                    context='\n'.join(context_lines) if context_lines else None
-                                )
-                                results.append(result)
+            for i, result in enumerate(git_results):
+                if isinstance(result, Exception):
+                    continue
+                    
+                if "Found" in result:
+                    # Parse git results
+                    lines = result.split('\n')
+                    for line in lines:
+                        if ':' in line and line.strip():
+                            parts = line.split(':', 2)
+                            if len(parts) >= 2:
+                                results.append(SearchResult(
+                                    file_path=parts[0].strip(),
+                                    line_number=None,
+                                    content=parts[-1].strip() if len(parts) > 2 else line,
+                                    search_type=SearchType.GIT,
+                                    score=0.8  # Good score for git matches
+                                ))
                                 
                                 if len(results) >= max_results:
                                     break
-                                    
-                            except ValueError:
-                                context_lines.append(line)
-                        else:
-                            context_lines.append(line)
             
-            await tool_ctx.info(f"AST search found {len(results)} results")
+            await tool_ctx.info(f"Git search found {len(results)} results")
             return results
             
         except Exception as e:
-            await tool_ctx.error(f"AST search failed: {str(e)}")
+            await tool_ctx.error(f"Git search failed: {e}")
             return []
     
-    async def _run_symbol_search(self, pattern: str, path: str, tool_ctx,
-                                max_results: int) -> List[SearchResult]:
-        """Run symbol search using AST analysis."""
-        await tool_ctx.info(f"Running symbol search for: {pattern}")
-        
+    async def _run_symbol_search(self, pattern: str, path: str,
+                                tool_ctx, max_results: int) -> List[SearchResult]:
+        """Search for symbol definitions using grep with specific patterns."""
         try:
-            results = []
-            path_obj = Path(path)
+            # Create patterns for common symbol definitions
+            symbol_patterns = [
+                f"(def|class|function|func|fn)\\s+{pattern}",  # Python, JS, various
+                f"(public|private|protected)?\\s*(static)?\\s*\\w+\\s+{pattern}\\s*\\(",  # Java/C++
+                f"const\\s+{pattern}\\s*=",  # JS/TS const
+                f"let\\s+{pattern}\\s*=",  # JS/TS let
+                f"var\\s+{pattern}\\s*=",  # JS/TS var
+            ]
+            
+            # Run grep searches in parallel for each pattern
+            tasks = []
+            for sp in symbol_patterns:
+                tasks.append(
+                    self.grep_tool.call(
+                        tool_ctx.mcp_context,
+                        pattern=sp,
+                        path=path,
+                        include="*"
+                    )
+                )
             
-            # Find files to analyze
-            files_to_check = []
-            if path_obj.is_file():
-                files_to_check.append(str(path_obj))
-            elif path_obj.is_dir():
-                # Look for source files
-                for ext in ['.py', '.js', '.ts', '.java', '.cpp', '.c']:
-                    files_to_check.extend(path_obj.rglob(f'*{ext}'))
-                files_to_check = [str(f) for f in files_to_check[:50]]  # Limit for performance
+            grep_results = await asyncio.gather(*tasks, return_exceptions=True)
             
-            # Analyze files for symbols
-            for file_path in files_to_check:
-                if not self.is_path_allowed(file_path):
+            results = []
+            for result in grep_results:
+                if isinstance(result, Exception):
                     continue
                     
-                # Check cache first
-                if file_path in self._symbol_cache:
-                    symbols = self._symbol_cache[file_path]
-                else:
-                    # Analyze file
-                    file_ast = self.ast_analyzer.analyze_file(file_path)
-                    symbols = file_ast.symbols if file_ast else []
-                    self._symbol_cache[file_path] = symbols
-                
-                # Search symbols
-                for symbol in symbols:
-                    if re.search(pattern, symbol.name, re.IGNORECASE):
-                        result = SearchResult(
-                            file_path=symbol.file_path,
-                            line_number=symbol.line_start,
-                            content=f"{symbol.type} {symbol.name}" + (f" - {symbol.docstring[:100]}..." if symbol.docstring else ""),
-                            search_type=SearchType.SYMBOL,
-                            score=0.95,  # Very high score for symbol matches
-                            symbol_info=symbol,
-                            context=symbol.signature
-                        )
-                        results.append(result)
-                        
-                        if len(results) >= max_results:
-                            break
-                
-                if len(results) >= max_results:
-                    break
+                if "Found" in result and "matches" in result:
+                    lines = result.split('\n')
+                    for line in lines[2:]:  # Skip header
+                        if ':' in line and line.strip():
+                            try:
+                                parts = line.split(':', 2)
+                                if len(parts) >= 3:
+                                    results.append(SearchResult(
+                                        file_path=parts[0],
+                                        line_number=int(parts[1]),
+                                        content=parts[2].strip(),
+                                        search_type=SearchType.SYMBOL,
+                                        score=0.98  # Very high score for symbol definitions
+                                    ))
+                                    if len(results) >= max_results:
+                                        break
+                            except ValueError:
+                                continue
             
             await tool_ctx.info(f"Symbol search found {len(results)} results")
             return results
             
         except Exception as e:
-            await tool_ctx.error(f"Symbol search failed: {str(e)}")
+            await tool_ctx.error(f"Symbol search failed: {e}")
             return []
     
-    async def _add_function_context(self, results: List[SearchResult], tool_ctx) -> List[SearchResult]:
-        """Add function/method context to results where relevant."""
-        enhanced_results = []
+    def _deduplicate_results(self, all_results: List[SearchResult]) -> List[SearchResult]:
+        """Deduplicate results, keeping the highest scoring version."""
+        seen = {}
         
-        for result in results:
-            enhanced_result = result
+        for result in all_results:
+            key = (result.file_path, result.line_number)
             
-            if result.line_number and not result.context:
-                try:
-                    # Read the file and find surrounding function
-                    file_path = Path(result.file_path)
-                    if file_path.exists() and self.is_path_allowed(str(file_path)):
-                        
-                        # Check if we have AST analysis cached
-                        if str(file_path) not in self._ast_cache:
-                            file_ast = self.ast_analyzer.analyze_file(str(file_path))
-                            self._ast_cache[str(file_path)] = file_ast
-                        else:
-                            file_ast = self._ast_cache[str(file_path)]
-                        
-                        if file_ast:
-                            # Find symbol containing this line
-                            for symbol in file_ast.symbols:
-                                if (symbol.line_start <= result.line_number <= symbol.line_end and
-                                    symbol.type in ['function', 'method']):
-                                    enhanced_result = SearchResult(
-                                        file_path=result.file_path,
-                                        line_number=result.line_number,
-                                        content=result.content,
-                                        search_type=result.search_type,
-                                        score=result.score,
-                                        context=f"In {symbol.type} {symbol.name}(): {symbol.signature or ''}",
-                                        symbol_info=symbol,
-                                        project=result.project
-                                    )
-                                    break
-                except Exception as e:
-                    await tool_ctx.warning(f"Could not add context for {result.file_path}: {str(e)}")
-            
-            enhanced_results.append(enhanced_result)
+            if key not in seen or result.score > seen[key].score:
+                seen[key] = result
+            elif key in seen and result.context and not seen[key].context:
+                # Add context if missing
+                seen[key].context = result.context
         
-        return enhanced_results
+        return list(seen.values())
     
-    def _combine_and_rank_results(self, results_by_type: Dict[SearchType, List[SearchResult]]) -> List[SearchResult]:
-        """Combine results from different search types and rank by relevance."""
-        all_results = []
-        seen_combinations = set()
-        
-        # Combine all results, avoiding duplicates
-        for search_type, results in results_by_type.items():
-            for result in results:
-                # Create a key to identify duplicates
-                key = (result.file_path, result.line_number)
-                
-                if key not in seen_combinations:
-                    seen_combinations.add(key)
-                    all_results.append(result)
-                else:
-                    # Merge with existing result based on score and type priority
-                    type_priority = {
-                        SearchType.SYMBOL: 4,
-                        SearchType.GREP: 3, 
-                        SearchType.AST: 2,
-                        SearchType.VECTOR: 1
-                    }
-                    
-                    for existing in all_results:
-                        existing_key = (existing.file_path, existing.line_number)
-                        if existing_key == key:
-                            # Update if the new result has higher priority or better score
-                            result_priority = type_priority[result.search_type]
-                            existing_priority = type_priority[existing.search_type]
-                            
-                            # Replace existing if: higher priority type, or same priority but higher score
-                            if (result_priority > existing_priority or 
-                                (result_priority == existing_priority and result.score > existing.score)):
-                                # Replace the entire result to preserve type
-                                idx = all_results.index(existing)
-                                all_results[idx] = result
-                            else:
-                                # Still merge useful information
-                                existing.context = existing.context or result.context
-                                existing.symbol_info = existing.symbol_info or result.symbol_info
-                            break
-        
-        # Sort by score (descending) then by search type priority
+    def _rank_results(self, results: List[SearchResult]) -> List[SearchResult]:
+        """Rank results by relevance score and search type priority."""
+        # Define search type priorities
         type_priority = {
-            SearchType.SYMBOL: 4,
-            SearchType.GREP: 3, 
-            SearchType.AST: 2,
+            SearchType.SYMBOL: 5,
+            SearchType.GREP: 4,
+            SearchType.GREP_AST: 3,
+            SearchType.GIT: 2,
             SearchType.VECTOR: 1
         }
         
-        all_results.sort(key=lambda r: (r.score, type_priority[r.search_type]), reverse=True)
+        # Sort by score (descending) and then by type priority
+        results.sort(
+            key=lambda r: (r.score, type_priority.get(r.search_type, 0)),
+            reverse=True
+        )
         
-        return all_results
+        return results
     
     @override
-    async def call(self, ctx: MCPContext, **params: Unpack[UnifiedSearchParams]) -> str:
-        """Execute unified search with all enabled search types."""
+    async def call(
+        self,
+        ctx: MCPContext,
+        **params: Unpack[UnifiedSearchParams],
+    ) -> str:
+        """Execute unified search across all enabled search types."""
         import time
         start_time = time.time()
         
@@ -516,10 +537,7 @@ Use this when you need comprehensive search results or aren't sure which search
         pattern = params["pattern"]
         path = params.get("path", ".")
         include = params.get("include", "*")
-        max_results = params.get("max_results", 20)
-        enable_vector = params.get("enable_vector", True)
-        enable_ast = params.get("enable_ast", True) 
-        enable_symbol = params.get("enable_symbol", True)
+        max_results = params.get("max_results", 50)
         include_context = params.get("include_context", True)
         
         # Validate path
@@ -528,136 +546,136 @@ Use this when you need comprehensive search results or aren't sure which search
             await tool_ctx.error(path_validation.error_message)
             return f"Error: {path_validation.error_message}"
         
-        # Check path permissions and existence
+        # Check permissions
         allowed, error_msg = await self.check_path_allowed(path, tool_ctx)
         if not allowed:
             return error_msg
-            
+        
+        # Check existence
         exists, error_msg = await self.check_path_exists(path, tool_ctx)
         if not exists:
             return error_msg
         
-        # Analyze search intent to optimize which searches to run
-        should_vector, should_ast, should_symbol = self._detect_search_intent(pattern)
-        enable_vector = enable_vector and should_vector
-        enable_ast = enable_ast and should_ast
-        enable_symbol = enable_symbol and should_symbol
+        # Analyze pattern to determine best search strategies
+        pattern_analysis = self._analyze_pattern(pattern)
         
         await tool_ctx.info(f"Starting unified search for '{pattern}' in {path}")
-        await tool_ctx.info(f"Enabled searches: grep=True vector={enable_vector} ast={enable_ast} symbol={enable_symbol}")
         
-        # Run searches in parallel for maximum efficiency
+        # Build list of search tasks based on enabled types and pattern analysis
         search_tasks = []
+        search_names = []
         
-        # Always run grep first (fastest, most reliable)
-        search_tasks.append(
-            self._run_grep_search(pattern, path, include, tool_ctx, max_results)
-        )
+        if params.get("enable_grep", True) and pattern_analysis['use_grep']:
+            search_tasks.append(self._run_grep_search(pattern, path, include, tool_ctx, max_results))
+            search_names.append("grep")
         
-        if enable_vector and self.vector_tool:
-            search_tasks.append(
-                self._run_vector_search(pattern, path, tool_ctx, max_results)
-            )
+        if params.get("enable_grep_ast", True) and pattern_analysis['use_grep_ast']:
+            search_tasks.append(self._run_grep_ast_search(pattern, path, tool_ctx, max_results))
+            search_names.append("grep_ast")
         
-        if enable_ast:
-            search_tasks.append(
-                self._run_ast_search(pattern, path, include, tool_ctx, max_results)
-            )
+        if params.get("enable_vector", True) and self.vector_tool and pattern_analysis['use_vector']:
+            search_tasks.append(self._run_vector_search(pattern, path, tool_ctx, max_results))
+            search_names.append("vector")
         
-        if enable_symbol:
-            search_tasks.append(
-                self._run_symbol_search(pattern, path, tool_ctx, max_results)
-            )
+        if params.get("enable_git", True) and pattern_analysis['use_git']:
+            search_tasks.append(self._run_git_search(pattern, path, tool_ctx, max_results))
+            search_names.append("git")
+        
+        if params.get("enable_symbol", True) and pattern_analysis['use_symbol']:
+            search_tasks.append(self._run_symbol_search(pattern, path, tool_ctx, max_results))
+            search_names.append("symbol")
         
-        # Execute all searches in parallel
+        await tool_ctx.info(f"Running {len(search_tasks)} search types in parallel: {', '.join(search_names)}")
+        
+        # Run all searches in parallel
         search_results = await asyncio.gather(*search_tasks, return_exceptions=True)
         
-        # Organize results by type
+        # Collect all results
+        all_results = []
         results_by_type = {}
-        search_types = [SearchType.GREP]
-        if enable_vector and self.vector_tool:
-            search_types.append(SearchType.VECTOR)
-        if enable_ast:
-            search_types.append(SearchType.AST)
-        if enable_symbol:
-            search_types.append(SearchType.SYMBOL)
-        
-        for i, result in enumerate(search_results):
-            if isinstance(result, Exception):
-                await tool_ctx.error(f"Search failed: {str(result)}")
-                continue
-            
-            search_type = search_types[i]
-            results_by_type[search_type] = result
         
-        # Add function context if requested
-        if include_context:
-            for search_type, results in results_by_type.items():
-                if results:
-                    results_by_type[search_type] = await self._add_function_context(results, tool_ctx)
+        for search_type, results in zip(search_names, search_results):
+            if isinstance(results, Exception):
+                await tool_ctx.error(f"{search_type} search failed: {results}")
+                results_by_type[search_type] = []
+            else:
+                results_by_type[search_type] = results
+                all_results.extend(results)
         
-        # Combine and rank all results
-        combined_results = self._combine_and_rank_results(results_by_type)
+        # Deduplicate and rank results
+        unique_results = self._deduplicate_results(all_results)
+        ranked_results = self._rank_results(unique_results)
         
-        end_time = time.time()
-        search_time_ms = (end_time - start_time) * 1000
+        # Limit total results
+        final_results = ranked_results[:max_results]
         
-        # Create unified results object
-        unified_results = UnifiedSearchResults(
-            query=pattern,
-            total_results=len(combined_results),
-            results_by_type=results_by_type,
-            combined_results=combined_results[:max_results * 2],  # Allow some extra for variety
-            search_time_ms=search_time_ms
-        )
+        # Calculate search time
+        search_time = (time.time() - start_time) * 1000
         
         # Format output
-        return self._format_unified_results(unified_results)
+        return self._format_results(
+            pattern=pattern,
+            results=final_results,
+            results_by_type=results_by_type,
+            search_time_ms=search_time,
+            include_context=include_context
+        )
     
-    def _format_unified_results(self, results: UnifiedSearchResults) -> str:
-        """Format unified search results for display."""
-        if results.total_results == 0:
-            return f"No results found for query: '{results.query}'"
-        
-        lines = [
-            f"Unified Search Results for '{results.query}' ({results.search_time_ms:.1f}ms)",
-            f"Found {results.total_results} total results across {len(results.results_by_type)} search types",
-            ""
-        ]
-        
-        # Show summary by type
-        for search_type, type_results in results.results_by_type.items():
+    def _format_results(self, pattern: str, results: List[SearchResult],
+                       results_by_type: Dict[str, List[SearchResult]],
+                       search_time_ms: float, include_context: bool) -> str:
+        """Format search results for display."""
+        output = []
+        
+        # Header
+        output.append(f"=== Unified Search Results ===")
+        output.append(f"Pattern: '{pattern}'")
+        output.append(f"Total results: {len(results)}")
+        output.append(f"Search time: {search_time_ms:.1f}ms")
+        
+        # Summary by type
+        output.append("\nResults by type:")
+        for search_type, type_results in results_by_type.items():
             if type_results:
-                lines.append(f"• {search_type.value.title()}: {len(type_results)} results")
-        lines.append("")
+                output.append(f"  {search_type}: {len(type_results)} matches")
         
-        # Show top combined results
-        lines.append("=== Top Results (Combined & Ranked) ===")
-        for i, result in enumerate(results.combined_results[:20], 1):
-            score_display = f"{result.score:.2f}" if result.score < 1.0 else "1.00"
-            
-            header = f"Result {i} [{result.search_type.value}] (Score: {score_display})"
-            if result.line_number:
-                header += f" - {result.file_path}:{result.line_number}"
-            else:
-                header += f" - {result.file_path}"
-            
-            lines.append(header)
-            lines.append("-" * len(header))
-            
-            if result.context:
-                lines.append(f"Context: {result.context}")
+        if not results:
+            output.append("\nNo results found.")
+            return "\n".join(output)
+        
+        # Group results by file
+        results_by_file = {}
+        for result in results:
+            if result.file_path not in results_by_file:
+                results_by_file[result.file_path] = []
+            results_by_file[result.file_path].append(result)
+        
+        # Display results
+        output.append(f"\n=== Results ({len(results)} total) ===\n")
+        
+        for file_path, file_results in results_by_file.items():
+            output.append(f"{file_path}")
+            output.append("-" * len(file_path))
             
-            lines.append(f"Content: {result.content}")
+            # Sort by line number
+            file_results.sort(key=lambda r: r.line_number or 0)
             
-            if result.symbol_info:
-                lines.append(f"Symbol: {result.symbol_info.type} {result.symbol_info.name}")
-                if result.symbol_info.signature:
-                    lines.append(f"Signature: {result.symbol_info.signature}")
+            for result in file_results:
+                # Format result line
+                score_str = f"[{result.search_type.value} {result.score:.2f}]"
+                
+                if result.line_number:
+                    output.append(f"  {result.line_number:>4}: {score_str} {result.content}")
+                else:
+                    output.append(f"       {score_str} {result.content}")
+                
+                # Add context if available and requested
+                if include_context and result.context:
+                    output.append(f"         Context: {result.context}")
             
-            lines.append("")
+            output.append("")  # Empty line between files
         
-        return "\n".join(lines)
+        return "\n".join(output)
     
     @override
     def register(self, mcp_server: FastMCP) -> None:
@@ -670,9 +688,11 @@ Use this when you need comprehensive search results or aren't sure which search
             pattern: Pattern,
             path: SearchPath = ".",
             include: Include = "*",
-            max_results: MaxResults = 20,
+            max_results: MaxResults = 50,
+            enable_grep: EnableGrep = True,
+            enable_grep_ast: EnableGrepAst = True,
             enable_vector: EnableVector = True,
-            enable_ast: EnableAST = True,  
+            enable_git: EnableGit = True,
             enable_symbol: EnableSymbol = True,
             include_context: IncludeContext = True,
         ) -> str:
@@ -682,8 +702,10 @@ Use this when you need comprehensive search results or aren't sure which search
                 path=path,
                 include=include,
                 max_results=max_results,
+                enable_grep=enable_grep,
+                enable_grep_ast=enable_grep_ast,
                 enable_vector=enable_vector,
-                enable_ast=enable_ast,
+                enable_git=enable_git,
                 enable_symbol=enable_symbol,
                 include_context=include_context,
             )