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

hanzo_mcp/tools/filesystem/{unified_search.py → batch_search.py}

@@ -1,10 +1,14 @@
-"""Unified search tool that combines grep, vector, AST, and semantic search.
+"""Batch search tool that runs multiple search queries 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 allows running multiple searches of different types concurrently:
+- grep: Fast pattern/regex search
+- grep_ast: AST-aware code search
+- vector_search: Semantic similarity search
+- git_search: Search through git history
+
+Results are combined and ranked for comprehensive search coverage.
+Perfect for complex research and refactoring tasks where you need
+to find all occurrences across different dimensions.
 """
 
 import asyncio
@@ -23,6 +27,7 @@ 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.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
@@ -35,6 +40,7 @@ class SearchType(Enum):
     VECTOR = "vector" 
     AST = "ast"
     SYMBOL = "symbol"
+    GIT = "git"
 
 
 @dataclass 
@@ -59,8 +65,8 @@ class SearchResult:
 
 
 @dataclass
-class UnifiedSearchResults:
-    """Container for all unified search results."""
+class BatchSearchResults:
+    """Container for all batch search results."""
     query: str
     total_results: int
     results_by_type: Dict[SearchType, List[SearchResult]]
@@ -78,30 +84,34 @@ class UnifiedSearchResults:
         }
 
 
-Pattern = Annotated[str, Field(description="The search pattern/query", min_length=1)]
+Queries = Annotated[List[Dict[str, Any]], Field(description="List of search queries with types", min_items=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)]
+MaxResults = Annotated[int, Field(description="Maximum results per query", default=20)]
 IncludeContext = Annotated[bool, Field(description="Include function/method context", default=True)]
+CombineResults = Annotated[bool, Field(description="Combine and deduplicate results", default=True)]
 
 
-class UnifiedSearchParams(TypedDict):
-    """Parameters for unified search."""
-    pattern: Pattern
-    path: SearchPath
+class BatchSearchParams(TypedDict):
+    """Parameters for batch search.
+    
+    queries format: [
+        {"type": "grep", "pattern": "TODO"},
+        {"type": "vector_search", "query": "error handling"},
+        {"type": "grep_ast", "pattern": "def.*test"},
+        {"type": "git_search", "pattern": "bug fix", "search_type": "commits"}
+    ]
+    """
+    queries: Queries
+    path: SearchPath  
     include: Include
     max_results: MaxResults
-    enable_vector: EnableVector
-    enable_ast: EnableAST
-    enable_symbol: EnableSymbol
     include_context: IncludeContext
+    combine_results: CombineResults
 
 
 @final
-class UnifiedSearchTool(FilesystemBaseTool):
+class BatchSearchTool(FilesystemBaseTool):
     """Unified search tool combining multiple search strategies."""
     
     def __init__(self, permission_manager: PermissionManager, 
@@ -113,6 +123,7 @@ class UnifiedSearchTool(FilesystemBaseTool):
         # Initialize component search tools
         self.grep_tool = Grep(permission_manager)
         self.grep_ast_tool = GrepAstTool(permission_manager)
+        self.git_search_tool = GitSearchTool(permission_manager)
         self.ast_analyzer = ASTAnalyzer()
         
         # Vector search is optional
@@ -128,23 +139,27 @@ class UnifiedSearchTool(FilesystemBaseTool):
     @override
     def name(self) -> str:
         """Get the tool name."""
-        return "unified_search"
+        return "batch_search"
     
     @property  
     @override
     def description(self) -> str:
         """Get the tool description."""
-        return """Intelligent unified search combining grep, vector similarity, AST context, and symbol search.
+        return """Run multiple search queries in parallel across different search types.
+
+Supports running concurrent searches:
+- Multiple grep patterns
+- Multiple vector queries 
+- Multiple AST searches
+- Combined with git history search
 
-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
+Examples:
+- Search for 'config' in code + 'configuration' in docs + 'CONFIG' in constants
+- Find all references to a function across code, comments, and git history
+- Search for concept across different naming conventions
 
-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."""
+Results are intelligently combined, deduplicated, and ranked by relevance.
+Perfect for comprehensive code analysis and refactoring tasks."""
 
     def _detect_search_intent(self, pattern: str) -> Tuple[bool, bool, bool]:
         """Analyze pattern to determine which search types to enable.
@@ -505,22 +520,20 @@ Use this when you need comprehensive search results or aren't sure which search
         return all_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[BatchSearchParams]) -> str:
+        """Execute batch search with multiple queries in parallel."""
         import time
         start_time = time.time()
         
         tool_ctx = self.create_tool_context(ctx)
         
         # Extract parameters
-        pattern = params["pattern"]
+        queries = params["queries"]
         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)
         include_context = params.get("include_context", True)
+        combine_results = params.get("combine_results", True)
         
         # Validate path
         path_validation = self.validate_path(path)
@@ -537,127 +550,237 @@ Use this when you need comprehensive search results or aren't sure which search
         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
+        await tool_ctx.info(f"Starting batch search with {len(queries)} queries in {path}")
         
-        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
+        # Run all queries in parallel
         search_tasks = []
+        query_info = []  # Track query info for results
         
-        # Always run grep first (fastest, most reliable)
-        search_tasks.append(
-            self._run_grep_search(pattern, path, include, tool_ctx, max_results)
-        )
-        
-        if enable_vector and self.vector_tool:
-            search_tasks.append(
-                self._run_vector_search(pattern, path, tool_ctx, max_results)
-            )
-        
-        if enable_ast:
-            search_tasks.append(
-                self._run_ast_search(pattern, path, include, tool_ctx, max_results)
-            )
-        
-        if enable_symbol:
-            search_tasks.append(
-                self._run_symbol_search(pattern, path, tool_ctx, max_results)
-            )
+        for query in queries:
+            query_type = query.get("type", "grep")
+            query_info.append(query)
+            
+            if query_type == "grep":
+                pattern = query.get("pattern")
+                if pattern:
+                    search_tasks.append(
+                        self._run_grep_search(pattern, path, include, tool_ctx, max_results)
+                    )
+            
+            elif query_type == "grep_ast":
+                pattern = query.get("pattern")
+                if pattern:
+                    search_tasks.append(
+                        self._run_ast_search(pattern, path, include, tool_ctx, max_results)
+                    )
+                    
+            elif query_type == "vector_search" and self.vector_tool:
+                search_query = query.get("query") or query.get("pattern")
+                if search_query:
+                    search_tasks.append(
+                        self._run_vector_search(search_query, path, tool_ctx, max_results)
+                    )
+                    
+            elif query_type == "git_search":
+                pattern = query.get("pattern")
+                search_type = query.get("search_type", "content")
+                if pattern:
+                    search_tasks.append(
+                        self._run_git_search(pattern, path, search_type, tool_ctx, max_results)
+                    )
+            
+            else:
+                await tool_ctx.warning(f"Unknown or unavailable search type: {query_type}")
         
         # Execute all searches in parallel
         search_results = await asyncio.gather(*search_tasks, return_exceptions=True)
         
-        # Organize results by type
-        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):
+        # Collect all results
+        all_results = []
+        results_by_query = {}
+        
+        for i, (query, result) in enumerate(zip(query_info, 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
+                await tool_ctx.error(f"Query {i+1} failed: {str(result)}")
+                results_by_query[i] = []
+            else:
+                results_by_query[i] = result
+                all_results.extend(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)
+        # Combine and deduplicate results if requested
+        if combine_results:
+            combined_results = self._combine_results(all_results)
+        else:
+            combined_results = all_results
         
-        # Combine and rank all results
-        combined_results = self._combine_and_rank_results(results_by_type)
+        # Add context if requested
+        if include_context:
+            combined_results = await self._add_context_to_results(combined_results, tool_ctx)
         
         end_time = time.time()
         search_time_ms = (end_time - start_time) * 1000
         
-        # Create unified results object
-        unified_results = UnifiedSearchResults(
-            query=pattern,
+        # Sort by relevance score
+        combined_results.sort(key=lambda r: r.score, reverse=True)
+        
+        # Limit total results
+        combined_results = combined_results[:max_results * 2]  # Allow more when combining
+        
+        # Create batch results object
+        batch_results = BatchSearchResults(
+            query=f"Batch search with {len(queries)} queries",
             total_results=len(combined_results),
-            results_by_type=results_by_type,
-            combined_results=combined_results[:max_results * 2],  # Allow some extra for variety
+            results_by_type={
+                SearchType.GREP: [r for r in combined_results if r.search_type == SearchType.GREP],
+                SearchType.VECTOR: [r for r in combined_results if r.search_type == SearchType.VECTOR],
+                SearchType.AST: [r for r in combined_results if r.search_type == SearchType.AST],
+                SearchType.GIT: [r for r in combined_results if r.search_type == SearchType.GIT],
+            },
+            combined_results=combined_results,
             search_time_ms=search_time_ms
         )
         
         # Format output
-        return self._format_unified_results(unified_results)
+        return self._format_batch_results(batch_results, query_info)
     
-    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():
-            if type_results:
-                lines.append(f"• {search_type.value.title()}: {len(type_results)} results")
-        lines.append("")
+    async def _run_git_search(self, pattern: str, path: str, search_type: str, 
+                             tool_ctx, max_results: int) -> List[SearchResult]:
+        """Run git search and convert results."""
+        await tool_ctx.info(f"Running git search for: {pattern} (type: {search_type})")
         
-        # 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}"
+        try:
+            # Use the git search tool
+            git_result = await self.git_search_tool.call(
+                tool_ctx.mcp_context,
+                pattern=pattern,
+                path=path,
+                search_type=search_type,
+                max_count=max_results
+            )
             
-            lines.append(header)
-            lines.append("-" * len(header))
+            results = []
+            if "Found" in git_result:
+                # Parse git search results - simplified parser
+                lines = git_result.split('\n')
+                current_file = None
+                
+                for line in lines:
+                    if line.strip():
+                        # Extract file path and content
+                        if ':' in line:
+                            parts = line.split(':', 2)
+                            if len(parts) >= 2:
+                                file_path = parts[0].strip()
+                                content = parts[-1].strip() if len(parts) > 2 else line
+                                
+                                result = SearchResult(
+                                    file_path=file_path,
+                                    line_number=None,
+                                    content=content,
+                                    search_type=SearchType.GIT,
+                                    score=0.8,  # Git results are relevant
+                                )
+                                results.append(result)
+                                
+                                if len(results) >= max_results:
+                                    break
             
-            if result.context:
-                lines.append(f"Context: {result.context}")
+            await tool_ctx.info(f"Git search found {len(results)} results")
+            return results
+                        
+        except Exception as e:
+            await tool_ctx.error(f"Git search failed: {str(e)}")
+            return []
+    
+    def _combine_results(self, results: List[SearchResult]) -> List[SearchResult]:
+        """Combine and deduplicate search results."""
+        # Use file path and line number as key for deduplication
+        seen = {}
+        combined = []
+        
+        for result in results:
+            key = (result.file_path, result.line_number)
             
-            lines.append(f"Content: {result.content}")
+            if key not in seen:
+                seen[key] = result
+                combined.append(result)
+            else:
+                # If we've seen this location, keep the one with higher score
+                existing = seen[key]
+                if result.score > existing.score:
+                    # Replace with higher scored result
+                    idx = combined.index(existing)
+                    combined[idx] = result
+                    seen[key] = result
+        
+        return combined
+    
+    async def _add_context_to_results(self, results: List[SearchResult], tool_ctx) -> List[SearchResult]:
+        """Add function/method context to results."""
+        # This is a simplified version - you could enhance with full AST context
+        return await self._add_function_context(results, tool_ctx)
+    
+    def _format_batch_results(self, results: BatchSearchResults, query_info: List[Dict]) -> str:
+        """Format batch search results for display."""
+        output = []
+        
+        # Header
+        output.append(f"=== Batch Search Results ===")
+        output.append(f"Queries: {len(query_info)}")
+        output.append(f"Total results: {results.total_results}")
+        output.append(f"Search time: {results.search_time_ms:.1f}ms\n")
+        
+        # Summary by type
+        output.append("Results by type:")
+        for search_type, type_results in results.results_by_type.items():
+            if type_results:
+                output.append(f"  {search_type.value}: {len(type_results)} results")
+        output.append("")
+        
+        # Query summary
+        output.append("Queries executed:")
+        for i, query in enumerate(query_info):
+            query_type = query.get("type", "grep")
+            pattern = query.get("pattern") or query.get("query", "")
+            output.append(f"  {i+1}. {query_type}: {pattern}")
+        output.append("")
+        
+        # Results
+        if results.combined_results:
+            output.append("=== Top Results ===\n")
             
-            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}")
+            # Group by file
+            results_by_file = {}
+            for result in results.combined_results[:50]:  # Limit display
+                if result.file_path not in results_by_file:
+                    results_by_file[result.file_path] = []
+                results_by_file[result.file_path].append(result)
             
-            lines.append("")
+            # Display results by file
+            for file_path, file_results in results_by_file.items():
+                output.append(f"{file_path}")
+                output.append("-" * len(file_path))
+                
+                # Sort by line number if available
+                file_results.sort(key=lambda r: r.line_number or 0)
+                
+                for result in file_results:
+                    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}")
+                    
+                    if result.context:
+                        output.append(f"         Context: {result.context}")
+                
+                output.append("")
+        else:
+            output.append("No results found.")
         
-        return "\n".join(lines)
+        return "\n".join(output)
+    
     
     @override
     def register(self, mcp_server: FastMCP) -> None: