hanzo-mcp 0.8.11__py3-none-any.whl → 0.8.13__py3-none-any.whl

hanzo_mcp/tools/search/unified_search.py

@@ -171,9 +171,7 @@ class UnifiedSearch(BaseTool):
         # Use vector search for natural language queries
         indicators = [
             len(query.split()) > 2,  # Multi-word queries
-            not any(
-                c in query for c in ["(", ")", "{", "}", "[", "]"]
-            ),  # Not code syntax
+            not any(c in query for c in ["(", ")", "{", "}", "[", "]"]),  # Not code syntax
             " " in query,  # Has spaces (natural language)
             not query.startswith("^") and not query.endswith("$"),  # Not regex anchors
         ]
@@ -185,10 +183,7 @@ class UnifiedSearch(BaseTool):
         indicators = [
             "class " in query or "function " in query or "def " in query,
             "import " in query or "from " in query,
-            any(
-                kw in query.lower()
-                for kw in ["method", "function", "class", "interface", "struct"]
-            ),
+            any(kw in query.lower() for kw in ["method", "function", "class", "interface", "struct"]),
             "::" in query or "->" in query or "." in query,  # Member access
         ]
         return any(indicators)
@@ -198,9 +193,7 @@ class UnifiedSearch(BaseTool):
         # Use symbol search for identifiers
         return (
             len(query.split()) <= 2  # Short queries
-            and query.replace("_", "")
-            .replace("-", "")
-            .isalnum()  # Looks like identifier
+            and query.replace("_", "").replace("-", "").isalnum()  # Looks like identifier
             and not " " in query.strip()  # Single token
         )
 
@@ -243,19 +236,14 @@ class UnifiedSearch(BaseTool):
             # Search memory for natural language queries or specific references
             search_memory = MEMORY_AVAILABLE and (
                 self._should_use_vector_search(pattern)
-                or any(
-                    word in pattern.lower()
-                    for word in ["previous", "discussion", "remember", "last"]
-                )
+                or any(word in pattern.lower() for word in ["previous", "discussion", "remember", "last"])
             )
 
         if enable_text is None:
             enable_text = True  # Always use text search as baseline
 
         if enable_vector is None:
-            enable_vector = (
-                self._should_use_vector_search(pattern) and VECTOR_SEARCH_AVAILABLE
-            )
+            enable_vector = self._should_use_vector_search(pattern) and VECTOR_SEARCH_AVAILABLE
 
         if enable_ast is None:
             enable_ast = self._should_use_ast_search(pattern) and TREESITTER_AVAILABLE
@@ -277,9 +265,7 @@ class UnifiedSearch(BaseTool):
         # 1. Text search (ripgrep) - always fast, do first
         if enable_text:
             start = time.time()
-            text_results = await self._text_search(
-                pattern, path, include, exclude, max_results_per_type, context_lines
-            )
+            text_results = await self._text_search(pattern, path, include, exclude, max_results_per_type, context_lines)
             search_stats["time_ms"]["text"] = int((time.time() - start) * 1000)
             search_stats["search_types_used"].append("text")
             all_results.extend(text_results)
@@ -287,9 +273,7 @@ class UnifiedSearch(BaseTool):
         # 2. AST search - for code structure
         if enable_ast and TREESITTER_AVAILABLE:
             start = time.time()
-            ast_results = await self._ast_search(
-                pattern, path, include, exclude, max_results_per_type, context_lines
-            )
+            ast_results = await self._ast_search(pattern, path, include, exclude, max_results_per_type, context_lines)
             search_stats["time_ms"]["ast"] = int((time.time() - start) * 1000)
             search_stats["search_types_used"].append("ast")
             all_results.extend(ast_results)
@@ -297,9 +281,7 @@ class UnifiedSearch(BaseTool):
         # 3. Symbol search - for definitions
         if enable_symbol:
             start = time.time()
-            symbol_results = await self._symbol_search(
-                pattern, path, include, exclude, max_results_per_type
-            )
+            symbol_results = await self._symbol_search(pattern, path, include, exclude, max_results_per_type)
             search_stats["time_ms"]["symbol"] = int((time.time() - start) * 1000)
             search_stats["search_types_used"].append("symbol")
             all_results.extend(symbol_results)
@@ -317,9 +299,7 @@ class UnifiedSearch(BaseTool):
         # 5. File search - for finding files by name/pattern
         if search_files:
             start = time.time()
-            file_results = await self._file_search(
-                pattern, path, include, exclude, max_results_per_type
-            )
+            file_results = await self._file_search(pattern, path, include, exclude, max_results_per_type)
             search_stats["time_ms"]["files"] = int((time.time() - start) * 1000)
             search_stats["search_types_used"].append("files")
             all_results.extend(file_results)
@@ -327,9 +307,7 @@ class UnifiedSearch(BaseTool):
         # 6. Memory search - for knowledge base and previous discussions
         if search_memory:
             start = time.time()
-            memory_results = await self._memory_search(
-                pattern, max_results_per_type, context_lines
-            )
+            memory_results = await self._memory_search(pattern, max_results_per_type, context_lines)
             search_stats["time_ms"]["memory"] = int((time.time() - start) * 1000)
             search_stats["search_types_used"].append("memory")
             all_results.extend(memory_results)
@@ -428,9 +406,7 @@ class UnifiedSearch(BaseTool):
 
         if not self.ripgrep_available:
             # Fallback to Python implementation
-            return await self._python_text_search(
-                pattern, path, include, exclude, max_results, context_lines
-            )
+            return await self._python_text_search(pattern, path, include, exclude, max_results, context_lines)
 
         # Build ripgrep command
         cmd = ["rg", "--json", "--max-count", str(max_results)]
@@ -547,17 +523,9 @@ class UnifiedSearch(BaseTool):
                             file_path=str(file_path),
                             line_number=line_num,
                             column=0,
-                            match_text=(
-                                lines[line_num - 1]
-                                if 0 < line_num <= len(lines)
-                                else ""
-                            ),
-                            context_before=lines[
-                                max(0, line_num - context_lines - 1) : line_num - 1
-                            ],
-                            context_after=lines[
-                                line_num : min(len(lines), line_num + context_lines)
-                            ],
+                            match_text=(lines[line_num - 1] if 0 < line_num <= len(lines) else ""),
+                            context_before=lines[max(0, line_num - context_lines - 1) : line_num - 1],
+                            context_after=lines[line_num : min(len(lines), line_num + context_lines)],
                             match_type="ast",
                             score=0.9,
                             node_type="ast_match",
@@ -650,10 +618,7 @@ class UnifiedSearch(BaseTool):
                         context_before=[],
                         context_after=[],
                         match_type="vector",
-                        score=1.0
-                        - search_results["distances"][0][
-                            i
-                        ],  # Convert distance to similarity
+                        score=1.0 - search_results["distances"][0][i],  # Convert distance to similarity
                         semantic_context=metadata.get("context", ""),
                     )
                     results.append(result)
@@ -712,9 +677,7 @@ class UnifiedSearch(BaseTool):
 
         return results
 
-    async def _memory_search(
-        self, query: str, max_results: int, context_lines: int
-    ) -> List[SearchResult]:
+    async def _memory_search(self, query: str, max_results: int, context_lines: int) -> List[SearchResult]:
         """Search in memory/knowledge base."""
         results = []
 
@@ -748,9 +711,7 @@ class UnifiedSearch(BaseTool):
                         file_path=virtual_path,
                         line_number=1,
                         column=0,
-                        match_text=(
-                            content[:200] + "..." if len(content) > 200 else content
-                        ),
+                        match_text=(content[:200] + "..." if len(content) > 200 else content),
                         context_before=[],
                         context_after=[],
                         match_type="memory",
@@ -793,9 +754,7 @@ class UnifiedSearch(BaseTool):
 
         return unique
 
-    def _rank_results(
-        self, results: List[SearchResult], query: str
-    ) -> List[SearchResult]:
+    def _rank_results(self, results: List[SearchResult], query: str) -> List[SearchResult]:
         """Rank results by relevance."""
         # Simple ranking based on:
         # 1. Match type score
@@ -808,16 +767,11 @@ class UnifiedSearch(BaseTool):
                 result.score *= 1.2
 
             # Path relevance (prefer non-test, non-vendor files)
-            if any(
-                skip in result.file_path for skip in ["test", "vendor", "node_modules"]
-            ):
+            if any(skip in result.file_path for skip in ["test", "vendor", "node_modules"]):
                 result.score *= 0.8
 
             # Prefer definition files
-            if any(
-                pattern in result.file_path
-                for pattern in ["index.", "main.", "api.", "types."]
-            ):
+            if any(pattern in result.file_path for pattern in ["index.", "main.", "api.", "types."]):
                 result.score *= 1.1
 
         # Sort by score descending, then by file path
@@ -955,13 +909,9 @@ class CodeIndexer:
         # Batch embed and store
         if documents:
             embeddings = self.embedder.encode(documents).tolist()
-            self.collection.add(
-                embeddings=embeddings, documents=documents, metadatas=metadatas, ids=ids
-            )
+            self.collection.add(embeddings=embeddings, documents=documents, metadatas=metadatas, ids=ids)
 
-    def _split_code_intelligently(
-        self, content: str, file_path: Path
-    ) -> List[Dict[str, Any]]:
+    def _split_code_intelligently(self, content: str, file_path: Path) -> List[Dict[str, Any]]:
         """Split code into meaningful chunks."""
         # Simple line-based splitting for now
         # TODO: Use AST for better splitting
@@ -976,9 +926,7 @@ class CodeIndexer:
             current_chunk.append(line)
 
             # Split on function/class definitions or every 50 lines
-            if len(current_chunk) >= 50 or any(
-                kw in line for kw in ["def ", "function ", "class ", "interface "]
-            ):
+            if len(current_chunk) >= 50 or any(kw in line for kw in ["def ", "function ", "class ", "interface "]):
                 if current_chunk:
                     chunks.append(
                         {
@@ -992,9 +940,7 @@ class CodeIndexer:
 
         # Add remaining
         if current_chunk:
-            chunks.append(
-                {"text": "\n".join(current_chunk), "line": current_line, "type": "code"}
-            )
+            chunks.append({"text": "\n".join(current_chunk), "line": current_line, "type": "code"})
 
         return chunks
 

hanzo_mcp/tools/shell/__init__.py

@@ -49,8 +49,8 @@ def get_shell_tools(
     # Return shell_tool first (smart default), then specific shells
     return [
         shell_tool,  # Smart shell (prefers zsh if available)
-        zsh_tool,    # Explicit zsh
-        bash_tool,   # Explicit bash
+        zsh_tool,  # Explicit zsh
+        bash_tool,  # Explicit bash
         npx_tool,
         uvx_tool,
         process_tool,

hanzo_mcp/tools/shell/auto_background.py

@@ -19,9 +19,7 @@ class AutoBackgroundExecutor:
     # Default timeout before auto-backgrounding (2 minutes)
     DEFAULT_TIMEOUT = 120.0
 
-    def __init__(
-        self, process_manager: ProcessManager, timeout: float = DEFAULT_TIMEOUT
-    ):
+    def __init__(self, process_manager: ProcessManager, timeout: float = DEFAULT_TIMEOUT):
         """Initialize the auto-background executor.
 
         Args:
@@ -148,9 +146,7 @@ class AutoBackgroundExecutor:
                     task.cancel()
 
                 # Continue reading output in background
-                asyncio.create_task(
-                    self._background_reader(process, process_id, log_file)
-                )
+                asyncio.create_task(self._background_reader(process, process_id, log_file))
 
                 # Return status message
                 elapsed = time.time() - start_time

hanzo_mcp/tools/shell/base.py

@@ -63,11 +63,7 @@ class CommandResult:
         Returns:
             True if the command succeeded, False otherwise
         """
-        return (
-            self.return_code == 0
-            and self.status == BashCommandStatus.COMPLETED
-            and not self.error_message
-        )
+        return self.return_code == 0 and self.status == BashCommandStatus.COMPLETED and not self.error_message
 
     @property
     def is_running(self) -> bool:

hanzo_mcp/tools/shell/base_process.py

@@ -171,13 +171,11 @@ class BaseProcessTool(BaseTool):
             process_env.update(env)
 
         # Execute with auto-backgrounding
-        output, was_backgrounded, process_id = (
-            await self.auto_background_executor.execute_with_auto_background(
-                cmd_args=cmd_args,
-                tool_name=self.get_tool_name(),
-                cwd=cwd,
-                env=process_env,
-            )
+        output, was_backgrounded, process_id = await self.auto_background_executor.execute_with_auto_background(
+            cmd_args=cmd_args,
+            tool_name=self.get_tool_name(),
+            cwd=cwd,
+            env=process_env,
         )
 
         if was_backgrounded:

hanzo_mcp/tools/shell/bash_session.py

@@ -84,11 +84,7 @@ def escape_bash_special_chars(command: str) -> str:
 
         def visit_node(node: Any) -> None:
             nonlocal last_pos
-            if (
-                node.kind == "redirect"
-                and hasattr(node, "heredoc")
-                and node.heredoc is not None
-            ):
+            if node.kind == "redirect" and hasattr(node, "heredoc") and node.heredoc is not None:
                 # We're entering a heredoc - preserve everything as-is until we see EOF
                 between = command[last_pos : node.pos[0]]
                 parts.append(between)
@@ -414,15 +410,11 @@ class BashSession:
                 "> ",  # generic
                 ">",  # generic without space
             ]
-            output_ends_with_prompt = any(
-                cur_pane_output.rstrip().endswith(pattern)
-                for pattern in prompt_patterns
-            )
+            output_ends_with_prompt = any(cur_pane_output.rstrip().endswith(pattern) for pattern in prompt_patterns)
 
             # Also check for username@hostname pattern (common in many shells)
             has_user_host_pattern = "@" in cur_pane_output and any(
-                cur_pane_output.rstrip().endswith(indicator)
-                for indicator in prompt_patterns
+                cur_pane_output.rstrip().endswith(indicator) for indicator in prompt_patterns
             )
 
             if output_ends_with_prompt or has_user_host_pattern:
@@ -430,10 +422,7 @@ class BashSession:
 
             # 2) No-change timeout (only if not blocking)
             time_since_last_change = time.time() - last_change_time
-            if (
-                not blocking
-                and time_since_last_change >= self.NO_CHANGE_TIMEOUT_SECONDS
-            ):
+            if not blocking and time_since_last_change >= self.NO_CHANGE_TIMEOUT_SECONDS:
                 # Extract current output
                 lines = cur_pane_output.strip().split("\n")
                 output = "\n".join(lines)
@@ -497,9 +486,7 @@ class BashSession:
             session_id=self.id,
         )
 
-    def _handle_nochange_timeout_command(
-        self, command: str, pane_content: str
-    ) -> CommandResult:
+    def _handle_nochange_timeout_command(self, command: str, pane_content: str) -> CommandResult:
         """Handle a command that timed out due to no output changes."""
         self.prev_status = BashCommandStatus.NO_CHANGE_TIMEOUT
 
@@ -530,9 +517,7 @@ class BashSession:
             session_id=self.id,
         )
 
-    def _handle_hard_timeout_command(
-        self, command: str, pane_content: str, timeout: float
-    ) -> CommandResult:
+    def _handle_hard_timeout_command(self, command: str, pane_content: str, timeout: float) -> CommandResult:
         """Handle a command that hit the hard timeout."""
         self.prev_status = BashCommandStatus.HARD_TIMEOUT
 
@@ -563,9 +548,7 @@ class BashSession:
             session_id=self.id,
         )
 
-    def _fallback_completion_detection(
-        self, command: str, pane_content: str
-    ) -> CommandResult:
+    def _fallback_completion_detection(self, command: str, pane_content: str) -> CommandResult:
         """Fallback completion detection when PS1 metadata is not available."""
         # Use the old logic as fallback
         self.pane.send_keys("echo EXIT_CODE:$?", enter=True)

hanzo_mcp/tools/shell/bash_session_executor.py

@@ -44,9 +44,7 @@ class BashSessionExecutor:
         self.fast_test_mode: bool = fast_test_mode
 
         # If no session manager is provided, create a non-singleton instance to avoid shared state
-        self.session_manager: SessionManager = session_manager or SessionManager(
-            use_singleton=False
-        )
+        self.session_manager: SessionManager = session_manager or SessionManager(use_singleton=False)
 
         # Excluded commands or patterns (for compatibility)
         self.excluded_commands: list[str] = ["rm"]
@@ -146,9 +144,7 @@ class BashSessionExecutor:
         Returns:
             CommandResult containing execution results
         """
-        self._log(
-            f"Executing command: {command} (is_input={is_input}, blocking={blocking})"
-        )
+        self._log(f"Executing command: {command} (is_input={is_input}, blocking={blocking})")
 
         # Check if the command is allowed (skip for input to running processes)
         if not is_input and not self.is_command_allowed(command):
@@ -183,9 +179,7 @@ class BashSessionExecutor:
             if session is None:
                 # Use faster timeouts and polling for tests
                 if self.fast_test_mode:
-                    timeout_seconds = (
-                        10  # Faster timeout for tests but not too aggressive
-                    )
+                    timeout_seconds = 10  # Faster timeout for tests but not too aggressive
                     poll_interval = 0.2  # Faster polling for tests but still reasonable
                 else:
                     timeout_seconds = 30  # Default timeout
@@ -206,9 +200,7 @@ class BashSessionExecutor:
                         self._log(f"Failed to set environment variable {key}")
 
             # Execute the command with enhanced parameters
-            result = session.execute(
-                command=command, is_input=is_input, blocking=blocking, timeout=timeout
-            )
+            result = session.execute(command=command, is_input=is_input, blocking=blocking, timeout=timeout)
 
             # Add session_id to the result
             result.session_id = effective_session_id
@@ -257,9 +249,7 @@ class BashSessionExecutor:
 
             # Wait for completion with timeout
             try:
-                stdout, stderr = await asyncio.wait_for(
-                    process.communicate(), timeout=timeout
-                )
+                stdout, stderr = await asyncio.wait_for(process.communicate(), timeout=timeout)
             except asyncio.TimeoutError:
                 # Kill the process if it times out
                 process.kill()

hanzo_mcp/tools/shell/bash_tool.py

@@ -28,9 +28,7 @@ class BashTool(BaseScriptTool):
             env: Optional[dict[str, str]] = None,
             timeout: Optional[int] = None,
         ) -> str:
-            return await tool_self.run(
-                ctx, command=command, cwd=cwd, env=env, timeout=timeout
-            )
+            return await tool_self.run(ctx, command=command, cwd=cwd, env=env, timeout=timeout)
 
     async def call(self, ctx: MCPContext, **params) -> str:
         """Call the tool with arguments."""
@@ -71,7 +69,7 @@ bash "npm run dev" --cwd ./frontend  # Auto-backgrounds if needed"""
                 if Path(path).exists():
                     return path
             return "cmd.exe"  # Fall back to cmd if no bash found
-        
+
         # On Unix-like systems, always use bash
         return "bash"
 
@@ -112,9 +110,7 @@ bash "npm run dev" --cwd ./frontend  # Auto-backgrounds if needed"""
         work_dir = Path(cwd).resolve() if cwd else Path.cwd()
 
         # Always use execute_sync which now has auto-backgrounding
-        output = await self.execute_sync(
-            command, cwd=work_dir, env=env, timeout=timeout
-        )
+        output = await self.execute_sync(command, cwd=work_dir, env=env, timeout=timeout)
         return output if output else "Command completed successfully (no output)"