hanzo-mcp 0.7.6__py3-none-any.whl → 0.8.0__py3-none-any.whl

hanzo_mcp/tools/filesystem/search_tool.py

@@ -10,28 +10,37 @@ This tool consolidates all search capabilities and runs them concurrently:
 Results are combined, deduplicated, and ranked for comprehensive search coverage.
 """
 
-import asyncio
 import re
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Annotated, Dict, List, Optional, Set, Tuple, TypedDict, Unpack, final, override
+import asyncio
 from enum import Enum
+from typing import (
+    Dict,
+    List,
+    Unpack,
+    Optional,
+    Annotated,
+    TypedDict,
+    final,
+    override,
+)
+from dataclasses import dataclass
 
-from mcp.server.fastmcp import Context as MCPContext
-from mcp.server import FastMCP
 from pydantic import Field
+from mcp.server import FastMCP
+from mcp.server.fastmcp import Context as MCPContext
 
 from hanzo_mcp.tools.filesystem.base import FilesystemBaseTool
 from hanzo_mcp.tools.filesystem.grep import Grep
-from hanzo_mcp.tools.filesystem.symbols_tool import SymbolsTool
-from hanzo_mcp.tools.filesystem.git_search import GitSearchTool
-from hanzo_mcp.tools.vector.vector_search import VectorSearchTool
 from hanzo_mcp.tools.common.permissions import PermissionManager
+from hanzo_mcp.tools.vector.vector_search import VectorSearchTool
+from hanzo_mcp.tools.filesystem.git_search import GitSearchTool
 from hanzo_mcp.tools.vector.project_manager import ProjectVectorManager
+from hanzo_mcp.tools.filesystem.symbols_tool import SymbolsTool
 
 
 class SearchType(Enum):
     """Types of searches that can be performed."""
+
     GREP = "grep"
     GREP_AST = "grep_ast"
     VECTOR = "vector"
@@ -42,6 +51,7 @@ class SearchType(Enum):
 @dataclass
 class SearchResult:
     """Search result from any search type."""
+
     file_path: str
     line_number: Optional[int]
     content: str
@@ -134,6 +144,7 @@ IncludeContext = Annotated[
 
 class UnifiedSearchParams(TypedDict):
     """Parameters for search."""
+
     pattern: Pattern
     path: SearchPath
     include: Include
@@ -149,34 +160,37 @@ class UnifiedSearchParams(TypedDict):
 @final
 class SearchTool(FilesystemBaseTool):
     """Search tool that runs multiple search types in parallel."""
-    
-    def __init__(self, permission_manager: PermissionManager, 
-                 project_manager: Optional[ProjectVectorManager] = None):
+
+    def __init__(
+        self,
+        permission_manager: PermissionManager,
+        project_manager: Optional[ProjectVectorManager] = None,
+    ):
         """Initialize the 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 tools
         self.grep_tool = Grep(permission_manager)
         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)
-    
+
     @property
     @override
     def name(self) -> str:
         """Get the tool name."""
         return "search"
-    
+
     @property
     @override
     def description(self) -> str:
@@ -200,75 +214,76 @@ Examples:
 - 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:
             Dictionary of search type recommendations
         """
         # Check if pattern looks like regex
-        regex_chars = r'[.*+?^${}()|[\]\\]'
+        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))
-        
+        is_symbol = bool(re.match(r"^[a-zA-Z_][a-zA-Z0-9_]*$", pattern))
+
         # Check if pattern is natural language
         words = pattern.split()
         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
+            "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,
-                              tool_ctx, max_results: int) -> List[SearchResult]:
+
+    async def _run_grep_search(
+        self, pattern: str, path: str, include: str, tool_ctx, max_results: int
+    ) -> List[SearchResult]:
         """Run grep search and parse results."""
         try:
             result = await self.grep_tool.call(
-                tool_ctx.mcp_context,
-                pattern=pattern,
-                path=path,
-                include=include
+                tool_ctx.mcp_context, pattern=pattern, path=path, include=include
             )
-            
+
             results = []
             if "Found" in result and "matches" in result:
-                lines = result.split('\n')
+                lines = result.split("\n")
                 for line in lines[2:]:  # Skip header
-                    if ':' in line and line.strip():
+                    if ":" in line and line.strip():
                         try:
-                            parts = line.split(':', 2)
+                            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.GREP,
-                                    score=1.0  # Exact matches get perfect score
-                                ))
+                                results.append(
+                                    SearchResult(
+                                        file_path=parts[0],
+                                        line_number=int(parts[1]),
+                                        content=parts[2].strip(),
+                                        search_type=SearchType.GREP,
+                                        score=1.0,  # Exact matches get perfect score
+                                    )
+                                )
                                 if len(results) >= max_results:
                                     break
                         except ValueError:
                             continue
-            
+
             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]:
+
+    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(
@@ -276,107 +291,117 @@ This is the recommended search tool for comprehensive results."""
                 pattern=pattern,
                 path=path,
                 ignore_case=True,
-                line_number=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:
+
+                for line in result.split("\n"):
+                    if line.endswith(":") and "/" in line:
                         current_file = line[:-1]
                         current_context = []
-                    elif current_file and ':' in line:
+                    elif current_file and ":" in line:
                         try:
                             # Try to parse line with number
-                            parts = line.split(':', 1)
+                            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
-                            ))
-                            
+
+                            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"AST search failed: {e}")
             return []
-    
-    async def _run_vector_search(self, pattern: str, path: str,
-                                tool_ctx, max_results: int) -> List[SearchResult]:
+
+    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 []
-            
+
         try:
             # Determine search scope
             search_scope = "current" if path == "." else "all"
-            
+
             result = await self.vector_tool.call(
                 tool_ctx.mcp_context,
                 query=pattern,
                 limit=max_results,
                 score_threshold=0.3,
                 search_scope=search_scope,
-                include_content=True
+                include_content=True,
             )
-            
+
             results = []
             if "Found" in result:
                 # Parse vector search results
-                lines = result.split('\n')
+                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 and file
-                        score_match = re.search(r'Score: ([\d.]+)%', line)
+                        score_match = re.search(r"Score: ([\d.]+)%", line)
                         if score_match:
                             current_score = float(score_match.group(1)) / 100.0
-                        
-                        file_match = re.search(r' - ([^\s]+)$', line)
+
+                        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('-'):
+
+                    elif current_file and line.strip() and not line.startswith("-"):
                         # Content line
-                        results.append(SearchResult(
-                            file_path=current_file,
-                            line_number=None,
-                            content=line.strip()[:200],  # Limit content length
-                            search_type=SearchType.VECTOR,
-                            score=current_score
-                        ))
-                        
+                        results.append(
+                            SearchResult(
+                                file_path=current_file,
+                                line_number=None,
+                                content=line.strip()[:200],  # Limit content length
+                                search_type=SearchType.VECTOR,
+                                score=current_score,
+                            )
+                        )
+
                         if len(results) >= max_results:
                             break
-            
+
             await tool_ctx.info(f"Vector search found {len(results)} results")
             return results
-            
+
         except Exception as e:
             await tool_ctx.error(f"Vector search failed: {e}")
             return []
-    
-    async def _run_git_search(self, pattern: str, path: str,
-                             tool_ctx, max_results: int) -> List[SearchResult]:
+
+    async def _run_git_search(
+        self, pattern: str, path: str, tool_ctx, max_results: int
+    ) -> List[SearchResult]:
         """Run git history search."""
         try:
             # Search in both content and commits
@@ -386,51 +411,58 @@ This is the recommended search tool for comprehensive results."""
                     pattern=pattern,
                     path=path,
                     search_type="content",
-                    max_count=max_results // 2
+                    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
-                )
+                    max_count=max_results // 2,
+                ),
             ]
-            
+
             git_results = await asyncio.gather(*tasks, return_exceptions=True)
-            
+
             results = []
-            for i, result in enumerate(git_results):
+            for _i, result in enumerate(git_results):
                 if isinstance(result, Exception):
                     continue
-                    
+
                 if "Found" in result:
                     # Parse git results
-                    lines = result.split('\n')
+                    lines = result.split("\n")
                     for line in lines:
-                        if ':' in line and line.strip():
-                            parts = line.split(':', 2)
+                        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
-                                ))
-                                
+                                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
-            
+
             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: {e}")
             return []
-    
-    async def _run_symbol_search(self, pattern: str, path: str,
-                                tool_ctx, max_results: int) -> List[SearchResult]:
+
+    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:
             # Create patterns for common symbol definitions
@@ -441,67 +473,68 @@ This is the recommended search tool for comprehensive results."""
                 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="*"
+                        tool_ctx.mcp_context, pattern=sp, path=path, include="*"
                     )
                 )
-            
+
             grep_results = await asyncio.gather(*tasks, return_exceptions=True)
-            
+
             results = []
             for result in grep_results:
                 if isinstance(result, Exception):
                     continue
-                    
+
                 if "Found" in result and "matches" in result:
-                    lines = result.split('\n')
+                    lines = result.split("\n")
                     for line in lines[2:]:  # Skip header
-                        if ':' in line and line.strip():
+                        if ":" in line and line.strip():
                             try:
-                                parts = line.split(':', 2)
+                                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
-                                    ))
+                                    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: {e}")
             return []
-    
-    def _deduplicate_results(self, all_results: List[SearchResult]) -> List[SearchResult]:
+
+    def _deduplicate_results(
+        self, all_results: List[SearchResult]
+    ) -> List[SearchResult]:
         """Deduplicate results, keeping the highest scoring version."""
         seen = {}
-        
+
         for result in all_results:
             key = (result.file_path, result.line_number)
-            
+
             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 list(seen.values())
-    
+
     def _rank_results(self, results: List[SearchResult]) -> List[SearchResult]:
         """Rank results by relevance score and search type priority."""
         # Define search type priorities
@@ -510,17 +543,16 @@ This is the recommended search tool for comprehensive results."""
             SearchType.GREP: 4,
             SearchType.GREP_AST: 3,
             SearchType.GIT: 2,
-            SearchType.VECTOR: 1
+            SearchType.VECTOR: 1,
         }
-        
+
         # 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
+            key=lambda r: (r.score, type_priority.get(r.search_type, 0)), reverse=True
         )
-        
+
         return results
-    
+
     @override
     async def call(
         self,
@@ -529,71 +561,88 @@ This is the recommended search tool for comprehensive results."""
     ) -> str:
         """Execute search across all enabled search types."""
         import time
+
         start_time = time.time()
-        
+
         tool_ctx = self.create_tool_context(ctx)
-        
+
         # Extract parameters
         pattern = params["pattern"]
         path = params.get("path", ".")
         include = params.get("include", "*")
         max_results = params.get("max_results", 50)
         include_context = params.get("include_context", True)
-        
+
         # Validate path
         path_validation = self.validate_path(path)
         if path_validation.is_error:
             await tool_ctx.error(path_validation.error_message)
             return f"Error: {path_validation.error_message}"
-        
+
         # 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 pattern to determine best search strategies
         pattern_analysis = self._analyze_pattern(pattern)
-        
+
         await tool_ctx.info(f"Starting search for '{pattern}' in {path}")
-        
+
         # Build list of search tasks based on enabled types and pattern analysis
         search_tasks = []
         search_names = []
-        
-        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))
+
+        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 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))
+
+        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 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))
+
+        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 params.get("enable_git", True) and pattern_analysis['use_git']:
-            search_tasks.append(self._run_git_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))
+
+        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")
-        
-        await tool_ctx.info(f"Running {len(search_tasks)} search types in parallel: {', '.join(search_names)}")
-        
+
+        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)
-        
+
         # Collect all results
         all_results = []
         results_by_type = {}
-        
+
         for search_type, results in zip(search_names, search_results):
             if isinstance(results, Exception):
                 await tool_ctx.error(f"{search_type} search failed: {results}")
@@ -601,87 +650,94 @@ This is the recommended search tool for comprehensive results."""
             else:
                 results_by_type[search_type] = results
                 all_results.extend(results)
-        
+
         # Deduplicate and rank results
         unique_results = self._deduplicate_results(all_results)
         ranked_results = self._rank_results(unique_results)
-        
+
         # Limit total results
         final_results = ranked_results[:max_results]
-        
+
         # Calculate search time
         search_time = (time.time() - start_time) * 1000
-        
+
         # Format output
         return self._format_results(
             pattern=pattern,
             results=final_results,
             results_by_type=results_by_type,
             search_time_ms=search_time,
-            include_context=include_context
+            include_context=include_context,
         )
-    
-    def _format_results(self, pattern: str, results: List[SearchResult],
-                       results_by_type: Dict[str, List[SearchResult]],
-                       search_time_ms: float, include_context: bool) -> str:
+
+    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:
                 output.append(f"  {search_type}: {len(type_results)} matches")
-        
+
         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))
-            
+
             # Sort by line number
             file_results.sort(key=lambda r: r.line_number or 0)
-            
+
             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}")
+                    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}")
-            
+
             output.append("")  # Empty line between files
-        
+
         return "\n".join(output)
-    
+
     @override
     def register(self, mcp_server: FastMCP) -> None:
         """Register the search tool with the MCP server."""
         tool_self = self
-        
+
         @mcp_server.tool(name=self.name, description=self.description)
         async def search(
             ctx: MCPContext,
@@ -708,4 +764,4 @@ This is the recommended search tool for comprehensive results."""
                 enable_git=enable_git,
                 enable_symbol=enable_symbol,
                 include_context=include_context,
-            )
+            )