hanzo-mcp 0.3.4__py3-none-any.whl → 0.5.0__py3-none-any.whl

hanzo_mcp/tools/project/base.py

@@ -1,66 +0,0 @@
-"""Base classes for project tools.
-
-This module provides abstract base classes for project analysis tools.
-"""
-
-from abc import ABC, abstractmethod
-from typing import Any
-
-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.validation import validate_path_parameter
-
-
-class ProjectBaseTool(BaseTool, ABC):
-    """Base class for project-related tools.
-    
-    Provides common functionality for project analysis and scanning.
-    """
-    
-    def __init__(
-        self, 
-        permission_manager: PermissionManager
-    ) -> None:
-        """Initialize project base tool.
-        
-        Args:
-            permission_manager: Permission manager for access control
-        """
-        self.permission_manager: PermissionManager = permission_manager
-        
-    def validate_path(self, path: str, param_name: str = "path") -> Any:
-        """Validate a path parameter.
-        
-        Args:
-            path: Path to validate
-            param_name: Name of the parameter (for error messages)
-            
-        Returns:
-            Validation result containing validation status and error message if any
-        """
-        return validate_path_parameter(path, param_name)
-        
-    def is_path_allowed(self, path: str) -> bool:
-        """Check if a path is allowed according to permission settings.
-        
-        Args:
-            path: Path to check
-            
-        Returns:
-            True if the path is allowed, False otherwise
-        """
-        return self.permission_manager.is_path_allowed(path)
-    
-    @abstractmethod
-    async def prepare_tool_context(self, ctx: MCPContext) -> Any:
-        """Create and prepare the tool context.
-        
-        Args:
-            ctx: MCP context
-            
-        Returns:
-            Prepared tool context
-        """
-        pass

hanzo_mcp/tools/project/project_analyze.py

@@ -1,173 +0,0 @@
-"""Project analyze tool implementation.
-
-This module provides the ProjectAnalyzeTool for analyzing project structure and dependencies.
-"""
-
-from typing import Any, final, override
-
-from mcp.server.fastmcp import Context as MCPContext
-from mcp.server.fastmcp import FastMCP
-
-from hanzo_mcp.tools.common.context import create_tool_context
-from hanzo_mcp.tools.project.analysis import ProjectAnalyzer, ProjectManager
-from hanzo_mcp.tools.project.base import ProjectBaseTool
-
-
-@final
-class ProjectAnalyzeTool(ProjectBaseTool):
-    """Tool for analyzing project structure and dependencies."""
-    
-    def __init__(
-        self, 
-        permission_manager: Any,
-        project_manager: ProjectManager,
-        project_analyzer: ProjectAnalyzer
-    ) -> None:
-        """Initialize the project analyze tool.
-        
-        Args:
-            permission_manager: Permission manager for access control
-            project_manager: Project manager for tracking projects
-            project_analyzer: Project analyzer for analyzing project structure
-        """
-        super().__init__(permission_manager)
-        self.project_manager: ProjectManager = project_manager
-        self.project_analyzer: ProjectAnalyzer = project_analyzer
-        
-    @property
-    @override 
-    def name(self) -> str:
-        """Get the tool name.
-        
-        Returns:
-            Tool name
-        """
-        return "project_analyze_tool"
-        
-    @property
-    @override 
-    def description(self) -> str:
-        """Get the tool description.
-        
-        Returns:
-            Tool description
-        """
-        return """Analyze a project directory structure and dependencies."""
-        
-    @property
-    @override 
-    def parameters(self) -> dict[str, Any]:
-        """Get the parameter specifications for the tool.
-        
-        Returns:
-            Parameter specifications
-        """
-        return {
-            "properties": {
-                "project_dir": {
-                    "type": "string",
-                    "description": "path to the project directory to analyze"
-                }
-            },
-            "required": ["project_dir"],
-            "type": "object"
-        }
-        
-    @property
-    @override 
-    def required(self) -> list[str]:
-        """Get the list of required parameter names.
-        
-        Returns:
-            List of required parameter names
-        """
-        return ["project_dir"]
-    
-    @override 
-    async def prepare_tool_context(self, ctx: MCPContext) -> Any:
-        """Create and prepare the tool context.
-        
-        Args:
-            ctx: MCP context
-            
-        Returns:
-            Prepared tool context
-        """
-        tool_ctx = create_tool_context(ctx)
-        tool_ctx.set_tool_info(self.name)
-        return tool_ctx
-        
-    @override 
-    async def call(self, ctx: MCPContext, **params: Any) -> str:
-        """Execute the tool with the given parameters.
-        
-        Args:
-            ctx: MCP context
-            **params: Tool parameters
-            
-        Returns:
-            Tool result
-        """
-        tool_ctx = await self.prepare_tool_context(ctx)
-        
-        # Extract parameters
-        project_dir = params.get("project_dir")
-        
-        # Validate project_dir parameter
-        path_validation = self.validate_path(project_dir, "project_dir")
-        if path_validation.is_error:
-            await tool_ctx.error(path_validation.error_message)
-            return f"Error: {path_validation.error_message}"
-            
-        await tool_ctx.info(f"Analyzing project: {project_dir}")
-        
-        # Check if directory is allowed
-        if not self.is_path_allowed(project_dir):
-            await tool_ctx.error(f"Directory not allowed: {project_dir}")
-            return f"Error: Directory not allowed: {project_dir}"
-            
-        # Set project root
-        if not self.project_manager.set_project_root(project_dir):
-            await tool_ctx.error(f"Failed to set project root: {project_dir}")
-            return f"Error: Failed to set project root: {project_dir}"
-            
-        await tool_ctx.info("Analyzing project structure...")
-        
-        # Report intermediate progress
-        await tool_ctx.report_progress(10, 100)
-        
-        # Analyze project
-        analysis = await self.project_manager.analyze_project()
-        if "error" in analysis:
-            await tool_ctx.error(f"Error analyzing project: {analysis['error']}")
-            return f"Error analyzing project: {analysis['error']}"
-            
-        # Report more progress
-        await tool_ctx.report_progress(50, 100)
-        
-        await tool_ctx.info("Generating project summary...")
-        
-        # Generate summary
-        summary = self.project_manager.generate_project_summary()
-        
-        # Complete progress
-        await tool_ctx.report_progress(100, 100)
-        
-        await tool_ctx.info("Project analysis complete")
-        return summary
-        
-    @override
-    def register(self, mcp_server: FastMCP) -> None:
-        """Register this project analyze tool with the MCP server.
-        
-        Creates a wrapper function with explicitly defined parameters that match
-        the tool's parameter schema and registers it with the MCP server.
-        
-        Args:
-            mcp_server: The FastMCP server instance
-        """
-        tool_self = self  # Create a reference to self for use in the closure
-        
-        @mcp_server.tool(name=self.name, description=self.mcp_description)
-        async def project_analyze_tool(project_dir: str, ctx: MCPContext) -> str:
-            return await tool_self.call(ctx, project_dir=project_dir)

hanzo_mcp/tools/shell/run_script.py

@@ -1,215 +0,0 @@
-"""Run script tool implementation.
-
-This module provides the RunScriptTool for executing scripts with interpreters.
-"""
-
-import os
-from typing import Any, final, override
-
-from mcp.server.fastmcp import Context as MCPContext
-from mcp.server.fastmcp import FastMCP
-
-from hanzo_mcp.tools.common.context import create_tool_context
-from hanzo_mcp.tools.shell.base import ShellBaseTool
-from hanzo_mcp.tools.shell.command_executor import CommandExecutor
-
-
-@final
-class RunScriptTool(ShellBaseTool):
-    """Tool for executing scripts with interpreters."""
-    
-    def __init__(self, permission_manager: Any, command_executor: CommandExecutor) -> None:
-        """Initialize the run script tool.
-        
-        Args:
-            permission_manager: Permission manager for access control
-            command_executor: Command executor for running scripts
-        """
-        super().__init__(permission_manager)
-        self.command_executor: CommandExecutor = command_executor
-        
-    @property
-    @override
-    def name(self) -> str:
-        """Get the tool name.
-        
-        Returns:
-            Tool name
-        """
-        return "run_script"
-        
-    @property
-    @override
-    def description(self) -> str:
-        """Get the tool description.
-        
-        Returns:
-            Tool description
-        """
-        return """Execute a script with the specified interpreter.
-
-Args:
-    script: The script content to execute
-    cwd: Working directory for script execution. MUST be a subdirectory of one of the allowed paths, not a parent directory. Specify the most specific path possible.
-
-    interpreter: The interpreter to use (bash, python, etc.)
-    use_login_shell: Whether to use login shell (loads ~/.zshrc, ~/.bashrc, etc.)
-
-Returns:
-    The output of the script
-"""
-        
-    @property
-    @override
-    def parameters(self) -> dict[str, Any]:
-        """Get the parameter specifications for the tool.
-        
-        Returns:
-            Parameter specifications
-        """
-        return {
-            "properties": {
-                "script": {
-                    "title": "Script",
-                    "type": "string"
-                },
-                "cwd": {
-                    "title": "Cwd",
-                    "type": "string"
-                },
-                "interpreter": {
-                    "default": "bash",
-                    "title": "Interpreter",
-                    "type": "string"
-                },
-                "use_login_shell": {
-                    "default": True,
-                    "title": "Use Login Shell",
-                    "type": "boolean"
-                }
-            },
-            "required": ["script", "cwd"],
-            "title": "run_scriptArguments",
-            "type": "object"
-        }
-        
-    @property
-    @override
-    def required(self) -> list[str]:
-        """Get the list of required parameter names.
-        
-        Returns:
-            List of required parameter names
-        """
-        return ["script", "cwd"]
-    
-    @override
-    async def prepare_tool_context(self, ctx: MCPContext) -> Any:
-        """Create and prepare the tool context.
-        
-        Args:
-            ctx: MCP context
-            
-        Returns:
-            Prepared tool context
-        """
-        tool_ctx = create_tool_context(ctx)
-        tool_ctx.set_tool_info(self.name)
-        return tool_ctx
-        
-    @override
-    async def call(self, ctx: MCPContext, **params: Any) -> str:
-        """Execute the tool with the given parameters.
-        
-        Args:
-            ctx: MCP context
-            **params: Tool parameters
-            
-        Returns:
-            Tool result
-        """
-        tool_ctx = await self.prepare_tool_context(ctx)
-        
-        # Extract parameters
-        script = params.get("script")
-        cwd = params.get("cwd")
-        interpreter = params.get("interpreter", "bash")
-        use_login_shell = params.get("use_login_shell", True)
-        
-        # Validate required parameters
-        if not script:
-            await tool_ctx.error("Parameter 'script' is required but was None")
-            return "Error: Parameter 'script' is required but was None"
-            
-        if script.strip() == "":
-            await tool_ctx.error("Parameter 'script' cannot be empty")
-            return "Error: Parameter 'script' cannot be empty"
-            
-        # Validate interpreter
-        if not interpreter:
-            interpreter = "bash"  # Use default if None
-        elif interpreter.strip() == "":
-            await tool_ctx.error("Parameter 'interpreter' cannot be empty")
-            return "Error: Parameter 'interpreter' cannot be empty"
-            
-        # Validate required cwd parameter
-        if not cwd:
-            await tool_ctx.error("Parameter 'cwd' is required but was None")
-            return "Error: Parameter 'cwd' is required but was None"
-            
-        if cwd.strip() == "":
-            await tool_ctx.error("Parameter 'cwd' cannot be empty")
-            return "Error: Parameter 'cwd' cannot be empty"
-        
-        await tool_ctx.info(f"Executing script with interpreter: {interpreter}")
-        
-        # Check if working directory is allowed
-        if not self.is_path_allowed(cwd):
-            await tool_ctx.error(f"Working directory not allowed: {cwd}")
-            return f"Error: Working directory not allowed: {cwd}"
-            
-        # Check if working directory exists
-        if not os.path.isdir(cwd):
-            await tool_ctx.error(f"Working directory does not exist: {cwd}")
-            return f"Error: Working directory does not exist: {cwd}"
-            
-        # Execute the script
-        result = await self.command_executor.execute_script(
-            script=script,
-            interpreter=interpreter,
-            cwd=cwd,
-            timeout=30.0,
-            use_login_shell=use_login_shell
-        )
-        
-        # Report result
-        if result.is_success:
-            await tool_ctx.info("Script executed successfully")
-        else:
-            await tool_ctx.error(f"Script execution failed with exit code {result.return_code}")
-            
-        # Format the result
-        if result.is_success:
-            # For successful scripts, just return stdout unless stderr has content
-            if result.stderr:
-                return f"Script executed successfully.\n\nSTDOUT:\n{result.stdout}\n\nSTDERR:\n{result.stderr}"
-            return result.stdout
-        else:
-            # For failed scripts, include all available information
-            return result.format_output()
-            
-    @override
-    def register(self, mcp_server: FastMCP) -> None:
-        """Register this run script tool with the MCP server.
-        
-        Creates a wrapper function with explicitly defined parameters that match
-        the tool's parameter schema and registers it with the MCP server.
-        
-        Args:
-            mcp_server: The FastMCP server instance
-        """
-        tool_self = self  # Create a reference to self for use in the closure
-        
-        @mcp_server.tool(name=self.name, description=self.mcp_description)
-        async def run_script(ctx: MCPContext, script: str, cwd: str, interpreter: str = "bash", use_login_shell: bool = True) -> str:
-            return await tool_self.call(ctx, script=script, cwd=cwd, interpreter=interpreter, use_login_shell=use_login_shell)

hanzo_mcp/tools/shell/script_tool.py

@@ -1,244 +0,0 @@
-"""Script tool implementation.
-
-This module provides the ScriptTool for executing scripts in various languages.
-"""
-
-import os
-from typing import Any, final, override
-
-from mcp.server.fastmcp import Context as MCPContext
-from mcp.server.fastmcp import FastMCP
-
-from hanzo_mcp.tools.common.context import create_tool_context
-from hanzo_mcp.tools.shell.base import ShellBaseTool
-from hanzo_mcp.tools.shell.command_executor import CommandExecutor
-
-
-@final
-class ScriptTool(ShellBaseTool):
-    """Tool for executing scripts in various languages."""
-    
-    def __init__(self, permission_manager: Any, command_executor: CommandExecutor) -> None:
-        """Initialize the script tool.
-        
-        Args:
-            permission_manager: Permission manager for access control
-            command_executor: Command executor for running scripts
-        """
-        super().__init__(permission_manager)
-        self.command_executor: CommandExecutor = command_executor
-        
-    @property
-    @override
-    def name(self) -> str:
-        """Get the tool name.
-        
-        Returns:
-            Tool name
-        """
-        return "script_tool"
-        
-    @property
-    @override
-    def description(self) -> str:
-        """Get the tool description.
-        
-        Returns:
-            Tool description
-        """
-        return """Execute a script in the specified language.
-
-Args:
-    language: The programming language (python, javascript, etc.)
-    script: The script code to execute
-    cwd: Working directory for script execution. MUST be a subdirectory of one of the allowed paths, not a parent directory. Specify the most specific path possible.
-
-    args: Optional command-line arguments
-    use_login_shell: Whether to use login shell (loads ~/.zshrc, ~/.bashrc, etc.)
-
-Returns:
-    Script execution results
-"""
-        
-    @property
-    @override
-    def parameters(self) -> dict[str, Any]:
-        """Get the parameter specifications for the tool.
-        
-        Returns:
-            Parameter specifications
-        """
-        return {
-            "properties": {
-                "language": {
-                    "title": "Language",
-                    "type": "string"
-                },
-                "script": {
-                    "title": "Script",
-                    "type": "string"
-                },
-                "cwd": {
-                    "title": "Cwd",
-                    "type": "string"
-                },
-                "args": {
-                    "anyOf": [
-                        {"items": {"type": "string"}, "type": "array"},
-                        {"type": "null"}
-                    ],
-                    "default": None,
-                    "title": "Args"
-                },
-                "use_login_shell": {
-                    "default": True,
-                    "title": "Use Login Shell",
-                    "type": "boolean"
-                }
-            },
-            "required": ["language", "script", "cwd"],
-            "title": "script_toolArguments",
-            "type": "object"
-        }
-        
-    @property
-    @override
-    def required(self) -> list[str]:
-        """Get the list of required parameter names.
-        
-        Returns:
-            List of required parameter names
-        """
-        return ["language", "script", "cwd"]
-    
-    @override
-    async def prepare_tool_context(self, ctx: MCPContext) -> Any:
-        """Create and prepare the tool context.
-        
-        Args:
-            ctx: MCP context
-            
-        Returns:
-            Prepared tool context
-        """
-        tool_ctx = create_tool_context(ctx)
-        tool_ctx.set_tool_info(self.name)
-        return tool_ctx
-        
-    @override
-    async def call(self, ctx: MCPContext, **params: Any) -> str:
-        """Execute the tool with the given parameters.
-        
-        Args:
-            ctx: MCP context
-            **params: Tool parameters
-            
-        Returns:
-            Tool result
-        """
-        tool_ctx = await self.prepare_tool_context(ctx)
-        
-        # Extract parameters
-        language = params.get("language")
-        script = params.get("script")
-        cwd = params.get("cwd")
-        args = params.get("args")
-        use_login_shell = params.get("use_login_shell", True)
-        
-        # Validate required parameters
-        if not language:
-            await tool_ctx.error("Parameter 'language' is required but was None")
-            return "Error: Parameter 'language' is required but was None"
-            
-        if language.strip() == "":
-            await tool_ctx.error("Parameter 'language' cannot be empty")
-            return "Error: Parameter 'language' cannot be empty"
-            
-        if not script:
-            await tool_ctx.error("Parameter 'script' is required but was None")
-            return "Error: Parameter 'script' is required but was None"
-            
-        if script.strip() == "":
-            await tool_ctx.error("Parameter 'script' cannot be empty")
-            return "Error: Parameter 'script' cannot be empty"
-            
-        # args can be None as it's optional
-        # Check for empty list but still allow None
-        if args is not None and len(args) == 0:
-            await tool_ctx.warning("Parameter 'args' is an empty list")
-            # We don't return error for this as empty args is acceptable
-            
-        # Validate required cwd parameter
-        if not cwd:
-            await tool_ctx.error("Parameter 'cwd' is required but was None")
-            return "Error: Parameter 'cwd' is required but was None"
-            
-        if cwd.strip() == "":
-            await tool_ctx.error("Parameter 'cwd' cannot be empty")
-            return "Error: Parameter 'cwd' cannot be empty"
-        
-        await tool_ctx.info(f"Executing {language} script")
-        
-        # Check if the language is supported
-        if language not in self.command_executor.get_available_languages():
-            await tool_ctx.error(f"Unsupported language: {language}")
-            return f"Error: Unsupported language: {language}. Supported languages: {', '.join(self.command_executor.get_available_languages())}"
-            
-        # Check if working directory is allowed
-        if not self.is_path_allowed(cwd):
-            await tool_ctx.error(f"Working directory not allowed: {cwd}")
-            return f"Error: Working directory not allowed: {cwd}"
-            
-        # Check if working directory exists
-        if not os.path.isdir(cwd):
-            await tool_ctx.error(f"Working directory does not exist: {cwd}")
-            return f"Error: Working directory does not exist: {cwd}"
-            
-        # Execute the script
-        result = await self.command_executor.execute_script_from_file(
-            script=script,
-            language=language,
-            cwd=cwd,
-            timeout=30.0,
-            args=args,
-            use_login_shell=use_login_shell
-        )
-        
-        # Report result
-        if result.is_success:
-            await tool_ctx.info(f"{language} script executed successfully")
-        else:
-            await tool_ctx.error(
-                f"{language} script execution failed with exit code {result.return_code}"
-            )
-            
-        # Format the result
-        if result.is_success:
-            # Format the successful result
-            output = f"{language} script executed successfully.\n\n"
-            if result.stdout:
-                output += f"STDOUT:\n{result.stdout}\n\n"
-            if result.stderr:
-                output += f"STDERR:\n{result.stderr}"
-            return output.strip()
-        else:
-            # For failed scripts, include all available information
-            return result.format_output()
-            
-    @override
-    def register(self, mcp_server: FastMCP) -> None:
-        """Register this script tool with the MCP server.
-        
-        Creates a wrapper function with explicitly defined parameters that match
-        the tool's parameter schema and registers it with the MCP server.
-        
-        Args:
-            mcp_server: The FastMCP server instance
-        """
-        tool_self = self  # Create a reference to self for use in the closure
-        
-        @mcp_server.tool(name=self.name, description=self.mcp_description)
-        async def script_tool(ctx: MCPContext, language: str, script: str, cwd: str, args: list[str] | None = None, 
-                              use_login_shell: bool = True) -> str:
-            return await tool_self.call(ctx, language=language, script=script, cwd=cwd, 
-                                        args=args, use_login_shell=use_login_shell)