mirror of
https://github.com/hanzoai/stack.git
synced 2026-11-19 03:06:57 +00:00
271 lines
7.1 KiB
Python
271 lines
7.1 KiB
Python
"""Tree tool implementation.
|
|
|
|
Unix-style tree command for directory visualization.
|
|
"""
|
|
|
|
from typing import List, Unpack, Optional, Annotated, TypedDict, final, override
|
|
from pathlib import Path
|
|
|
|
from pydantic import Field
|
|
from mcp.server.fastmcp import Context as MCPContext
|
|
|
|
from hanzo_mcp.tools.filesystem.base import FilesystemBaseTool
|
|
|
|
# Parameter types
|
|
TreePath = Annotated[
|
|
str,
|
|
Field(
|
|
description="Directory path to display",
|
|
default=".",
|
|
),
|
|
]
|
|
|
|
Depth = Annotated[
|
|
Optional[int],
|
|
Field(
|
|
description="Maximum depth to display",
|
|
default=None,
|
|
),
|
|
]
|
|
|
|
ShowHidden = Annotated[
|
|
bool,
|
|
Field(
|
|
description="Show hidden files (starting with .)",
|
|
default=False,
|
|
),
|
|
]
|
|
|
|
DirsOnly = Annotated[
|
|
bool,
|
|
Field(
|
|
description="Show only directories",
|
|
default=False,
|
|
),
|
|
]
|
|
|
|
ShowSize = Annotated[
|
|
bool,
|
|
Field(
|
|
description="Show file sizes",
|
|
default=False,
|
|
),
|
|
]
|
|
|
|
Pattern = Annotated[
|
|
Optional[str],
|
|
Field(
|
|
description="Only show files matching pattern",
|
|
default=None,
|
|
),
|
|
]
|
|
|
|
|
|
class TreeParams(TypedDict, total=False):
|
|
"""Parameters for tree tool."""
|
|
|
|
path: str
|
|
depth: Optional[int]
|
|
show_hidden: bool
|
|
dirs_only: bool
|
|
show_size: bool
|
|
pattern: Optional[str]
|
|
|
|
|
|
@final
|
|
class TreeTool(FilesystemBaseTool):
|
|
"""Unix-style tree command for directory visualization."""
|
|
|
|
@property
|
|
@override
|
|
def name(self) -> str:
|
|
"""Get the tool name."""
|
|
return "tree"
|
|
|
|
@property
|
|
@override
|
|
def description(self) -> str:
|
|
"""Get the tool description."""
|
|
return """Directory tree visualization.
|
|
|
|
Usage:
|
|
tree
|
|
tree ./src --depth 2
|
|
tree --dirs-only
|
|
tree --pattern "*.py" --show-size"""
|
|
|
|
@override
|
|
async def call(
|
|
self,
|
|
ctx: MCPContext,
|
|
**params: Unpack[TreeParams],
|
|
) -> str:
|
|
"""Execute tree command."""
|
|
tool_ctx = self.create_tool_context(ctx)
|
|
|
|
# Extract parameters
|
|
path = params.get("path", ".")
|
|
max_depth = params.get("depth")
|
|
show_hidden = params.get("show_hidden", False)
|
|
dirs_only = params.get("dirs_only", False)
|
|
show_size = params.get("show_size", False)
|
|
pattern = params.get("pattern")
|
|
|
|
# Validate path
|
|
path_validation = self.validate_path(path)
|
|
if path_validation.is_error:
|
|
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
|
|
|
|
path_obj = Path(path)
|
|
if not path_obj.is_dir():
|
|
return f"Error: {path} is not a directory"
|
|
|
|
# Build tree
|
|
output = [str(path_obj)]
|
|
stats = {"dirs": 0, "files": 0}
|
|
|
|
self._build_tree(
|
|
path_obj,
|
|
output,
|
|
stats,
|
|
prefix="",
|
|
is_last=True,
|
|
current_depth=0,
|
|
max_depth=max_depth,
|
|
show_hidden=show_hidden,
|
|
dirs_only=dirs_only,
|
|
show_size=show_size,
|
|
pattern=pattern,
|
|
)
|
|
|
|
# Add summary
|
|
output.append("")
|
|
if dirs_only:
|
|
output.append(f"{stats['dirs']} directories")
|
|
else:
|
|
output.append(f"{stats['dirs']} directories, {stats['files']} files")
|
|
|
|
return "\n".join(output)
|
|
|
|
def _build_tree(
|
|
self,
|
|
path: Path,
|
|
output: List[str],
|
|
stats: dict,
|
|
prefix: str,
|
|
is_last: bool,
|
|
current_depth: int,
|
|
max_depth: Optional[int],
|
|
show_hidden: bool,
|
|
dirs_only: bool,
|
|
show_size: bool,
|
|
pattern: Optional[str],
|
|
) -> None:
|
|
"""Recursively build tree structure."""
|
|
# Check depth limit
|
|
if max_depth is not None and current_depth >= max_depth:
|
|
return
|
|
|
|
try:
|
|
# Get entries
|
|
entries = list(path.iterdir())
|
|
|
|
# Filter hidden files
|
|
if not show_hidden:
|
|
entries = [e for e in entries if not e.name.startswith(".")]
|
|
|
|
# Filter by pattern
|
|
if pattern:
|
|
import fnmatch
|
|
|
|
entries = [
|
|
e for e in entries if fnmatch.fnmatch(e.name, pattern) or e.is_dir()
|
|
]
|
|
|
|
# Filter dirs only
|
|
if dirs_only:
|
|
entries = [e for e in entries if e.is_dir()]
|
|
|
|
# Sort entries (dirs first, then alphabetically)
|
|
entries.sort(key=lambda e: (not e.is_dir(), e.name.lower()))
|
|
|
|
# Process each entry
|
|
for i, entry in enumerate(entries):
|
|
is_last_entry = i == len(entries) - 1
|
|
|
|
# Skip if not allowed
|
|
if not self.is_path_allowed(str(entry)):
|
|
continue
|
|
|
|
# Build the tree branch
|
|
if prefix:
|
|
if is_last_entry:
|
|
branch = prefix + "└── "
|
|
extension = prefix + " "
|
|
else:
|
|
branch = prefix + "├── "
|
|
extension = prefix + "│ "
|
|
else:
|
|
branch = ""
|
|
extension = ""
|
|
|
|
# Build entry line
|
|
line = branch + entry.name
|
|
|
|
# Add size if requested
|
|
if show_size and entry.is_file():
|
|
try:
|
|
size = entry.stat().st_size
|
|
line += f" ({self._format_size(size)})"
|
|
except Exception:
|
|
pass
|
|
|
|
output.append(line)
|
|
|
|
# Update stats
|
|
if entry.is_dir():
|
|
stats["dirs"] += 1
|
|
# Recurse into directory
|
|
self._build_tree(
|
|
entry,
|
|
output,
|
|
stats,
|
|
prefix=extension,
|
|
is_last=is_last_entry,
|
|
current_depth=current_depth + 1,
|
|
max_depth=max_depth,
|
|
show_hidden=show_hidden,
|
|
dirs_only=dirs_only,
|
|
show_size=show_size,
|
|
pattern=pattern,
|
|
)
|
|
else:
|
|
stats["files"] += 1
|
|
|
|
except PermissionError:
|
|
output.append(prefix + "[Permission Denied]")
|
|
except Exception as e:
|
|
output.append(prefix + f"[Error: {str(e)}]")
|
|
|
|
def _format_size(self, size: int) -> str:
|
|
"""Format file size in human-readable format."""
|
|
for unit in ["B", "KB", "MB", "GB", "TB"]:
|
|
if size < 1024.0:
|
|
return f"{size:.1f}{unit}"
|
|
size /= 1024.0
|
|
return f"{size:.1f}PB"
|
|
|
|
def register(self, mcp_server) -> None:
|
|
"""Register this tool with the MCP server."""
|
|
pass
|