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

hanzo_mcp/tools/filesystem/ast_multi_edit.py

@@ -129,9 +129,7 @@ class ASTMultiEdit(BaseTool):
 
         return parser.parse(bytes(content, "utf-8"))
 
-    def _find_references(
-        self, symbol: str, file_path: str, project_root: Optional[str] = None
-    ) -> List[ASTMatch]:
+    def _find_references(self, symbol: str, file_path: str, project_root: Optional[str] = None) -> List[ASTMatch]:
         """Find all references to a symbol across the project."""
         matches = []
 
@@ -149,9 +147,7 @@ class ASTMultiEdit(BaseTool):
 
         return matches
 
-    def _get_reference_patterns(
-        self, symbol: str, file_path: str
-    ) -> List[Dict[str, Any]]:
+    def _get_reference_patterns(self, symbol: str, file_path: str) -> List[Dict[str, Any]]:
         """Get language-specific patterns for finding references."""
         ext = Path(file_path).suffix.lower()
         lang = self.languages.get(ext, "generic")
@@ -262,9 +258,7 @@ class ASTMultiEdit(BaseTool):
                     matches.extend(self._query_ast(tree, pattern, file_path, content))
                 else:
                     # Fallback to text search
-                    matches.extend(
-                        self._text_search(content, pattern["query"], file_path)
-                    )
+                    matches.extend(self._text_search(content, pattern["query"], file_path))
 
             except Exception:
                 continue
@@ -313,9 +307,7 @@ class ASTMultiEdit(BaseTool):
 
         return matches
 
-    def _get_parent_context(
-        self, node: tree_sitter.Node, content: str
-    ) -> Optional[str]:
+    def _get_parent_context(self, node: tree_sitter.Node, content: str) -> Optional[str]:
         """Get parent context for better understanding."""
         parent = node.parent
         if parent:
@@ -335,9 +327,7 @@ class ASTMultiEdit(BaseTool):
 
         return None
 
-    def _text_search(
-        self, content: str, pattern: str, file_path: str
-    ) -> List[ASTMatch]:
+    def _text_search(self, content: str, pattern: str, file_path: str) -> List[ASTMatch]:
         """Fallback text search."""
         matches = []
         lines = content.split("\n")
@@ -412,18 +402,14 @@ class ASTMultiEdit(BaseTool):
 
         return str(path.parent)
 
-    def _group_matches_by_file(
-        self, matches: List[ASTMatch]
-    ) -> Dict[str, List[ASTMatch]]:
+    def _group_matches_by_file(self, matches: List[ASTMatch]) -> Dict[str, List[ASTMatch]]:
         """Group matches by file for efficient editing."""
         grouped = defaultdict(list)
         for match in matches:
             grouped[match.file_path].append(match)
         return grouped
 
-    def _create_unique_context(
-        self, content: str, match: ASTMatch, context_lines: int
-    ) -> str:
+    def _create_unique_context(self, content: str, match: ASTMatch, context_lines: int) -> str:
         """Create unique context for edit identification."""
         lines = content.split("\n")
 
@@ -499,27 +485,20 @@ class ASTMultiEdit(BaseTool):
                         pattern = {"query": edit_op.old_string, "type": "text"}
                         matches = self._query_ast(tree, pattern, file_path, content)
                     else:
-                        matches = self._text_search(
-                            content, edit_op.old_string, file_path
-                        )
+                        matches = self._text_search(content, edit_op.old_string, file_path)
 
                 # Filter by node types if specified
                 if edit_op.node_types:
                     matches = [m for m in matches if m.node_type in edit_op.node_types]
 
                 # Check expected count
-                if (
-                    edit_op.expect_count is not None
-                    and len(matches) != edit_op.expect_count
-                ):
+                if edit_op.expect_count is not None and len(matches) != edit_op.expect_count:
                     results["errors"].append(
                         {
                             "edit": edit_op.old_string,
                             "expected": edit_op.expect_count,
                             "found": len(matches),
-                            "locations": [
-                                f"{m.file_path}:{m.line_start}" for m in matches[:5]
-                            ],
+                            "locations": [f"{m.file_path}:{m.line_start}" for m in matches[:5]],
                         }
                     )
                     continue
@@ -547,9 +526,7 @@ class ASTMultiEdit(BaseTool):
                 success = await self._apply_file_changes(file_path, changes)
                 if success:
                     results["edits_applied"] += len(changes)
-                    results["changes"].append(
-                        {"file": file_path, "edits": len(changes)}
-                    )
+                    results["changes"].append({"file": file_path, "edits": len(changes)})
             except Exception as e:
                 results["errors"].append({"file": file_path, "error": str(e)})
 
@@ -564,9 +541,7 @@ class ASTMultiEdit(BaseTool):
             grouped[match.file_path].append((edit_op, match))
         return grouped
 
-    async def _apply_file_changes(
-        self, file_path: str, changes: List[Tuple[EditOperation, ASTMatch]]
-    ) -> bool:
+    async def _apply_file_changes(self, file_path: str, changes: List[Tuple[EditOperation, ASTMatch]]) -> bool:
         """Apply changes to a single file."""
         with open(file_path, "r", encoding="utf-8") as f:
             content = f.read()
@@ -600,9 +575,7 @@ class ASTMultiEdit(BaseTool):
 
         return True
 
-    def _generate_preview(
-        self, matches: List[Tuple[EditOperation, ASTMatch]], page_size: int
-    ) -> List[Dict[str, Any]]:
+    def _generate_preview(self, matches: List[Tuple[EditOperation, ASTMatch]], page_size: int) -> List[Dict[str, Any]]:
         """Generate preview of changes."""
         preview = []
 
@@ -625,9 +598,7 @@ class ASTMultiEdit(BaseTool):
 
         return preview
 
-    def _fallback_to_basic_edit(
-        self, file_path: str, edits: List[Dict[str, Any]]
-    ) -> MCPResourceDocument:
+    def _fallback_to_basic_edit(self, file_path: str, edits: List[Dict[str, Any]]) -> MCPResourceDocument:
         """Fallback to basic multi-edit when treesitter not available."""
         # Delegate to existing multi_edit tool
         from hanzo_mcp.tools.filesystem.multi_edit import MultiEdit

hanzo_mcp/tools/filesystem/base.py

@@ -21,9 +21,7 @@ class FilesystemBaseTool(FileSystemTool, ABC):
     the base functionality in FileSystemTool.
     """
 
-    async def check_path_allowed(
-        self, path: str, tool_ctx: Any, error_prefix: str = "Error"
-    ) -> tuple[bool, str]:
+    async def check_path_allowed(self, path: str, tool_ctx: Any, error_prefix: str = "Error") -> tuple[bool, str]:
         """Check if a path is allowed and log an error if not.
 
         Args:
@@ -40,9 +38,7 @@ class FilesystemBaseTool(FileSystemTool, ABC):
             return False, f"{error_prefix}: {message}"
         return True, ""
 
-    async def check_path_exists(
-        self, path: str, tool_ctx: Any, error_prefix: str = "Error"
-    ) -> tuple[bool, str]:
+    async def check_path_exists(self, path: str, tool_ctx: Any, error_prefix: str = "Error") -> tuple[bool, str]:
         """Check if a path exists and log an error if not.
 
         Args:
@@ -60,9 +56,7 @@ class FilesystemBaseTool(FileSystemTool, ABC):
             return False, f"{error_prefix}: {message}"
         return True, ""
 
-    async def check_is_file(
-        self, path: str, tool_ctx: Any, error_prefix: str = "Error"
-    ) -> tuple[bool, str]:
+    async def check_is_file(self, path: str, tool_ctx: Any, error_prefix: str = "Error") -> tuple[bool, str]:
         """Check if a path is a file and log an error if not.
 
         Args:
@@ -80,9 +74,7 @@ class FilesystemBaseTool(FileSystemTool, ABC):
             return False, f"{error_prefix}: {message}"
         return True, ""
 
-    async def check_is_directory(
-        self, path: str, tool_ctx: Any, error_prefix: str = "Error"
-    ) -> tuple[bool, str]:
+    async def check_is_directory(self, path: str, tool_ctx: Any, error_prefix: str = "Error") -> tuple[bool, str]:
         """Check if a path is a directory and log an error if not.
 
         Args:

hanzo_mcp/tools/filesystem/batch_search.py

@@ -80,10 +80,7 @@ class BatchSearchResults:
         return {
             "query": self.query,
             "total_results": self.total_results,
-            "results_by_type": {
-                k.value: [r.to_dict() for r in v]
-                for k, v in self.results_by_type.items()
-            },
+            "results_by_type": {k.value: [r.to_dict() for r in v] for k, v in self.results_by_type.items()},
             "combined_results": [r.to_dict() for r in self.combined_results],
             "search_time_ms": self.search_time_ms,
         }
@@ -96,12 +93,8 @@ Queries = Annotated[
 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 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)
-]
+IncludeContext = Annotated[bool, Field(description="Include function/method context", default=True)]
+CombineResults = Annotated[bool, Field(description="Combine and deduplicate results", default=True)]
 
 
 class BatchSearchParams(TypedDict):
@@ -212,9 +205,7 @@ Perfect for comprehensive code analysis and refactoring tasks."""
 
         # If pattern contains natural language, prioritize vector search
         words = pattern.split()
-        if len(words) > 2 and not any(
-            c in pattern for c in ["(", ")", "{", "}", "[", "]"]
-        ):
+        if len(words) > 2 and not any(c in pattern for c in ["(", ")", "{", "}", "[", "]"]):
             use_vector = True
 
         return use_vector, use_ast, use_symbol
@@ -227,9 +218,7 @@ Perfect for comprehensive code analysis and refactoring tasks."""
 
         try:
             # Use the existing grep tool
-            grep_result = await self.grep_tool.call(
-                tool_ctx.mcp_context, pattern=pattern, path=path, include=include
-            )
+            grep_result = await self.grep_tool.call(tool_ctx.mcp_context, pattern=pattern, path=path, include=include)
 
             results = []
             if "Found" in grep_result and "matches" in grep_result:
@@ -265,9 +254,7 @@ Perfect for comprehensive code analysis and refactoring tasks."""
             await tool_ctx.error(f"Grep search failed: {str(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 vector search and convert results."""
         if not self.vector_tool:
             return []
@@ -373,11 +360,7 @@ Perfect for comprehensive code analysis and refactoring tasks."""
                                     content=content,
                                     search_type=SearchType.AST,
                                     score=0.9,  # High score for AST matches
-                                    context=(
-                                        "\n".join(context_lines)
-                                        if context_lines
-                                        else None
-                                    ),
+                                    context=("\n".join(context_lines) if context_lines else None),
                                 )
                                 results.append(result)
 
@@ -396,9 +379,7 @@ Perfect for comprehensive code analysis and refactoring tasks."""
             await tool_ctx.error(f"AST search failed: {str(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]:
         """Run symbol search using AST analysis."""
         await tool_ctx.info(f"Running symbol search for: {pattern}")
 
@@ -414,9 +395,7 @@ Perfect for comprehensive code analysis and refactoring tasks."""
                 # Look for source files
                 for ext in [".py", ".js", ".ts", ".java", ".cpp", ".c"]:
                     files_to_check.extend(path_obj.rglob(f"*{ext}"))
-                files_to_check = [
-                    str(f) for f in files_to_check[:50]
-                ]  # Limit for performance
+                files_to_check = [str(f) for f in files_to_check[:50]]  # Limit for performance
 
             # Analyze files for symbols
             for file_path in files_to_check:
@@ -439,11 +418,7 @@ Perfect for comprehensive code analysis and refactoring tasks."""
                             file_path=symbol.file_path,
                             line_number=symbol.line_start,
                             content=f"{symbol.type} {symbol.name}"
-                            + (
-                                f" - {symbol.docstring[:100]}..."
-                                if symbol.docstring
-                                else ""
-                            ),
+                            + (f" - {symbol.docstring[:100]}..." if symbol.docstring else ""),
                             search_type=SearchType.SYMBOL,
                             score=0.95,  # Very high score for symbol matches
                             symbol_info=symbol,
@@ -464,9 +439,7 @@ Perfect for comprehensive code analysis and refactoring tasks."""
             await tool_ctx.error(f"Symbol search failed: {str(e)}")
             return []
 
-    async def _add_function_context(
-        self, results: List[SearchResult], tool_ctx
-    ) -> List[SearchResult]:
+    async def _add_function_context(self, results: List[SearchResult], tool_ctx) -> List[SearchResult]:
         """Add function/method context to results where relevant."""
         enhanced_results = []
 
@@ -488,16 +461,10 @@ Perfect for comprehensive code analysis and refactoring tasks."""
                         if file_ast:
                             # Find symbol containing this line
                             for symbol in file_ast.symbols:
-                                if (
-                                    symbol.line_start
-                                    <= result.line_number
-                                    <= symbol.line_end
-                                    and symbol.type
-                                    in [
-                                        "function",
-                                        "method",
-                                    ]
-                                ):
+                                if symbol.line_start <= result.line_number <= symbol.line_end and symbol.type in [
+                                    "function",
+                                    "method",
+                                ]:
                                     enhanced_result = SearchResult(
                                         file_path=result.file_path,
                                         line_number=result.line_number,
@@ -510,17 +477,13 @@ Perfect for comprehensive code analysis and refactoring tasks."""
                                     )
                                     break
                 except Exception as e:
-                    await tool_ctx.warning(
-                        f"Could not add context for {result.file_path}: {str(e)}"
-                    )
+                    await tool_ctx.warning(f"Could not add context for {result.file_path}: {str(e)}")
 
             enhanced_results.append(enhanced_result)
 
         return enhanced_results
 
-    def _combine_and_rank_results(
-        self, results_by_type: Dict[SearchType, List[SearchResult]]
-    ) -> List[SearchResult]:
+    def _combine_and_rank_results(self, results_by_type: Dict[SearchType, List[SearchResult]]) -> List[SearchResult]:
         """Combine results from different search types and rank by relevance."""
         all_results = []
         seen_combinations = set()
@@ -552,8 +515,7 @@ Perfect for comprehensive code analysis and refactoring tasks."""
 
                             # Replace existing if: higher priority type, or same priority but higher score
                             if result_priority > existing_priority or (
-                                result_priority == existing_priority
-                                and result.score > existing.score
+                                result_priority == existing_priority and result.score > existing.score
                             ):
                                 # Replace the entire result to preserve type
                                 idx = all_results.index(existing)
@@ -561,9 +523,7 @@ Perfect for comprehensive code analysis and refactoring tasks."""
                             else:
                                 # Still merge useful information
                                 existing.context = existing.context or result.context
-                                existing.symbol_info = (
-                                    existing.symbol_info or result.symbol_info
-                                )
+                                existing.symbol_info = existing.symbol_info or result.symbol_info
                             break
 
         # Sort by score (descending) then by search type priority
@@ -574,9 +534,7 @@ Perfect for comprehensive code analysis and refactoring tasks."""
             SearchType.VECTOR: 1,
         }
 
-        all_results.sort(
-            key=lambda r: (r.score, type_priority[r.search_type]), reverse=True
-        )
+        all_results.sort(key=lambda r: (r.score, type_priority[r.search_type]), reverse=True)
 
         return all_results
 
@@ -612,9 +570,7 @@ Perfect for comprehensive code analysis and refactoring tasks."""
         if not exists:
             return error_msg
 
-        await tool_ctx.info(
-            f"Starting batch search with {len(queries)} queries in {path}"
-        )
+        await tool_ctx.info(f"Starting batch search with {len(queries)} queries in {path}")
 
         # Run all queries in parallel
         search_tasks = []
@@ -627,44 +583,26 @@ Perfect for comprehensive code analysis and refactoring tasks."""
             if query_type == "grep":
                 pattern = query.get("pattern")
                 if pattern:
-                    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))
 
             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
-                        )
-                    )
+                    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
-                        )
-                    )
+                    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
-                        )
-                    )
+                    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}"
-                )
+                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)
@@ -689,9 +627,7 @@ Perfect for comprehensive code analysis and refactoring tasks."""
 
         # Add context if requested
         if include_context:
-            combined_results = await self._add_context_to_results(
-                combined_results, tool_ctx
-            )
+            combined_results = await self._add_context_to_results(combined_results, tool_ctx)
 
         end_time = time.time()
         search_time_ms = (end_time - start_time) * 1000
@@ -700,27 +636,17 @@ Perfect for comprehensive code analysis and refactoring tasks."""
         combined_results.sort(key=lambda r: r.score, reverse=True)
 
         # Limit total results
-        combined_results = combined_results[
-            : max_results * 2
-        ]  # Allow more when combining
+        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={
-                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
-                ],
+                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,
@@ -802,16 +728,12 @@ Perfect for comprehensive code analysis and refactoring tasks."""
 
         return combined
 
-    async def _add_context_to_results(
-        self, results: List[SearchResult], tool_ctx
-    ) -> List[SearchResult]:
+    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:
+    def _format_batch_results(self, results: BatchSearchResults, query_info: List[Dict]) -> str:
         """Format batch search results for display."""
         output = []
 
@@ -859,9 +781,7 @@ Perfect for comprehensive code analysis and refactoring tasks."""
                     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/content_replace.py

@@ -159,15 +159,11 @@ Only works within allowed directories."""
             # Process based on whether path is a file or directory
             if input_path.is_file():
                 # Single file search
-                if file_pattern == "*" or fnmatch.fnmatch(
-                    input_path.name, file_pattern
-                ):
+                if file_pattern == "*" or fnmatch.fnmatch(input_path.name, file_pattern):
                     matching_files.append(input_path)
                     await tool_ctx.info(f"Searching single file: {path}")
                 else:
-                    await tool_ctx.info(
-                        f"File does not match pattern '{file_pattern}': {path}"
-                    )
+                    await tool_ctx.info(f"File does not match pattern '{file_pattern}': {path}")
                     return f"File does not match pattern '{file_pattern}': {path}"
             elif input_path.is_dir():
                 # Directory search - optimized file finding
@@ -186,9 +182,7 @@ Only works within allowed directories."""
                 for entry in input_path.rglob("*"):
                     entry_path = str(entry)
                     if entry_path in allowed_paths and entry.is_file():
-                        if file_pattern == "*" or fnmatch.fnmatch(
-                            entry.name, file_pattern
-                        ):
+                        if file_pattern == "*" or fnmatch.fnmatch(entry.name, file_pattern):
                             matching_files.append(entry)
 
                 await tool_ctx.info(f"Found {len(matching_files)} matching files")
@@ -251,9 +245,7 @@ Only works within allowed directories."""
                 )
                 message = f"Dry run: {replacements_made} replacements of '{pattern}' with '{replacement}' would be made in {files_modified} files:"
             else:
-                await tool_ctx.info(
-                    f"Made {replacements_made} replacements in {files_modified} files"
-                )
+                await tool_ctx.info(f"Made {replacements_made} replacements in {files_modified} files")
                 message = f"Made {replacements_made} replacements of '{pattern}' with '{replacement}' in {files_modified} files:"
 
             return message + "\n\n" + "\n".join(results)

hanzo_mcp/tools/filesystem/diff.py

@@ -166,16 +166,8 @@ diff a.json b.json --ignore-whitespace"""
             output.extend(diff_lines)
 
         # Add summary
-        additions = sum(
-            1
-            for line in diff_lines
-            if line.startswith("+") and not line.startswith("+++")
-        )
-        deletions = sum(
-            1
-            for line in diff_lines
-            if line.startswith("-") and not line.startswith("---")
-        )
+        additions = sum(1 for line in diff_lines if line.startswith("+") and not line.startswith("+++"))
+        deletions = sum(1 for line in diff_lines if line.startswith("-") and not line.startswith("---"))
 
         output.append("")
         output.append("=" * 60)

hanzo_mcp/tools/filesystem/directory_tree.py

@@ -112,9 +112,7 @@ requested. Only works within allowed directories."""
             await tool_ctx.error(path_validation.error_message)
             return f"Error: {path_validation.error_message}"
 
-        await tool_ctx.info(
-            f"Getting directory tree: {path} (depth: {depth}, include_filtered: {include_filtered})"
-        )
+        await tool_ctx.info(f"Getting directory tree: {path} (depth: {depth}, include_filtered: {include_filtered})")
 
         # Check if path is allowed
         allowed, error_msg = await self.check_path_allowed(path, tool_ctx)
@@ -153,9 +151,7 @@ requested. Only works within allowed directories."""
             }
 
             # Log filtering settings
-            await tool_ctx.info(
-                f"Directory tree filtering: include_filtered={include_filtered}"
-            )
+            await tool_ctx.info(f"Directory tree filtering: include_filtered={include_filtered}")
 
             # Check if a directory should be filtered
             def should_filter(current_path: Path) -> bool:
@@ -165,9 +161,7 @@ requested. Only works within allowed directories."""
                     return False
 
                 # Filter based on directory name if filtering is enabled
-                return (
-                    current_path.name in FILTERED_DIRECTORIES and not include_filtered
-                )
+                return current_path.name in FILTERED_DIRECTORIES and not include_filtered
 
             # Track stats for summary
             stats = {
@@ -178,9 +172,7 @@ requested. Only works within allowed directories."""
             }
 
             # Build the tree recursively
-            async def build_tree(
-                current_path: Path, current_depth: int = 0
-            ) -> list[dict[str, Any]]:
+            async def build_tree(current_path: Path, current_depth: int = 0) -> list[dict[str, Any]]:
                 result: list[dict[str, Any]] = []
 
                 # Skip processing if path isn't allowed
@@ -189,9 +181,7 @@ requested. Only works within allowed directories."""
 
                 try:
                     # Sort entries: directories first, then files alphabetically
-                    entries = sorted(
-                        current_path.iterdir(), key=lambda x: (not x.is_dir(), x.name)
-                    )
+                    entries = sorted(current_path.iterdir(), key=lambda x: (not x.is_dir(), x.name))
 
                     for entry in entries:
                         # Skip entries that aren't allowed
@@ -220,9 +210,7 @@ requested. Only works within allowed directories."""
                                 continue
 
                             # Process children recursively with depth increment
-                            entry_data["children"] = await build_tree(
-                                entry, current_depth + 1
-                            )
+                            entry_data["children"] = await build_tree(entry, current_depth + 1)
                             result.append(entry_data)
                         else:
                             # Files should be at the same level check as directories
@@ -237,9 +225,7 @@ requested. Only works within allowed directories."""
                 return result
 
             # Format the tree as a simple indented structure
-            def format_tree(
-                tree_data: list[dict[str, Any]], level: int = 0
-            ) -> list[str]:
+            def format_tree(tree_data: list[dict[str, Any]], level: int = 0) -> list[str]:
                 lines = []
 
                 for item in tree_data:
@@ -249,9 +235,7 @@ requested. Only works within allowed directories."""
                     # Format based on type
                     if item["type"] == "directory":
                         if "skipped" in item:
-                            lines.append(
-                                f"{indent}{item['name']}/ [skipped - {item['skipped']}]"
-                            )
+                            lines.append(f"{indent}{item['name']}/ [skipped - {item['skipped']}]")
                         else:
                             lines.append(f"{indent}{item['name']}/")
                             # Add children with increased indentation if present
@@ -310,6 +294,4 @@ requested. Only works within allowed directories."""
             depth: Depth = 3,
             include_filtered: IncludeFiltered = False,
         ) -> str:
-            return await tool_self.call(
-                ctx, path=path, depth=depth, include_filtered=include_filtered
-            )
+            return await tool_self.call(ctx, path=path, depth=depth, include_filtered=include_filtered)