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

hanzo_mcp/tools/filesystem/find_files.py

@@ -335,9 +335,7 @@ For database search, use 'sql_search' or 'vector_search'.
                 return f"No files found matching '{pattern}' (using fallback search)"
 
             # Format output
-            output = [
-                f"Found {len(results)} file(s) matching '{pattern}' (using fallback search):"
-            ]
+            output = [f"Found {len(results)} file(s) matching '{pattern}' (using fallback search):"]
             output.append("")
 
             for filepath in sorted(results):
@@ -346,9 +344,7 @@ For database search, use 'sql_search' or 'vector_search'.
             if count >= max_results:
                 output.append(f"\n... (showing first {max_results} results)")
 
-            output.append(
-                "\nNote: Install 'ffind' for faster searching: pip install ffind"
-            )
+            output.append("\nNote: Install 'ffind' for faster searching: pip install ffind")
 
             return "\n".join(output)
 

hanzo_mcp/tools/filesystem/git_search.py

@@ -256,9 +256,7 @@ Examples:
                     tool_ctx,
                 )
             elif search_type == "blame":
-                return await self._search_blame(
-                    abs_path, pattern, case_sensitive, file_pattern, tool_ctx
-                )
+                return await self._search_blame(abs_path, pattern, case_sensitive, file_pattern, tool_ctx)
             else:
                 return f"Unknown search type: {search_type}"
 
@@ -307,9 +305,7 @@ Examples:
         elif result.returncode == 1:
             return f"No matches found for pattern: {pattern}"
         else:
-            raise subprocess.CalledProcessError(
-                result.returncode, cmd, result.stdout, result.stderr
-            )
+            raise subprocess.CalledProcessError(result.returncode, cmd, result.stdout, result.stderr)
 
     async def _search_commits(
         self,
@@ -353,16 +349,11 @@ Examples:
             lines = result.stdout.strip().split("\n")
             if lines and lines[0]:
                 await tool_ctx.info(f"Found {len(lines)} commits")
-                return (
-                    f"Found {len(lines)} commits matching '{pattern}':\n\n"
-                    + result.stdout
-                )
+                return f"Found {len(lines)} commits matching '{pattern}':\n\n" + result.stdout
             else:
                 return f"No commits found matching: {pattern}"
         else:
-            raise subprocess.CalledProcessError(
-                result.returncode, cmd, result.stdout, result.stderr
-            )
+            raise subprocess.CalledProcessError(result.returncode, cmd, result.stdout, result.stderr)
 
     async def _search_diff(
         self,
@@ -387,8 +378,7 @@ Examples:
             import re
 
             case_insensitive_pattern = "".join(
-                f"[{c.upper()}{c.lower()}]" if c.isalpha() else re.escape(c)
-                for c in pattern
+                f"[{c.upper()}{c.lower()}]" if c.isalpha() else re.escape(c) for c in pattern
             )
             search_flag = f"-G{case_insensitive_pattern}"
 
@@ -415,9 +405,7 @@ Examples:
 
         if result.returncode == 0 and result.stdout.strip():
             # Parse and highlight matching lines
-            output = self._highlight_diff_matches(
-                result.stdout, pattern, case_sensitive
-            )
+            output = self._highlight_diff_matches(result.stdout, pattern, case_sensitive)
             matches = output.count("commit ")
             await tool_ctx.info(f"Found {matches} commits with changes")
             return f"Found {matches} commits with changes matching '{pattern}':\n\n{output}"
@@ -505,9 +493,8 @@ Examples:
 
         if all_matches:
             await tool_ctx.info(f"Found {len(all_matches)} matching lines")
-            return (
-                f"Found {len(all_matches)} lines matching '{pattern}':\n\n"
-                + "\n".join(all_matches[:50])
+            return f"Found {len(all_matches)} lines matching '{pattern}':\n\n" + "\n".join(
+                all_matches[:50]
             )  # Limit output
         else:
             return f"No lines found matching: {pattern}"
@@ -534,9 +521,7 @@ Examples:
 
         return f"Found matches for '{pattern}':\n" + "\n".join(output)
 
-    def _highlight_diff_matches(
-        self, diff_output: str, pattern: str, case_sensitive: bool
-    ) -> str:
+    def _highlight_diff_matches(self, diff_output: str, pattern: str, case_sensitive: bool) -> str:
         """Highlight matching lines in diff output."""
         lines = diff_output.split("\n")
         output = []

hanzo_mcp/tools/filesystem/grep.py

@@ -118,9 +118,7 @@ When you are doing an open ended search that may require multiple rounds of glob
         # Special case for tests: direct file path with include pattern that doesn't match
         if Path(path).is_file() and include_pattern and include_pattern != "*":
             if not fnmatch.fnmatch(Path(path).name, include_pattern):
-                await tool_ctx.info(
-                    f"File does not match pattern '{include_pattern}': {path}"
-                )
+                await tool_ctx.info(f"File does not match pattern '{include_pattern}': {path}")
                 return f"File does not match pattern '{include_pattern}': {path}"
 
         cmd = ["rg", "--json", pattern]
@@ -144,9 +142,7 @@ When you are doing an open ended search that may require multiple rounds of glob
 
             if process.returncode != 0 and process.returncode != 1:
                 # rg returns 1 when no matches are found, which is not an error
-                await tool_ctx.error(
-                    f"ripgrep failed with exit code {process.returncode}: {stderr.decode()}"
-                )
+                await tool_ctx.error(f"ripgrep failed with exit code {process.returncode}: {stderr.decode()}")
                 return f"Error executing ripgrep: {stderr.decode()}"
 
             # Parse the JSON output
@@ -182,9 +178,7 @@ When you are doing an open ended search that may require multiple rounds of glob
                 if data.get("type") == "match":
                     path = data.get("data", {}).get("path", {}).get("text", "")
                     line_number = data.get("data", {}).get("line_number", 0)
-                    line_text = (
-                        data.get("data", {}).get("lines", {}).get("text", "").rstrip()
-                    )
+                    line_text = data.get("data", {}).get("lines", {}).get("text", "").rstrip()
 
                     if path not in file_results:
                         file_results[path] = []
@@ -251,9 +245,7 @@ When you are doing an open ended search that may require multiple rounds of glob
                     await tool_ctx.info(f"Searching single file: {path}")
                 else:
                     # File doesn't match the pattern, return immediately
-                    await tool_ctx.info(
-                        f"File does not match pattern '{include_pattern}': {path}"
-                    )
+                    await tool_ctx.info(f"File does not match pattern '{include_pattern}': {path}")
                     return f"File does not match pattern '{include_pattern}': {path}"
             elif input_path.is_dir():
                 # Directory search - find all files
@@ -290,9 +282,7 @@ When you are doing an open ended search that may require multiple rounds of glob
             if input_path.is_file():
                 await tool_ctx.info(f"Searching file: {path}")
             else:
-                await tool_ctx.info(
-                    f"Searching through {total_files} files in directory"
-                )
+                await tool_ctx.info(f"Searching through {total_files} files in directory")
 
             # Set up for parallel processing
             results: list[str] = []
@@ -314,18 +304,14 @@ When you are doing an open ended search that may require multiple rounds of glob
                             with open(file_path, "r", encoding="utf-8") as f:
                                 for line_num, line in enumerate(f, 1):
                                     if re.search(pattern, line):
-                                        file_results.append(
-                                            f"{file_path}:{line_num}: {line.rstrip()}"
-                                        )
+                                        file_results.append(f"{file_path}:{line_num}: {line.rstrip()}")
                                         matches_found += 1
                             files_processed += 1
                         except UnicodeDecodeError:
                             # Skip binary files
                             files_processed += 1
                         except Exception as e:
-                            await tool_ctx.warning(
-                                f"Error reading {file_path}: {str(e)}"
-                            )
+                            await tool_ctx.warning(f"Error reading {file_path}: {str(e)}")
                 except Exception as e:
                     await tool_ctx.warning(f"Error processing {file_path}: {str(e)}")
 
@@ -429,9 +415,7 @@ When you are doing an open ended search that may require multiple rounds of glob
                     truncation_message="\n\n[Grep results truncated due to token limit. Use more specific patterns or paths to reduce output.]",
                 )
             else:
-                await tool_ctx.info(
-                    "ripgrep is not installed, using fallback implementation"
-                )
+                await tool_ctx.info("ripgrep is not installed, using fallback implementation")
                 result = await self.fallback_grep(pattern, path, tool_ctx, include)
                 return truncate_response(
                     result,
@@ -462,6 +446,4 @@ When you are doing an open ended search that may require multiple rounds of glob
             include: Include,
         ) -> str:
             # Use 'include' parameter if provided, otherwise fall back to 'file_pattern'
-            return await tool_self.call(
-                ctx, pattern=pattern, path=path, include=include
-            )
+            return await tool_self.call(ctx, pattern=pattern, path=path, include=include)

hanzo_mcp/tools/filesystem/multi_edit.py

@@ -170,15 +170,11 @@ If you want to create a new file, use:
             expected_replacements = edit.get("expected_replacements", 1)
 
             if old_string is None:
-                await tool_ctx.error(
-                    f"Parameter 'old_string' in edit at index {i} is required but was None"
-                )
+                await tool_ctx.error(f"Parameter 'old_string' in edit at index {i} is required but was None")
                 return f"Error: Parameter 'old_string' in edit at index {i} is required but was None"
 
             if new_string is None:
-                await tool_ctx.error(
-                    f"Parameter 'new_string' in edit at index {i} is required but was None"
-                )
+                await tool_ctx.error(f"Parameter 'new_string' in edit at index {i} is required but was None")
                 return f"Error: Parameter 'new_string' in edit at index {i} is required but was None"
 
             if (
@@ -192,12 +188,8 @@ If you want to create a new file, use:
                 return f"Error: Parameter 'expected_replacements' in edit at index {i} must be a non-negative number"
 
             if old_string == new_string:
-                await tool_ctx.error(
-                    f"Edit at index {i}: old_string and new_string are identical"
-                )
-                return (
-                    f"Error: Edit at index {i}: old_string and new_string are identical"
-                )
+                await tool_ctx.error(f"Edit at index {i}: old_string and new_string are identical")
+                return f"Error: Edit at index {i}: old_string and new_string are identical"
 
         await tool_ctx.info(f"Applying {len(edits)} edits to file: {file_path}")
 
@@ -261,9 +253,7 @@ If you want to create a new file, use:
 
                 # Check if old_string exists in current content
                 if old_string not in current_content:
-                    edit_index = (
-                        i + 1 if not creation_mode else i + 2
-                    )  # Adjust for display
+                    edit_index = i + 1 if not creation_mode else i + 2  # Adjust for display
                     await tool_ctx.error(
                         f"Edit {edit_index}: The specified old_string was not found in the file content"
                     )
@@ -274,9 +264,7 @@ If you want to create a new file, use:
 
                 # Check if the number of occurrences matches expected_replacements
                 if occurrences != expected_replacements:
-                    edit_index = (
-                        i + 1 if not creation_mode else i + 2
-                    )  # Adjust for display
+                    edit_index = i + 1 if not creation_mode else i + 2  # Adjust for display
                     await tool_ctx.error(
                         f"Edit {edit_index}: Found {occurrences} occurrences of the specified old_string, but expected {expected_replacements}"
                     )

hanzo_mcp/tools/filesystem/read.py

@@ -118,18 +118,12 @@ Usage:
             await tool_ctx.error("Parameter 'file_path' is required but was None")
             return "Error: Parameter 'file_path' is required but was None"
 
-        await tool_ctx.info(
-            f"Reading file: {file_path} (offset: {offset}, limit: {limit})"
-        )
+        await tool_ctx.info(f"Reading file: {file_path} (offset: {offset}, limit: {limit})")
 
         # Check if path is allowed
         if not self.is_path_allowed(file_path):
-            await tool_ctx.error(
-                f"Access denied - path outside allowed directories: {file_path}"
-            )
-            return (
-                f"Error: Access denied - path outside allowed directories: {file_path}"
-            )
+            await tool_ctx.error(f"Access denied - path outside allowed directories: {file_path}")
+            return f"Error: Access denied - path outside allowed directories: {file_path}"
 
         try:
             file_path_obj = Path(file_path)
@@ -166,10 +160,7 @@ Usage:
 
                             # Truncate long lines
                             if len(line) > self.MAX_LINE_LENGTH:
-                                line = (
-                                    line[: self.MAX_LINE_LENGTH]
-                                    + self.LINE_TRUNCATION_INDICATOR
-                                )
+                                line = line[: self.MAX_LINE_LENGTH] + self.LINE_TRUNCATION_INDICATOR
 
                             # Add line with line number (1-based)
                             lines.append(f"{i + 1:6d}  {line.rstrip()}")
@@ -196,17 +187,12 @@ Usage:
 
                                 # Truncate long lines
                                 if len(line) > self.MAX_LINE_LENGTH:
-                                    line = (
-                                        line[: self.MAX_LINE_LENGTH]
-                                        + self.LINE_TRUNCATION_INDICATOR
-                                    )
+                                    line = line[: self.MAX_LINE_LENGTH] + self.LINE_TRUNCATION_INDICATOR
 
                                 # Add line with line number (1-based)
                                 lines.append(f"{i + 1:6d}  {line.rstrip()}")
 
-                        await tool_ctx.warning(
-                            f"File read with latin-1 encoding: {file_path}"
-                        )
+                        await tool_ctx.warning(f"File read with latin-1 encoding: {file_path}")
 
                     except Exception:
                         await tool_ctx.error(f"Cannot read binary file: {file_path}")
@@ -236,9 +222,7 @@ Usage:
             await tool_ctx.error(f"Error reading file: {str(e)}")
             return f"Error: {str(e)}"
 
-    async def run(
-        self, ctx: MCPContext, file_path: str, offset: int = 0, limit: int = 2000
-    ) -> str:
+    async def run(self, ctx: MCPContext, file_path: str, offset: int = 0, limit: int = 2000) -> str:
         """Run method for backwards compatibility with test scripts.
 
         Args:
@@ -271,6 +255,4 @@ Usage:
             offset: Offset = 0,
             limit: Limit = 2000,
         ) -> str:
-            return await tool_self.call(
-                ctx, file_path=file_path, offset=offset, limit=limit
-            )
+            return await tool_self.call(ctx, file_path=file_path, offset=offset, limit=limit)

hanzo_mcp/tools/filesystem/rules_tool.py

@@ -142,9 +142,7 @@ understand project-specific requirements and preferences."""
                             found_configs.append(
                                 {
                                     "path": str(config_path),
-                                    "relative_path": str(
-                                        config_path.relative_to(start_path)
-                                    ),
+                                    "relative_path": str(config_path.relative_to(start_path)),
                                     "content": content,
                                     "size": len(content),
                                 }
@@ -152,9 +150,7 @@ understand project-specific requirements and preferences."""
 
                             await tool_ctx.info(f"Found configuration: {config_path}")
                     except Exception as e:
-                        await tool_ctx.warning(
-                            f"Could not read {config_path}: {str(e)}"
-                        )
+                        await tool_ctx.warning(f"Could not read {config_path}: {str(e)}")
 
             # Check if we've reached the root or a git repository root
             if current_path.parent == current_path:
@@ -169,8 +165,7 @@ understand project-specific requirements and preferences."""
                         if (
                             config_path.exists()
                             and config_path.is_file()
-                            and str(config_path)
-                            not in [c["path"] for c in found_configs]
+                            and str(config_path) not in [c["path"] for c in found_configs]
                         ):
                             try:
                                 if self.is_path_allowed(str(config_path)):
@@ -180,21 +175,15 @@ understand project-specific requirements and preferences."""
                                     found_configs.append(
                                         {
                                             "path": str(config_path),
-                                            "relative_path": str(
-                                                config_path.relative_to(start_path)
-                                            ),
+                                            "relative_path": str(config_path.relative_to(start_path)),
                                             "content": content,
                                             "size": len(content),
                                         }
                                     )
 
-                                    await tool_ctx.info(
-                                        f"Found configuration: {config_path}"
-                                    )
+                                    await tool_ctx.info(f"Found configuration: {config_path}")
                             except Exception as e:
-                                await tool_ctx.warning(
-                                    f"Could not read {config_path}: {str(e)}"
-                                )
+                                await tool_ctx.warning(f"Could not read {config_path}: {str(e)}")
                 break
 
             # Move to parent directory

hanzo_mcp/tools/filesystem/search_tool.py

@@ -248,9 +248,7 @@ This is the recommended search tool for comprehensive results."""
     ) -> 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
-            )
+            result = await self.grep_tool.call(tool_ctx.mcp_context, pattern=pattern, path=path, include=include)
 
             results = []
             if "Found" in result and "matches" in result:
@@ -281,9 +279,7 @@ This is the recommended search tool for comprehensive results."""
             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(
@@ -317,11 +313,7 @@ This is the recommended search tool for comprehensive results."""
                                     content=content,
                                     search_type=SearchType.GREP_AST,
                                     score=0.95,  # High score for AST matches
-                                    context=(
-                                        " > ".join(current_context)
-                                        if current_context
-                                        else None
-                                    ),
+                                    context=(" > ".join(current_context) if current_context else None),
                                 )
                             )
 
@@ -339,9 +331,7 @@ This is the recommended search tool for comprehensive results."""
             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 []
@@ -399,9 +389,7 @@ This is the recommended search tool for comprehensive results."""
             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
@@ -440,11 +428,7 @@ This is the recommended search tool for comprehensive results."""
                                     SearchResult(
                                         file_path=parts[0].strip(),
                                         line_number=None,
-                                        content=(
-                                            parts[-1].strip()
-                                            if len(parts) > 2
-                                            else line
-                                        ),
+                                        content=(parts[-1].strip() if len(parts) > 2 else line),
                                         search_type=SearchType.GIT,
                                         score=0.8,  # Good score for git matches
                                     )
@@ -460,9 +444,7 @@ This is the recommended search tool for comprehensive results."""
             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
@@ -477,11 +459,7 @@ This is the recommended search tool for comprehensive results."""
             # 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="*"
-                    )
-                )
+                tasks.append(self.grep_tool.call(tool_ctx.mcp_context, pattern=sp, path=path, include="*"))
 
             grep_results = await asyncio.gather(*tasks, return_exceptions=True)
 
@@ -518,9 +496,7 @@ This is the recommended search tool for comprehensive results."""
             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 = {}
 
@@ -547,9 +523,7 @@ This is the recommended search tool for comprehensive results."""
         }
 
         # 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
-        )
+        results.sort(key=lambda r: (r.score, type_priority.get(r.search_type, 0)), reverse=True)
 
         return results
 
@@ -599,42 +573,26 @@ This is the recommended search tool for comprehensive results."""
         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)
-            )
+            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)
-            )
+            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)
-            )
+            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_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)
@@ -719,9 +677,7 @@ This is the recommended search tool for comprehensive 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}"
-                    )
+                    output.append(f"  {result.line_number:>4}: {score_str} {result.content}")
                 else:
                     output.append(f"       {score_str} {result.content}")
 

hanzo_mcp/tools/filesystem/symbols_tool.py

@@ -141,9 +141,7 @@ Finds code structures (functions, classes, methods) with full context."""
         # Route to appropriate handler
         if action == "search":
             return await self._handle_search(params, tool_ctx)
-        elif (
-            action == "ast" or action == "grep_ast"
-        ):  # Support both for backward compatibility
+        elif action == "ast" or action == "grep_ast":  # Support both for backward compatibility
             return await self._handle_ast(params, tool_ctx)
         elif action == "index":
             return await self._handle_index(params, tool_ctx)
@@ -218,9 +216,7 @@ Finds code structures (functions, classes, methods) with full context."""
                         output = tc.format()
                     else:
                         # Just show matching lines
-                        output = "\n".join(
-                            [f"{line}: {code.splitlines()[line - 1]}" for line in loi]
-                        )
+                        output = "\n".join([f"{line}: {code.splitlines()[line - 1]}" for line in loi])
 
                     results.append(f"\n{file_path}:\n{output}\n")
                     match_count += len(loi)
@@ -325,9 +321,7 @@ Finds code structures (functions, classes, methods) with full context."""
             return f"No matches found for '{pattern}' in {path}"
 
         output = [f"=== AST-aware Grep Results for '{pattern}' ==="]
-        output.append(
-            f"Total matches: {match_count} in {len([r for r in results if '===' in str(r)]) // 4} files\n"
-        )
+        output.append(f"Total matches: {match_count} in {len([r for r in results if '===' in str(r)]) // 4} files\n")
         output.extend(results)
 
         if match_count >= limit:
@@ -490,16 +484,12 @@ Finds code structures (functions, classes, methods) with full context."""
             for root, _, files in os.walk(path_obj):
                 for file in files:
                     file_path = Path(root) / file
-                    if file_path.suffix in extensions and self.is_path_allowed(
-                        str(file_path)
-                    ):
+                    if file_path.suffix in extensions and self.is_path_allowed(str(file_path)):
                         files_to_process.append(str(file_path))
 
         return files_to_process
 
-    def _extract_symbols(
-        self, tc: TreeContext, file_path: str
-    ) -> Dict[str, List[Dict[str, Any]]]:
+    def _extract_symbols(self, tc: TreeContext, file_path: str) -> Dict[str, List[Dict[str, Any]]]:
         """Extract symbols from a TreeContext (placeholder implementation)."""
         # This would need proper tree-sitter queries to extract symbols
         # For now, return empty structure

hanzo_mcp/tools/filesystem/tree.py

@@ -188,9 +188,7 @@ tree --pattern "*.py" --show-size"""
             if pattern:
                 import fnmatch
 
-                entries = [
-                    e for e in entries if fnmatch.fnmatch(e.name, pattern) or e.is_dir()
-                ]
+                entries = [e for e in entries if fnmatch.fnmatch(e.name, pattern) or e.is_dir()]
 
             # Filter dirs only
             if dirs_only:

hanzo_mcp/tools/filesystem/watch.py

@@ -191,9 +191,7 @@ watch . --recursive --exclude "__pycache__"
             output.append("\nWatch cancelled")
 
         # Summary
-        output.append(
-            f"\nWatch completed after {int(time.time() - start_time)} seconds"
-        )
+        output.append(f"\nWatch completed after {int(time.time() - start_time)} seconds")
         output.append(f"Total changes detected: {len(changes)}")
 
         return "\n".join(output)

hanzo_mcp/tools/filesystem/write.py

@@ -125,9 +125,7 @@ Usage:
             with open(path_obj, "w", encoding="utf-8") as f:
                 f.write(content)
 
-            await tool_ctx.info(
-                f"Successfully wrote file: {file_path} ({len(content)} bytes)"
-            )
+            await tool_ctx.info(f"Successfully wrote file: {file_path} ({len(content)} bytes)")
             return f"Successfully wrote file: {file_path} ({len(content)} bytes)"
         except Exception as e:
             await tool_ctx.error(f"Error writing file: {str(e)}")