hanzo-mcp 0.7.3__py3-none-any.whl → 0.7.7__py3-none-any.whl

hanzo_mcp/tools/filesystem/{symbols.py → ast_tool.py}

@@ -66,8 +66,8 @@ class GrepAstToolParams(TypedDict):
 
 
 @final
-class SymbolsTool(FilesystemBaseTool):
-    """Tool for searching and querying code symbols using tree-sitter AST parsing."""
+class ASTTool(FilesystemBaseTool):
+    """Tool for searching and querying code structures using tree-sitter AST parsing."""
 
     @property
     @override
@@ -77,7 +77,7 @@ class SymbolsTool(FilesystemBaseTool):
         Returns:
             Tool name
         """
-        return "symbols"
+        return "ast"
 
     @property
     @override
@@ -87,14 +87,14 @@ class SymbolsTool(FilesystemBaseTool):
         Returns:
             Tool description
         """
-        return """Code symbols search with tree-sitter AST. Actions: search (default), index, query.
+        return """AST-based code structure search using tree-sitter. Find functions, classes, methods with full context.
 
 Usage:
-symbols "function_name" ./src
-symbols --action index --path ./src
-symbols --action query --type function --path ./src
+ast "function_name" ./src
+ast "class.*Service" ./src
+ast "def test_" ./tests
 
-Finds code structures (functions, classes, methods) with full context."""
+Searches code structure intelligently, understanding syntax and providing semantic context."""
 
     @override
     async def call(

hanzo_mcp/tools/filesystem/batch_search.py

@@ -26,7 +26,7 @@ from typing_extensions import Annotated, TypedDict, Unpack, final, override
 
 from hanzo_mcp.tools.filesystem.base import FilesystemBaseTool
 from hanzo_mcp.tools.filesystem.grep import Grep
-from hanzo_mcp.tools.filesystem.symbols import SymbolsTool
+from hanzo_mcp.tools.filesystem.ast_tool import ASTTool
 from hanzo_mcp.tools.filesystem.git_search import GitSearchTool
 from hanzo_mcp.tools.vector.vector_search import VectorSearchTool
 from hanzo_mcp.tools.vector.ast_analyzer import ASTAnalyzer, Symbol
@@ -122,7 +122,7 @@ class BatchSearchTool(FilesystemBaseTool):
         
         # Initialize component search tools
         self.grep_tool = Grep(permission_manager)
-        self.grep_ast_tool = SymbolsTool(permission_manager)
+        self.grep_ast_tool = ASTTool(permission_manager)
         self.git_search_tool = GitSearchTool(permission_manager)
         self.ast_analyzer = ASTAnalyzer()
         

hanzo_mcp/tools/filesystem/directory_tree.py

@@ -11,6 +11,7 @@ from mcp.server import FastMCP
 from pydantic import Field
 
 from hanzo_mcp.tools.filesystem.base import FilesystemBaseTool
+from hanzo_mcp.tools.common.truncate import truncate_response
 
 DirectoryPath = Annotated[
     str,
@@ -279,7 +280,13 @@ requested. Only works within allowed directories."""
                 f"Generated directory tree for {path} (depth: {depth}, include_filtered: {include_filtered})"
             )
 
-            return formatted_output + summary
+            # Truncate response to stay within token limits
+            full_response = formatted_output + summary
+            return truncate_response(
+                full_response, 
+                max_tokens=25000,
+                truncation_message="\n\n[Response truncated due to token limit. Please use a smaller depth, specific subdirectory, or the paginated version of this tool.]"
+            )
         except Exception as e:
             await tool_ctx.error(f"Error generating directory tree: {str(e)}")
             return f"Error generating directory tree: {str(e)}"

hanzo_mcp/tools/filesystem/find.py

@@ -17,6 +17,7 @@ from mcp.server.fastmcp import Context as MCPContext
 from pydantic import Field
 
 from hanzo_mcp.tools.common.context import ToolContext
+from hanzo_mcp.tools.common.truncate import truncate_response
 from hanzo_mcp.tools.filesystem.base import FilesystemBaseTool
 
 

hanzo_mcp/tools/filesystem/grep.py

@@ -17,6 +17,7 @@ from mcp.server import FastMCP
 from pydantic import Field
 
 from hanzo_mcp.tools.common.context import ToolContext
+from hanzo_mcp.tools.common.truncate import truncate_response
 from hanzo_mcp.tools.filesystem.base import FilesystemBaseTool
 
 Pattern = Annotated[
@@ -422,13 +423,21 @@ When you are doing an open ended search that may require multiple rounds of glob
             if self.is_ripgrep_installed():
                 await tool_ctx.info("ripgrep is installed, using ripgrep for search")
                 result = await self.run_ripgrep(pattern, path, tool_ctx, include)
-                return result
+                return truncate_response(
+                    result,
+                    max_tokens=25000,
+                    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"
                 )
                 result = await self.fallback_grep(pattern, path, tool_ctx, include)
-                return result
+                return truncate_response(
+                    result,
+                    max_tokens=25000,
+                    truncation_message="\n\n[Grep results truncated due to token limit. Use more specific patterns or paths to reduce output.]"
+                )
         except Exception as e:
             await tool_ctx.error(f"Error in grep tool: {str(e)}")
             return f"Error in grep tool: {str(e)}"

hanzo_mcp/tools/filesystem/read.py

@@ -11,6 +11,7 @@ from mcp.server import FastMCP
 from pydantic import Field
 
 from hanzo_mcp.tools.filesystem.base import FilesystemBaseTool
+from hanzo_mcp.tools.common.truncate import truncate_response
 
 FilePath = Annotated[
     str,
@@ -219,7 +220,13 @@ Usage:
                     result += f"\n... (output truncated, showing {limit} of {limit + truncated_lines}+ lines)"
 
                 await tool_ctx.info(f"Successfully read file: {file_path}")
-                return result
+                
+                # Apply token limit to prevent excessive output
+                return truncate_response(
+                    result,
+                    max_tokens=25000,
+                    truncation_message="\n\n[File content truncated due to token limit. Use offset/limit parameters to read specific sections.]"
+                )
 
             except Exception as e:
                 await tool_ctx.error(f"Error reading file: {str(e)}")

hanzo_mcp/tools/filesystem/search_tool.py

@@ -23,7 +23,7 @@ from pydantic import Field
 
 from hanzo_mcp.tools.filesystem.base import FilesystemBaseTool
 from hanzo_mcp.tools.filesystem.grep import Grep
-from hanzo_mcp.tools.filesystem.symbols import SymbolsTool
+from hanzo_mcp.tools.filesystem.symbols_tool import SymbolsTool
 from hanzo_mcp.tools.filesystem.git_search import GitSearchTool
 from hanzo_mcp.tools.vector.vector_search import VectorSearchTool
 from hanzo_mcp.tools.common.permissions import PermissionManager

hanzo_mcp/tools/jupyter/__init__.py

@@ -70,13 +70,17 @@ def register_jupyter_tools(
     }
     
     tools = []
+    added_classes = set()  # Track which tool classes have been added
     
     if enabled_tools:
         # Use individual tool configuration
         for tool_name, enabled in enabled_tools.items():
             if enabled and tool_name in tool_classes:
                 tool_class = tool_classes[tool_name]
-                tools.append(tool_class(permission_manager))
+                # Avoid adding the same tool class multiple times
+                if tool_class not in added_classes:
+                    tools.append(tool_class(permission_manager))
+                    added_classes.add(tool_class)
     else:
         # Use all tools (backward compatibility)
         tools = get_jupyter_tools(permission_manager)

hanzo_mcp/tools/jupyter/base.py

@@ -12,7 +12,7 @@ from typing import Any, final
 
 from mcp.server.fastmcp import Context as MCPContext
 
-from hanzo_mcp.tools.common.base import FileSystemTool
+from hanzo_mcp.tools.filesystem.base import FilesystemBaseTool
 from hanzo_mcp.tools.common.context import ToolContext, create_tool_context
 
 
@@ -101,7 +101,7 @@ class NotebookCellSource:
         self.outputs = outputs or []
 
 
-class JupyterBaseTool(FileSystemTool, ABC):
+class JupyterBaseTool(FilesystemBaseTool, ABC):
     """Base class for Jupyter notebook tools.
 
     Provides common functionality for working with Jupyter notebooks, including

hanzo_mcp/tools/jupyter/jupyter.py

@@ -185,10 +185,11 @@ jupyter --action create "new.ipynb"
             return error_msg
 
         source = params.get("source")
-        if not source:
-            return "Error: source is required for edit action"
-
         edit_mode = params.get("edit_mode", "replace")
+        
+        # Only require source for non-delete operations
+        if edit_mode != "delete" and not source:
+            return "Error: source is required for edit action"
         cell_id = params.get("cell_id")
         cell_index = params.get("cell_index")
         cell_type = params.get("cell_type")
@@ -233,18 +234,18 @@ jupyter --action create "new.ipynb"
                 if cell_id:
                     for cell in nb.cells:
                         if cell.get("id") == cell_id:
-                            cell.source = source
+                            cell["source"] = source
                             if cell_type:
-                                cell.cell_type = cell_type
+                                cell["cell_type"] = cell_type
                             self.write_notebook(nb, notebook_path)
                             return f"Successfully updated cell with ID '{cell_id}'"
                     return f"Error: Cell with ID '{cell_id}' not found"
                 
                 elif cell_index is not None:
                     if 0 <= cell_index < len(nb.cells):
-                        nb.cells[cell_index].source = source
+                        nb.cells[cell_index]["source"] = source
                         if cell_type:
-                            nb.cells[cell_index].cell_type = cell_type
+                            nb.cells[cell_index]["cell_type"] = cell_type
                         self.write_notebook(nb, notebook_path)
                         return f"Successfully updated cell at index {cell_index}"
                     else:
@@ -303,21 +304,91 @@ jupyter --action create "new.ipynb"
 
     def _format_cell(self, cell: dict, index: int) -> str:
         """Format a single cell for display."""
-        output = [f"Cell {index} ({cell.cell_type})"]
+        output = [f"Cell {index} ({cell.get('cell_type', 'unknown')})"]
         if cell.get("id"):
-            output.append(f"ID: {cell.id}")
+            output.append(f"ID: {cell.get('id')}")
         output.append("-" * 40)
-        output.append(cell.source)
+        # Get source content
+        source = cell.get("source", "")
+        if isinstance(source, list):
+            source = "".join(source)
+        output.append(source)
         
-        if cell.cell_type == "code" and cell.get("outputs"):
+        if cell.get("cell_type") == "code" and cell.get("outputs"):
             output.append("\nOutputs:")
-            for out in cell.outputs:
-                if out.output_type == "stream":
-                    output.append(f"[{out.name}]: {out.text}")
-                elif out.output_type == "execute_result":
-                    output.append(f"[Out {out.execution_count}]: {out.data}")
-                elif out.output_type == "error":
-                    output.append(f"[Error]: {out.ename}: {out.evalue}")
+            for out in cell.get("outputs", []):
+                out_type = out.get("output_type", "")
+                
+                if out_type == "stream":
+                    text = out.get("text", "")
+                    if isinstance(text, list):
+                        text = "".join(text)
+                    name = out.get("name", "stdout")
+                    output.append(f"[{name}]: {text}")
+                    
+                elif out_type == "execute_result":
+                    exec_count = out.get("execution_count", "?")
+                    data = out.get("data", {})
+                    # Try to get plain text representation
+                    if "text/plain" in data:
+                        text_data = data["text/plain"]
+                        if isinstance(text_data, list):
+                            text_data = "".join(text_data)
+                        output.append(f"[Out {exec_count}]: {text_data}")
+                    else:
+                        output.append(f"[Out {exec_count}]: {data}")
+                        
+                elif out_type == "error":
+                    ename = out.get("ename", "Error")
+                    evalue = out.get("evalue", "")
+                    output.append(f"[Error]: {ename}: {evalue}")
+                    # Include traceback if available
+                    traceback = out.get("traceback", [])
+                    if traceback:
+                        output.append("Traceback:")
+                        for line in traceback:
+                            output.append(f"  {line}")
+        
+        return "\n".join(output)
+
+    def read_notebook(self, notebook_path: str) -> Any:
+        """Read a notebook from disk using nbformat.
+        
+        Args:
+            notebook_path: Path to the notebook file
+            
+        Returns:
+            Notebook object
+        """
+        with open(notebook_path, 'r') as f:
+            return nbformat.read(f, as_version=4)
+    
+    def write_notebook(self, nb: Any, notebook_path: str) -> None:
+        """Write a notebook to disk using nbformat.
+        
+        Args:
+            nb: Notebook object to write
+            notebook_path: Path to write the notebook to
+        """
+        with open(notebook_path, 'w') as f:
+            nbformat.write(nb, f)
+    
+    def format_notebook(self, nb: Any) -> str:
+        """Format an entire notebook for display.
+        
+        Args:
+            nb: Notebook object
+            
+        Returns:
+            Formatted string representation of the notebook
+        """
+        output = []
+        output.append(f"Notebook with {len(nb.cells)} cells")
+        output.append("=" * 50)
+        
+        for i, cell in enumerate(nb.cells):
+            output.append("")
+            output.append(self._format_cell(cell, i))
         
         return "\n".join(output)
 

hanzo_mcp/tools/search/find_tool.py

@@ -3,22 +3,25 @@
 import os
 import time
 import fnmatch
+import re
 from typing import List, Optional, Dict, Any, Set
 from pathlib import Path
 from dataclasses import dataclass
 import subprocess
 import json
 from datetime import datetime
+from difflib import SequenceMatcher
 
 from hanzo_mcp.tools.common.base import BaseTool
 from hanzo_mcp.tools.common.paginated_response import AutoPaginatedResponse
 from hanzo_mcp.tools.common.decorators import with_context_normalization
 from hanzo_mcp.types import MCPResourceDocument
 
+# Check if ffind command is available
 try:
-    import ffind
+    subprocess.run(['ffind', '--version'], capture_output=True, check=True)
     FFIND_AVAILABLE = True
-except ImportError:
+except (subprocess.CalledProcessError, FileNotFoundError):
     FFIND_AVAILABLE = False
 
 
@@ -256,8 +259,8 @@ class FindTool(BaseTool):
         if FFIND_AVAILABLE and not in_content:
             # Use ffind for fast file discovery
             matches = await self._find_with_ffind(
-                pattern, root_path, type, case_sensitive, regex,
-                max_depth, follow_symlinks, ignore_patterns
+                pattern, root_path, type, case_sensitive, regex, fuzzy,
+                max_depth, follow_symlinks, respect_gitignore, ignore_patterns
             )
         else:
             # Fall back to Python implementation
@@ -392,8 +395,10 @@ class FindTool(BaseTool):
                               file_type: Optional[str],
                               case_sensitive: bool,
                               regex: bool,
+                              fuzzy: bool,
                               max_depth: Optional[int],
                               follow_symlinks: bool,
+                              respect_gitignore: bool,
                               ignore_patterns: Set[str]) -> List[FileMatch]:
         """Use ffind for fast file discovery."""
         matches = []
@@ -407,15 +412,51 @@ class FindTool(BaseTool):
             'follow_symlinks': follow_symlinks,
         }
         
+        if fuzzy:
+            ffind_args['fuzzy'] = True
+            
         if max_depth:
             ffind_args['max_depth'] = max_depth
         
         try:
-            # Run ffind
-            results = ffind.find(**ffind_args)
+            # Build ffind command
+            cmd = ['ffind']
+            
+            if not case_sensitive:
+                cmd.append('-i')
             
-            for result in results:
-                path = result['path']
+            if regex:
+                cmd.append('-E')
+                
+            if fuzzy:
+                cmd.append('-f')
+                
+            if follow_symlinks:
+                cmd.append('-L')
+                
+            if max_depth:
+                cmd.extend(['-D', str(max_depth)])
+                
+            # Add pattern and path
+            cmd.append(pattern)
+            cmd.append(str(root))
+            
+            # Run ffind command
+            result = subprocess.run(cmd, capture_output=True, text=True, check=False)
+            
+            if result.returncode != 0:
+                # Fall back to Python implementation on error
+                return await self._find_with_python(
+                    pattern, root, file_type, case_sensitive, regex, fuzzy,
+                    False, max_depth, follow_symlinks, respect_gitignore, ignore_patterns
+                )
+            
+            # Parse results
+            results = result.stdout.strip().split('\n') if result.stdout else []
+            
+            for path in results:
+                if not path:  # Skip empty lines
+                    continue
                 
                 # Check ignore patterns
                 if self._should_ignore(path, ignore_patterns):

hanzo_mcp/tools/shell/base_process.py

@@ -14,6 +14,7 @@ from mcp.server.fastmcp import Context as MCPContext
 
 from hanzo_mcp.tools.common.base import BaseTool
 from hanzo_mcp.tools.common.permissions import PermissionManager
+from hanzo_mcp.tools.common.truncate import truncate_response
 # Import moved to __init__ to avoid circular import
 
 
@@ -184,7 +185,12 @@ class BaseProcessTool(BaseTool):
         else:
             if output.startswith("Command failed"):
                 raise RuntimeError(output)
-            return output
+            # Truncate output to prevent token limit issues
+            return truncate_response(
+                output,
+                max_tokens=25000,
+                truncation_message="\n\n[Command output truncated due to token limit. Output may be available in logs or files.]"
+            )
     
     async def execute_background(
         self,

hanzo_mcp/tools/shell/streaming_command.py

@@ -174,6 +174,18 @@ class StreamingCommandTool(BaseProcessTool):
         
         return None
     
+    async def call(self, ctx: Any, **kwargs) -> Dict[str, Any]:
+        """MCP tool entry point.
+        
+        Args:
+            ctx: MCP context
+            **kwargs: Tool arguments
+            
+        Returns:
+            Tool result
+        """
+        return await self.run(**kwargs)
+    
     async def run(
         self,
         command: Optional[str] = None,
@@ -591,4 +603,25 @@ class StreamingCommandTool(BaseProcessTool):
                 },
             },
             "required": [],  # No required fields for maximum forgiveness
-        }
+        }
+    
+    def get_command_args(self, command: str, **kwargs) -> List[str]:
+        """Get the command arguments for subprocess.
+        
+        Args:
+            command: The command or script to run
+            **kwargs: Additional arguments (not used for shell commands)
+            
+        Returns:
+            List of command arguments for subprocess
+        """
+        # For shell commands, we use shell=True, so return the command as-is
+        return [command]
+    
+    def get_tool_name(self) -> str:
+        """Get the name of the tool being used.
+        
+        Returns:
+            Tool name
+        """
+        return "streaming_command"

{hanzo_mcp-0.7.3.dist-info → hanzo_mcp-0.7.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hanzo-mcp
-Version: 0.7.3
+Version: 0.7.7
 Summary: The Zen of Hanzo MCP: One server to rule them all. The ultimate MCP that orchestrates all others.
 Author-email: Hanzo Industries Inc <dev@hanzo.ai>
 License: MIT
@@ -40,6 +40,10 @@ Requires-Dist: sphinx>=8.0.0; extra == "dev"
 Requires-Dist: sphinx-rtd-theme>=3.0.0; extra == "dev"
 Requires-Dist: myst-parser>=4.0.0; extra == "dev"
 Requires-Dist: sphinx-copybutton>=0.5.0; extra == "dev"
+Requires-Dist: mypy>=1.10.0; extra == "dev"
+Requires-Dist: types-aiofiles>=23.2.0; extra == "dev"
+Requires-Dist: types-psutil>=5.9.5; extra == "dev"
+Requires-Dist: types-setuptools>=69.5.0; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: sphinx>=8.0.0; extra == "docs"
 Requires-Dist: sphinx-rtd-theme>=3.0.0; extra == "docs"
@@ -55,6 +59,8 @@ Requires-Dist: pytest-asyncio>=0.25.3; extra == "test"
 Requires-Dist: twisted; extra == "test"
 Provides-Extra: agents
 Requires-Dist: hanzo-agents>=0.1.0; extra == "agents"
+Provides-Extra: memory
+Requires-Dist: hanzo-memory>=1.0.0; extra == "memory"
 Provides-Extra: performance
 Requires-Dist: ujson>=5.7.0; extra == "performance"
 Requires-Dist: orjson>=3.9.0; extra == "performance"