hanzo-mcp 0.5.2__py3-none-any.whl → 0.6.2__py3-none-any.whl

hanzo_mcp/tools/filesystem/symbols_unified.py

@@ -0,0 +1,376 @@
+"""Unified symbols tool implementation.
+
+This module provides the SymbolsTool for searching, indexing, and querying code symbols
+using tree-sitter AST parsing. It can find function definitions, class declarations,
+and other code structures with full context.
+"""
+
+import os
+from pathlib import Path
+from typing import Annotated, TypedDict, Unpack, final, override, Optional, List, Dict, Any
+import json
+
+from mcp.server.fastmcp import Context as MCPContext
+from grep_ast.grep_ast import TreeContext
+from pydantic import Field
+
+from hanzo_mcp.tools.filesystem.base import FilesystemBaseTool
+
+
+# Parameter types
+Action = Annotated[
+    str,
+    Field(
+        description="Action: search (default), index, query, list",
+        default="search",
+    ),
+]
+
+Pattern = Annotated[
+    Optional[str],
+    Field(
+        description="Pattern to search for in code",
+        default=None,
+    ),
+]
+
+SearchPath = Annotated[
+    str,
+    Field(
+        description="Path to search/index (file or directory)",
+        default=".",
+    ),
+]
+
+SymbolType = Annotated[
+    Optional[str],
+    Field(
+        description="Symbol type: function, class, method, variable",
+        default=None,
+    ),
+]
+
+IgnoreCase = Annotated[
+    bool,
+    Field(
+        description="Ignore case when matching",
+        default=False,
+    ),
+]
+
+ShowContext = Annotated[
+    bool,
+    Field(
+        description="Show AST context around matches",
+        default=True,
+    ),
+]
+
+Limit = Annotated[
+    int,
+    Field(
+        description="Maximum results to return",
+        default=50,
+    ),
+]
+
+
+class SymbolsParams(TypedDict, total=False):
+    """Parameters for symbols tool."""
+    action: str
+    pattern: Optional[str]
+    path: str
+    symbol_type: Optional[str]
+    ignore_case: bool
+    show_context: bool
+    limit: int
+
+
+@final
+class SymbolsTool(FilesystemBaseTool):
+    """Unified tool for code symbol operations using tree-sitter."""
+    
+    def __init__(self, permission_manager):
+        """Initialize the symbols tool."""
+        super().__init__(permission_manager)
+        self._symbol_cache = {}  # Cache for indexed symbols
+
+    @property
+    @override
+    def name(self) -> str:
+        """Get the tool name."""
+        return "symbols"
+
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description."""
+        return """Code symbols with tree-sitter. Actions: search (default), index, query, list.
+
+Usage:
+symbols "function_name"
+symbols --action query --symbol-type function --path ./src
+symbols --action index --path ./project
+symbols --action list --path ./src --symbol-type class"""
+
+    @override
+    async def call(
+        self,
+        ctx: MCPContext,
+        **params: Unpack[SymbolsParams],
+    ) -> str:
+        """Execute symbols operation."""
+        tool_ctx = self.create_tool_context(ctx)
+        self.set_tool_context_info(tool_ctx)
+
+        # Extract action
+        action = params.get("action", "search")
+        
+        # Route to appropriate handler
+        if action == "search":
+            return await self._handle_search(params, tool_ctx)
+        elif action == "index":
+            return await self._handle_index(params, tool_ctx)
+        elif action == "query":
+            return await self._handle_query(params, tool_ctx)
+        elif action == "list":
+            return await self._handle_list(params, tool_ctx)
+        else:
+            return f"Error: Unknown action '{action}'. Valid actions: search, index, query, list"
+
+    async def _handle_search(self, params: Dict[str, Any], tool_ctx) -> str:
+        """Search for pattern in code with AST context."""
+        pattern = params.get("pattern")
+        if not pattern:
+            return "Error: pattern required for search action"
+        
+        path = params.get("path", ".")
+        ignore_case = params.get("ignore_case", False)
+        show_context = params.get("show_context", True)
+        limit = params.get("limit", 50)
+        
+        # Validate path
+        path_validation = self.validate_path(path)
+        if not path_validation.is_valid:
+            await tool_ctx.error(f"Invalid path: {path_validation.error_message}")
+            return f"Error: Invalid path: {path_validation.error_message}"
+
+        # Check permissions
+        is_allowed, error_message = await self.check_path_allowed(path, tool_ctx)
+        if not is_allowed:
+            return error_message
+
+        # Check existence
+        is_exists, error_message = await self.check_path_exists(path, tool_ctx)
+        if not is_exists:
+            return error_message
+
+        await tool_ctx.info(f"Searching for '{pattern}' in {path}")
+
+        # Get files to process
+        files_to_process = self._get_source_files(path)
+        if not files_to_process:
+            return f"No source code files found in {path}"
+
+        # Process files
+        results = []
+        match_count = 0
+        
+        for file_path in files_to_process:
+            if match_count >= limit:
+                break
+                
+            try:
+                with open(file_path, "r", encoding="utf-8") as f:
+                    code = f.read()
+
+                tc = TreeContext(
+                    file_path,
+                    code,
+                    color=False,
+                    verbose=False,
+                    line_number=True,
+                )
+
+                # Find matches
+                loi = tc.grep(pattern, ignore_case)
+                
+                if loi:
+                    if show_context:
+                        tc.add_lines_of_interest(loi)
+                        tc.add_context()
+                        output = tc.format()
+                    else:
+                        # Just show matching lines
+                        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)
+                    
+            except Exception as e:
+                await tool_ctx.warning(f"Could not parse {file_path}: {str(e)}")
+
+        if not results:
+            return f"No matches found for '{pattern}' in {path}"
+
+        output = [f"=== Symbol Search Results for '{pattern}' ==="]
+        output.append(f"Found {match_count} matches in {len(results)} files\n")
+        output.extend(results)
+        
+        if match_count >= limit:
+            output.append(f"\n(Results limited to {limit} matches)")
+        
+        return "\n".join(output)
+
+    async def _handle_index(self, params: Dict[str, Any], tool_ctx) -> str:
+        """Index symbols in a codebase."""
+        path = params.get("path", ".")
+        
+        # Validate path
+        is_allowed, error_message = await self.check_path_allowed(path, tool_ctx)
+        if not is_allowed:
+            return error_message
+
+        await tool_ctx.info(f"Indexing symbols in {path}...")
+        
+        files_to_process = self._get_source_files(path)
+        if not files_to_process:
+            return f"No source code files found in {path}"
+
+        # Clear cache for this path
+        self._symbol_cache[path] = {
+            "functions": [],
+            "classes": [],
+            "methods": [],
+            "variables": [],
+        }
+        
+        indexed_count = 0
+        symbol_count = 0
+        
+        for file_path in files_to_process:
+            try:
+                with open(file_path, "r", encoding="utf-8") as f:
+                    code = f.read()
+
+                tc = TreeContext(file_path, code, color=False, verbose=False)
+                
+                # Extract symbols (simplified - would need proper tree-sitter queries)
+                # This is a placeholder for actual symbol extraction
+                symbols = self._extract_symbols(tc, file_path)
+                
+                for symbol_type, syms in symbols.items():
+                    self._symbol_cache[path][symbol_type].extend(syms)
+                    symbol_count += len(syms)
+                
+                indexed_count += 1
+                
+            except Exception as e:
+                await tool_ctx.warning(f"Could not index {file_path}: {str(e)}")
+
+        output = [f"=== Symbol Indexing Complete ==="]
+        output.append(f"Indexed {indexed_count} files")
+        output.append(f"Found {symbol_count} total symbols:")
+        
+        for symbol_type, symbols in self._symbol_cache[path].items():
+            if symbols:
+                output.append(f"  {symbol_type}: {len(symbols)}")
+        
+        return "\n".join(output)
+
+    async def _handle_query(self, params: Dict[str, Any], tool_ctx) -> str:
+        """Query indexed symbols."""
+        path = params.get("path", ".")
+        symbol_type = params.get("symbol_type")
+        pattern = params.get("pattern")
+        limit = params.get("limit", 50)
+        
+        # Check if we have indexed this path
+        if path not in self._symbol_cache:
+            return f"No symbols indexed for {path}. Run 'symbols --action index --path {path}' first."
+        
+        symbols = self._symbol_cache[path]
+        results = []
+        
+        # Filter by type if specified
+        if symbol_type:
+            if symbol_type in symbols:
+                candidates = symbols[symbol_type]
+            else:
+                return f"Unknown symbol type: {symbol_type}. Valid types: {', '.join(symbols.keys())}"
+        else:
+            # Combine all symbol types
+            candidates = []
+            for syms in symbols.values():
+                candidates.extend(syms)
+        
+        # Filter by pattern if specified
+        if pattern:
+            filtered = []
+            for sym in candidates:
+                if pattern.lower() in sym["name"].lower():
+                    filtered.append(sym)
+            candidates = filtered
+        
+        # Limit results
+        candidates = candidates[:limit]
+        
+        if not candidates:
+            return "No symbols found matching criteria"
+        
+        output = [f"=== Symbol Query Results ==="]
+        output.append(f"Found {len(candidates)} symbols\n")
+        
+        for sym in candidates:
+            output.append(f"{sym['type']}: {sym['name']}")
+            output.append(f"  File: {sym['file']}:{sym['line']}")
+            if sym.get("signature"):
+                output.append(f"  Signature: {sym['signature']}")
+            output.append("")
+        
+        return "\n".join(output)
+
+    async def _handle_list(self, params: Dict[str, Any], tool_ctx) -> str:
+        """List all symbols in a path."""
+        # Similar to query but shows all symbols
+        params["pattern"] = None
+        return await self._handle_query(params, tool_ctx)
+
+    def _get_source_files(self, path: str) -> List[str]:
+        """Get all source code files in a path."""
+        path_obj = Path(path)
+        files_to_process = []
+        
+        # Common source file extensions
+        extensions = {
+            ".py", ".js", ".ts", ".jsx", ".tsx", ".java", ".cpp", ".c", ".h", 
+            ".hpp", ".cs", ".rb", ".go", ".rs", ".swift", ".kt", ".scala",
+            ".php", ".lua", ".r", ".jl", ".ex", ".exs", ".clj", ".cljs"
+        }
+        
+        if path_obj.is_file():
+            if path_obj.suffix in extensions:
+                files_to_process.append(str(path_obj))
+        elif path_obj.is_dir():
+            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)):
+                        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]]]:
+        """Extract symbols from a TreeContext (placeholder implementation)."""
+        # This would need proper tree-sitter queries to extract symbols
+        # For now, return empty structure
+        return {
+            "functions": [],
+            "classes": [],
+            "methods": [],
+            "variables": [],
+        }
+
+    def register(self, mcp_server) -> None:
+        """Register this tool with the MCP server."""
+        pass

hanzo_mcp/tools/filesystem/tree.py

@@ -0,0 +1,268 @@
+"""Tree tool implementation.
+
+Unix-style tree command for directory visualization.
+"""
+
+import os
+from pathlib import Path
+from typing import Annotated, TypedDict, Unpack, final, override, Optional, List
+
+from mcp.server.fastmcp import Context as MCPContext
+from pydantic import Field
+
+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:
+                        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