hanzo-mcp 0.1.25__py3-none-any.whl → 0.1.32__py3-none-any.whl

hanzo_mcp/tools/project/analysis.py

@@ -84,7 +84,7 @@ print(json.dumps(result))
 
         # Execute script
         result = await self.command_executor.execute_script_from_file(
-            script=script, language="python", cwd=project_dir, timeout=600.0
+            script=script, language="python", cwd=project_dir, timeout=30.0
         )
         code, stdout, stderr = result.return_code, result.stdout, result.stderr
 
@@ -204,7 +204,7 @@ try {
 
         # Execute script
         result = await self.command_executor.execute_script_from_file(
-            script=script, language="javascript", cwd=project_dir, timeout=600.0
+            script=script, language="javascript", cwd=project_dir, timeout=30.0
         )
         code, stdout, stderr = result.return_code, result.stdout, result.stderr
 
@@ -286,7 +286,7 @@ print(json.dumps(result))
 
         # Execute script
         result = await self.command_executor.execute_script_from_file(
-            script=script, language="python", cwd=project_dir, timeout=600.0
+            script=script, language="python", cwd=project_dir, timeout=30.0
         )
         code, stdout, stderr = result.return_code, result.stdout, result.stderr
 
@@ -813,14 +813,17 @@ class ProjectAnalysis:
         self.project_manager: ProjectManager = project_manager
         self.project_analyzer: ProjectAnalyzer = project_analyzer
         self.permission_manager: PermissionManager = permission_manager
-
+        
+    # Legacy method to keep backwards compatibility with tests
     def register_tools(self, mcp_server: FastMCP) -> None:
         """Register project analysis tools with the MCP server.
+        
+        Legacy method for backwards compatibility with existing tests.
+        New code should use the modular tool classes instead.
 
         Args:
             mcp_server: The FastMCP server instance
         """
-
         # Project analysis tool
         @mcp_server.tool()
         async def project_analyze_tool(project_dir: str, ctx: MCPContext) -> str:
@@ -859,7 +862,7 @@ class ProjectAnalysis:
             await tool_ctx.report_progress(10, 100)
 
             # Analyze project
-            analysis: dict[str, Any] = await self.project_manager.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']}"

hanzo_mcp/tools/project/base.py

@@ -0,0 +1,66 @@
+"""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

@@ -0,0 +1,173 @@
+"""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/__init__.py

@@ -1 +1,58 @@
-"""Shell and command execution tools for Hanzo MCP."""
+"""Shell tools package for Hanzo MCP.
+
+This package provides tools for executing shell commands and scripts.
+"""
+
+from mcp.server.fastmcp import FastMCP
+
+from hanzo_mcp.tools.common.base import BaseTool, ToolRegistry
+from hanzo_mcp.tools.common.permissions import PermissionManager
+from hanzo_mcp.tools.shell.command_executor import CommandExecutor
+from hanzo_mcp.tools.shell.run_command import RunCommandTool
+from hanzo_mcp.tools.shell.run_script import RunScriptTool
+from hanzo_mcp.tools.shell.script_tool import ScriptTool
+
+# Export all tool classes
+__all__ = [
+    "RunCommandTool",
+    "RunScriptTool",
+    "ScriptTool",
+    "CommandExecutor",
+    "get_shell_tools",
+    "register_shell_tools",
+]
+
+
+def get_shell_tools(
+    permission_manager: PermissionManager,
+) -> list[BaseTool]:
+    """Create instances of all shell tools.
+    
+    Args:
+        permission_manager: Permission manager for access control
+        
+    Returns:
+        List of shell tool instances
+    """
+    # Initialize the command executor
+    command_executor = CommandExecutor(permission_manager)
+    
+    return [
+        RunCommandTool(permission_manager, command_executor),
+        RunScriptTool(permission_manager, command_executor),
+        ScriptTool(permission_manager, command_executor),
+    ]
+
+
+def register_shell_tools(
+    mcp_server: FastMCP,
+    permission_manager: PermissionManager,
+) -> None:
+    """Register all shell tools with the MCP server.
+    
+    Args:
+        mcp_server: The FastMCP server instance
+        permission_manager: Permission manager for access control
+    """
+    tools = get_shell_tools(permission_manager)
+    ToolRegistry.register_tools(mcp_server, tools)

hanzo_mcp/tools/shell/base.py

@@ -0,0 +1,148 @@
+"""Base classes for shell tools.
+
+This module provides abstract base classes and utilities for shell tools,
+including command execution, script running, and process management.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, final
+from typing_extensions import override
+
+from mcp.server.fastmcp import Context as MCPContext
+from mcp.server.fastmcp import FastMCP
+
+from hanzo_mcp.tools.common.base import BaseTool
+from hanzo_mcp.tools.common.permissions import PermissionManager
+
+
+@final
+class CommandResult:
+    """Represents the result of a command execution."""
+
+    def __init__(
+        self,
+        return_code: int = 0,
+        stdout: str = "",
+        stderr: str = "",
+        error_message: str | None = None,
+    ):
+        """Initialize a command result.
+
+        Args:
+            return_code: The command's return code (0 for success)
+            stdout: Standard output from the command
+            stderr: Standard error from the command
+            error_message: Optional error message for failure cases
+        """
+        self.return_code: int = return_code
+        self.stdout: str = stdout
+        self.stderr: str = stderr
+        self.error_message: str | None = error_message
+
+    @property
+    def is_success(self) -> bool:
+        """Check if the command executed successfully.
+
+        Returns:
+            True if the command succeeded, False otherwise
+        """
+        return self.return_code == 0
+
+    def format_output(self, include_exit_code: bool = True) -> str:
+        """Format the command output as a string.
+
+        Args:
+            include_exit_code: Whether to include the exit code in the output
+
+        Returns:
+            Formatted output string
+        """
+        result_parts: list[str] = []
+
+        # Add error message if present
+        if self.error_message:
+            result_parts.append(f"Error: {self.error_message}")
+
+        # Add exit code if requested and not zero (for non-errors)
+        if include_exit_code and (self.return_code != 0 or not self.error_message):
+            result_parts.append(f"Exit code: {self.return_code}")
+
+        # Add stdout if present
+        if self.stdout:
+            result_parts.append(f"STDOUT:\n{self.stdout}")
+
+        # Add stderr if present
+        if self.stderr:
+            result_parts.append(f"STDERR:\n{self.stderr}")
+
+        # Join with newlines
+        return "\n\n".join(result_parts)
+
+
+class ShellBaseTool(BaseTool, ABC):
+    """Base class for shell-related tools.
+    
+    Provides common functionality for executing commands and scripts,
+    including permissions checking.
+    """
+    
+    def __init__(self, permission_manager: PermissionManager) -> None:
+        """Initialize the shell base tool.
+        
+        Args:
+            permission_manager: Permission manager for access control
+        """
+        self.permission_manager: PermissionManager = permission_manager
+        
+    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
+        
+    @override 
+    def register(self, mcp_server: FastMCP) -> None:
+        """Register this shell tool with the MCP server.
+        
+        This provides a default implementation that derived classes should override
+        with more specific parameter definitions. This implementation uses generic
+        **kwargs which doesn't provide proper parameter definitions to MCP.
+        
+        Args:
+            mcp_server: The FastMCP server instance
+        """
+        tool_self = self  # Create a reference to self for use in the closure
+        
+        # Each derived class should override this with a more specific signature
+        # that explicitly defines the parameters expected by the tool
+        @mcp_server.tool(name=self.name, description=self.mcp_description)
+        async def generic_wrapper(**kwargs: Any) -> str:
+            """Generic wrapper for shell tool.
+            
+            This wrapper should be overridden by derived classes to provide
+            explicit parameter definitions.
+            
+            Returns:
+                Tool execution result
+            """
+            # Extract context from kwargs
+            ctx = kwargs.pop("ctx")
+            # Call the actual tool implementation
+            return await tool_self.call(ctx, **kwargs)