hanzo-mcp 0.6.2__tar.gz → 0.6.3__tar.gz

{hanzo_mcp-0.6.2 → hanzo_mcp-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hanzo-mcp
-Version: 0.6.2
+Version: 0.6.3
 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
@@ -26,7 +26,8 @@ Requires-Dist: bashlex>=0.18
 Requires-Dist: libtmux>=0.39.0
 Requires-Dist: nbformat>=5.10.4
 Requires-Dist: psutil>=6.1.0
-Requires-Dist: pydantic>=2.10.0
+Requires-Dist: pydantic>=2.11.0
+Requires-Dist: pydantic-settings>=2.7.0
 Requires-Dist: typing-extensions>=4.12.2
 Requires-Dist: watchdog>=3.0.0
 Provides-Extra: dev

{hanzo_mcp-0.6.2 → hanzo_mcp-0.6.3}/hanzo_mcp/__init__.py

@@ -1,3 +1,3 @@
 """Hanzo MCP - Implementation of Hanzo capabilities using MCP."""
 
-__version__ = "0.6.2"
+__version__ = "0.6.3"

{hanzo_mcp-0.6.2 → hanzo_mcp-0.6.3}/hanzo_mcp/tools/config/palette_tool.py

@@ -155,11 +155,24 @@ palette --action current"""
 
     def register(self, server: FastMCP) -> None:
         """Register the tool with the MCP server."""
-        server.tool(name=self.name, description=self.description)(self.call)
+        tool_self = self
+        
+        @server.tool(name=self.name, description=self.description)
+        async def palette_handler(
+            ctx: MCPContext,
+            action: str = "list",
+            name: Optional[str] = None,
+        ) -> str:
+            """Handle palette tool calls."""
+            return await tool_self.run(ctx, action=action, name=name)
     
-    async def call(self, **kwargs) -> str:
+    async def call(self, ctx: MCPContext, **params) -> str:
         """Call the tool with arguments."""
-        return await self.run(None, **kwargs)
+        return await self.run(
+            ctx,
+            action=params.get("action", "list"),
+            name=params.get("name")
+        )
 
 
 # Create tool instance

{hanzo_mcp-0.6.2 → hanzo_mcp-0.6.3}/hanzo_mcp/tools/filesystem/batch_search.py

@@ -784,29 +784,25 @@ Perfect for comprehensive code analysis and refactoring tasks."""
     
     @override
     def register(self, mcp_server: FastMCP) -> None:
-        """Register the unified search tool with the MCP server."""
+        """Register the batch search tool with the MCP server."""
         tool_self = self
         
         @mcp_server.tool(name=self.name, description=self.description)
-        async def unified_search(
+        async def batch_search(
             ctx: MCPContext,
-            pattern: Pattern,
+            queries: Queries,
             path: SearchPath = ".",
             include: Include = "*",
             max_results: MaxResults = 20,
-            enable_vector: EnableVector = True,
-            enable_ast: EnableAST = True,  
-            enable_symbol: EnableSymbol = True,
             include_context: IncludeContext = True,
+            combine_results: CombineResults = True
         ) -> str:
             return await tool_self.call(
                 ctx,
-                pattern=pattern,
+                queries=queries,
                 path=path,
                 include=include,
                 max_results=max_results,
-                enable_vector=enable_vector,
-                enable_ast=enable_ast,
-                enable_symbol=enable_symbol,
                 include_context=include_context,
+                combine_results=combine_results
             )

{hanzo_mcp-0.6.2 → hanzo_mcp-0.6.3}/hanzo_mcp/tools/filesystem/content_replace.py

@@ -275,12 +275,12 @@ Only works within allowed directories."""
 
         @mcp_server.tool(name=self.name, description=self.description)
         async def content_replace(
+            ctx: MCPContext,
             pattern: Pattern,
             replacement: Replacement,
             path: SearchPath,
-            file_pattern: FilePattern,
-            dry_run: DryRun,
-            ctx: MCPContext
+            file_pattern: FilePattern = "*",
+            dry_run: DryRun = False
         ) -> str:
             return await tool_self.call(
                 ctx,

{hanzo_mcp-0.6.2 → hanzo_mcp-0.6.3}/hanzo_mcp/tools/filesystem/diff.py

@@ -173,11 +173,40 @@ diff a.json b.json --ignore-whitespace"""
 
     def register(self, server: FastMCP) -> None:
         """Register the tool with the MCP server."""
-        server.tool(name=self.name, description=self.description)(self.call)
+        tool_self = self
+        
+        @server.tool(name=self.name, description=self.description)
+        async def diff_handler(
+            ctx: MCPContext,
+            file1: str,
+            file2: str,
+            unified: bool = True,
+            context: int = 3,
+            ignore_whitespace: bool = False,
+            show_line_numbers: bool = True,
+        ) -> str:
+            """Handle diff tool calls."""
+            return await tool_self.run(
+                ctx,
+                file1=file1,
+                file2=file2,
+                unified=unified,
+                context=context,
+                ignore_whitespace=ignore_whitespace,
+                show_line_numbers=show_line_numbers,
+            )
     
-    async def call(self, **kwargs) -> str:
+    async def call(self, ctx: MCPContext, **params) -> str:
         """Call the tool with arguments."""
-        return await self.run(None, **kwargs)
+        return await self.run(
+            ctx,
+            file1=params["file1"],
+            file2=params["file2"],
+            unified=params.get("unified", True),
+            context=params.get("context", 3),
+            ignore_whitespace=params.get("ignore_whitespace", False),
+            show_line_numbers=params.get("show_line_numbers", True)
+        )
 
 
 # Create tool instance (requires permission manager to be set)

{hanzo_mcp-0.6.2 → hanzo_mcp-0.6.3}/hanzo_mcp/tools/filesystem/directory_tree.py

@@ -298,10 +298,10 @@ requested. Only works within allowed directories."""
 
         @mcp_server.tool(name=self.name, description=self.description)
         async def directory_tree(
+            ctx: MCPContext,
             path: DirectoryPath,
-            depth: Depth,
-            include_filtered: IncludeFiltered,
-            ctx: MCPContext
+            depth: Depth = 3,
+            include_filtered: IncludeFiltered = False
         ) -> str:
             return await tool_self.call(
                 ctx, path=path, depth=depth, include_filtered=include_filtered

{hanzo_mcp-0.6.2 → hanzo_mcp-0.6.3}/hanzo_mcp/tools/filesystem/edit.py

@@ -262,11 +262,11 @@ Usage:
 
         @mcp_server.tool(name=self.name, description=self.description)
         async def edit(
+            ctx: MCPContext,
             file_path: FilePath,
             old_string: OldString,
             new_string: NewString,
-            expected_replacements: ExpectedReplacements,
-            ctx: MCPContext
+            expected_replacements: ExpectedReplacements = 1
         ) -> str:
             return await tool_self.call(
                 ctx,

{hanzo_mcp-0.6.2 → hanzo_mcp-0.6.3}/hanzo_mcp/tools/filesystem/read.py

@@ -257,10 +257,10 @@ Usage:
 
         @mcp_server.tool(name=self.name, description=self.description)
         async def read(
+            ctx: MCPContext,
             file_path: FilePath,
-            offset: Offset,
-            limit: Limit,
-            ctx: MCPContext
+            offset: Offset = 0,
+            limit: Limit = 2000
         ) -> str:
             return await tool_self.call(
                 ctx, file_path=file_path, offset=offset, limit=limit

{hanzo_mcp-0.6.2 → hanzo_mcp-0.6.3}/hanzo_mcp/tools/filesystem/symbols.py

@@ -225,11 +225,11 @@ Finds code structures (functions, classes, methods) with full context."""
 
         @mcp_server.tool(name=self.name, description=self.description)
         async def symbols(
+            ctx: MCPContext,
             pattern: Pattern,
             path: SearchPath,
-            ignore_case: IgnoreCase,
-            line_number: LineNumber,
-            ctx: MCPContext
+            ignore_case: IgnoreCase = False,
+            line_number: LineNumber = False
         ) -> str:
             return await tool_self.call(
                 ctx,

{hanzo_mcp-0.6.2 → hanzo_mcp-0.6.3}/hanzo_mcp/tools/filesystem/watch.py

@@ -20,11 +20,38 @@ class WatchTool(BaseTool):
     
     def register(self, server: FastMCP) -> None:
         """Register the tool with the MCP server."""
-        server.tool(name=self.name, description=self.description)(self.call)
+        
+        @server.tool(name=self.name, description=self.description)
+        async def watch_handler(
+            path: str,
+            pattern: str = "*",
+            interval: int = 1,
+            recursive: bool = True,
+            exclude: str = "",
+            duration: int = 30,
+        ) -> str:
+            """Handle watch tool calls."""
+            return await self.run(
+                None,
+                path=path,
+                pattern=pattern,
+                interval=interval,
+                recursive=recursive,
+                exclude=exclude,
+                duration=duration,
+            )
     
-    async def call(self, **kwargs) -> str:
+    async def call(self, ctx: MCPContext, **params) -> str:
         """Call the tool with arguments."""
-        return await self.run(None, **kwargs)
+        return await self.run(
+            ctx,
+            path=params["path"],
+            pattern=params.get("pattern", "*"),
+            interval=params.get("interval", 1),
+            recursive=params.get("recursive", True),
+            exclude=params.get("exclude", ""),
+            duration=params.get("duration", 30)
+        )
 
     @property
     @override

{hanzo_mcp-0.6.2 → hanzo_mcp-0.6.3}/hanzo_mcp/tools/shell/bash_unified.py

@@ -18,11 +18,36 @@ class BashTool(BaseScriptTool):
     
     def register(self, server: FastMCP) -> None:
         """Register the tool with the MCP server."""
-        server.tool(name=self.name, description=self.description)(self.call)
+        tool_self = self
+        
+        @server.tool(name=self.name, description=self.description)
+        async def bash(
+            ctx: MCPContext,
+            command: str,
+            action: str = "run",
+            cwd: Optional[str] = None,
+            env: Optional[dict[str, str]] = None,
+            timeout: Optional[int] = None,
+        ) -> str:
+            return await tool_self.run(
+                ctx,
+                command=command,
+                action=action,
+                cwd=cwd,
+                env=env,
+                timeout=timeout
+            )
     
-    async def call(self, **kwargs) -> str:
+    async def call(self, ctx: MCPContext, **params) -> str:
         """Call the tool with arguments."""
-        return await self.run(None, **kwargs)
+        return await self.run(
+            ctx,
+            command=params["command"],
+            action=params.get("action", "run"),
+            cwd=params.get("cwd"),
+            env=params.get("env"),
+            timeout=params.get("timeout")
+        )
     
     @property
     @override

{hanzo_mcp-0.6.2 → hanzo_mcp-0.6.3}/hanzo_mcp/tools/shell/npx_unified.py

@@ -90,11 +90,36 @@ npx --action background json-server db.json"""
 
     def register(self, server: FastMCP) -> None:
         """Register the tool with the MCP server."""
-        server.tool(name=self.name, description=self.description)(self.call)
+        tool_self = self
+        
+        @server.tool(name=self.name, description=self.description)
+        async def npx(
+            ctx: MCPContext,
+            package: str,
+            args: str = "",
+            action: str = "run",
+            cwd: Optional[str] = None,
+            yes: bool = True,
+        ) -> str:
+            return await tool_self.run(
+                ctx,
+                package=package,
+                args=args,
+                action=action,
+                cwd=cwd,
+                yes=yes
+            )
     
-    async def call(self, **kwargs) -> str:
+    async def call(self, ctx: MCPContext, **params) -> str:
         """Call the tool with arguments."""
-        return await self.run(None, **kwargs)
+        return await self.run(
+            ctx,
+            package=params["package"],
+            args=params.get("args", ""),
+            action=params.get("action", "run"),
+            cwd=params.get("cwd"),
+            yes=params.get("yes", True)
+        )
 
 
 # Create tool instance

{hanzo_mcp-0.6.2 → hanzo_mcp-0.6.3}/hanzo_mcp/tools/shell/open.py

@@ -20,11 +20,18 @@ class OpenTool(BaseTool):
     
     def register(self, server: FastMCP) -> None:
         """Register the tool with the MCP server."""
-        server.tool(name=self.name, description=self.description)(self.call)
+        tool_self = self
+        
+        @server.tool(name=self.name, description=self.description)
+        async def open(
+            ctx: MCPContext,
+            path: str
+        ) -> str:
+            return await tool_self.run(ctx, path)
     
-    async def call(self, **kwargs) -> str:
+    async def call(self, ctx: MCPContext, **params) -> str:
         """Call the tool with arguments."""
-        return await self.run(None, **kwargs)
+        return await self.run(ctx, params["path"])
 
     @property
     @override

{hanzo_mcp-0.6.2 → hanzo_mcp-0.6.3}/hanzo_mcp/tools/shell/process_unified.py

@@ -120,11 +120,33 @@ process --action logs --id bash_ghi789 --lines 50"""
 
     def register(self, server: FastMCP) -> None:
         """Register the tool with the MCP server."""
-        server.tool(name=self.name, description=self.description)(self.call)
+        tool_self = self
+        
+        @server.tool(name=self.name, description=self.description)
+        async def process(
+            ctx: MCPContext,
+            action: str = "list",
+            id: Optional[str] = None,
+            signal_type: str = "TERM",
+            lines: int = 100,
+        ) -> str:
+            return await tool_self.run(
+                ctx,
+                action=action,
+                id=id,
+                signal_type=signal_type,
+                lines=lines
+            )
     
-    async def call(self, **kwargs) -> str:
+    async def call(self, ctx: MCPContext, **params) -> str:
         """Call the tool with arguments."""
-        return await self.run(None, **kwargs)
+        return await self.run(
+            ctx,
+            action=params.get("action", "list"),
+            id=params.get("id"),
+            signal_type=params.get("signal_type", "TERM"),
+            lines=params.get("lines", 100)
+        )
 
 
 # Create tool instance

{hanzo_mcp-0.6.2 → hanzo_mcp-0.6.3}/hanzo_mcp/tools/shell/uvx_unified.py

@@ -90,11 +90,36 @@ uvx --action background jupyter lab --port 8888"""
 
     def register(self, server: FastMCP) -> None:
         """Register the tool with the MCP server."""
-        server.tool(name=self.name, description=self.description)(self.call)
+        tool_self = self
+        
+        @server.tool(name=self.name, description=self.description)
+        async def uvx(
+            ctx: MCPContext,
+            package: str,
+            args: str = "",
+            action: str = "run",
+            cwd: Optional[str] = None,
+            python: Optional[str] = None,
+        ) -> str:
+            return await tool_self.run(
+                ctx,
+                package=package,
+                args=args,
+                action=action,
+                cwd=cwd,
+                python=python
+            )
     
-    async def call(self, **kwargs) -> str:
+    async def call(self, ctx: MCPContext, **params) -> str:
         """Call the tool with arguments."""
-        return await self.run(None, **kwargs)
+        return await self.run(
+            ctx,
+            package=params["package"],
+            args=params.get("args", ""),
+            action=params.get("action", "run"),
+            cwd=params.get("cwd"),
+            python=params.get("python")
+        )
 
 
 # Create tool instance

{hanzo_mcp-0.6.2 → hanzo_mcp-0.6.3}/hanzo_mcp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hanzo-mcp
-Version: 0.6.2
+Version: 0.6.3
 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
@@ -26,7 +26,8 @@ Requires-Dist: bashlex>=0.18
 Requires-Dist: libtmux>=0.39.0
 Requires-Dist: nbformat>=5.10.4
 Requires-Dist: psutil>=6.1.0
-Requires-Dist: pydantic>=2.10.0
+Requires-Dist: pydantic>=2.11.0
+Requires-Dist: pydantic-settings>=2.7.0
 Requires-Dist: typing-extensions>=4.12.2
 Requires-Dist: watchdog>=3.0.0
 Provides-Extra: dev

{hanzo_mcp-0.6.2 → hanzo_mcp-0.6.3}/hanzo_mcp.egg-info/requires.txt

@@ -10,7 +10,8 @@ bashlex>=0.18
 libtmux>=0.39.0
 nbformat>=5.10.4
 psutil>=6.1.0
-pydantic>=2.10.0
+pydantic>=2.11.0
+pydantic-settings>=2.7.0
 typing-extensions>=4.12.2
 watchdog>=3.0.0
 

{hanzo_mcp-0.6.2 → hanzo_mcp-0.6.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hanzo-mcp"
-version = "0.6.2"
+version = "0.6.3"
 description = "The Zen of Hanzo MCP: One server to rule them all. The ultimate MCP that orchestrates all others."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -29,7 +29,8 @@ dependencies = [
     "libtmux>=0.39.0",
     "nbformat>=5.10.4",
     "psutil>=6.1.0",
-    "pydantic>=2.10.0",
+    "pydantic>=2.11.0",
+    "pydantic-settings>=2.7.0",
     "typing-extensions>=4.12.2",
     "watchdog>=3.0.0",
 ]