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

hanzo_mcp/tools/common/session.py

@@ -0,0 +1,91 @@
+"""Session management for maintaining state across tool executions."""
+
+import os
+from pathlib import Path
+from typing import Dict, Optional, final
+
+
+@final
+class SessionManager:
+    """Manages session state across tool executions."""
+
+    _instances: Dict[str, "SessionManager"] = {}
+
+    @classmethod
+    def get_instance(cls, session_id: str) -> "SessionManager":
+        """Get or create a session manager instance for the given session ID.
+
+        Args:
+            session_id: The session ID
+
+        Returns:
+            The session manager instance
+        """
+        if session_id not in cls._instances:
+            cls._instances[session_id] = cls(session_id)
+        return cls._instances[session_id]
+
+    def __init__(self, session_id: str):
+        """Initialize the session manager.
+
+        Args:
+            session_id: The session ID
+        """
+        self.session_id = session_id
+        self._current_working_dir: Optional[Path] = None
+        self._initial_working_dir: Optional[Path] = None
+        self._environment_vars: Dict[str, str] = {}
+
+    @property
+    def current_working_dir(self) -> Path:
+        """Get the current working directory.
+
+        Returns:
+            The current working directory
+        """
+        if self._current_working_dir is None:
+            # Default to project directory if set, otherwise use current directory
+            self._current_working_dir = Path(os.getcwd())
+            self._initial_working_dir = self._current_working_dir
+        return self._current_working_dir
+
+    def set_working_dir(self, path: Path) -> None:
+        """Set the current working directory.
+
+        Args:
+            path: The path to set as the current working directory
+        """
+        self._current_working_dir = path
+
+    def reset_working_dir(self) -> None:
+        """Reset the working directory to the initial directory."""
+        if self._initial_working_dir is not None:
+            self._current_working_dir = self._initial_working_dir
+
+    def set_env_var(self, key: str, value: str) -> None:
+        """Set an environment variable.
+
+        Args:
+            key: The environment variable name
+            value: The environment variable value
+        """
+        self._environment_vars[key] = value
+
+    def get_env_var(self, key: str) -> Optional[str]:
+        """Get an environment variable.
+
+        Args:
+            key: The environment variable name
+
+        Returns:
+            The environment variable value, or None if not set
+        """
+        return self._environment_vars.get(key)
+
+    def get_env_vars(self) -> Dict[str, str]:
+        """Get all environment variables.
+
+        Returns:
+            A dictionary of environment variables
+        """
+        return self._environment_vars.copy()

hanzo_mcp/tools/common/thinking_tool.py

@@ -0,0 +1,123 @@
+"""Thinking tool implementation.
+
+This module provides the ThinkingTool for Claude to engage in structured thinking.
+"""
+
+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.base import BaseTool
+from hanzo_mcp.tools.common.context import create_tool_context
+
+
+@final
+class ThinkingTool(BaseTool):
+    """Tool for Claude to engage in structured thinking."""
+    
+    @property
+    @override
+    def name(self) -> str:
+        """Get the tool name.
+        
+        Returns:
+            Tool name
+        """
+        return "think"
+        
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description.
+        
+        Returns:
+            Tool description
+        """
+        return """Use the tool to think about something.
+
+It will not obtain new information or make any changes to the repository, but just log the thought. Use it when complex reasoning or brainstorming is needed. For example, if you explore the repo and discover the source of a bug, call this tool to brainstorm several unique ways of fixing the bug, and assess which change(s) are likely to be simplest and most effective. Alternatively, if you receive some test results, call this tool to brainstorm ways to fix the failing tests."""
+        
+    @property
+    @override
+    def parameters(self) -> dict[str, Any]:
+        """Get the parameter specifications for the tool.
+        
+        Returns:
+            Parameter specifications
+        """
+        return {
+            "properties": {
+                "thought": {
+                    "title": "Thought",
+                    "type": "string"
+                }
+            },
+            "required": ["thought"],
+            "title": "thinkArguments",
+            "type": "object"
+        }
+        
+    @property
+    @override
+    def required(self) -> list[str]:
+        """Get the list of required parameter names.
+        
+        Returns:
+            List of required parameter names
+        """
+        return ["thought"]
+        
+    def __init__(self) -> None:
+        """Initialize the thinking tool."""
+        pass
+        
+    @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 = create_tool_context(ctx)
+        tool_ctx.set_tool_info(self.name)
+        
+        # Extract parameters
+        thought = params.get("thought")
+        
+        # Validate required thought parameter
+        if not thought:
+            await tool_ctx.error(
+                "Parameter 'thought' is required but was None or empty"
+            )
+            return "Error: Parameter 'thought' is required but was None or empty"
+
+        if thought.strip() == "":
+            await tool_ctx.error("Parameter 'thought' cannot be empty")
+            return "Error: Parameter 'thought' cannot be empty"
+
+        # Log the thought but don't take action
+        await tool_ctx.info("Thinking process recorded")
+
+        # Return confirmation
+        return "I've recorded your thinking process. You can continue with your next action based on this analysis."
+        
+    @override
+    def register(self, mcp_server: FastMCP) -> None:
+        """Register this thinking 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 think(thought: str, ctx: MCPContext) -> str:
+            return await tool_self.call(ctx, thought=thought)

hanzo_mcp/tools/filesystem/__init__.py

@@ -1,9 +1,89 @@
-"""Filesystem tools for Hanzo MCP.
+"""Filesystem tools package for Hanzo MCP.
 
-This module provides comprehensive tools for interacting with the filesystem,
-including reading, writing, editing files, directory operations, and searching.
+This package provides tools for interacting with the filesystem, including reading, writing,
+and editing files, directory navigation, and content searching.
 """
 
-from hanzo_mcp.tools.filesystem.file_operations import FileOperations
+from mcp.server.fastmcp import FastMCP
 
-__all__ = ["FileOperations"]
+from hanzo_mcp.tools.common.base import BaseTool, ToolRegistry
+from hanzo_mcp.tools.common.context import DocumentContext
+from hanzo_mcp.tools.common.permissions import PermissionManager
+from hanzo_mcp.tools.filesystem.content_replace import ContentReplaceTool
+from hanzo_mcp.tools.filesystem.directory_tree import DirectoryTreeTool
+from hanzo_mcp.tools.filesystem.edit_file import EditFileTool
+from hanzo_mcp.tools.filesystem.get_file_info import GetFileInfoTool
+from hanzo_mcp.tools.filesystem.read_files import ReadFilesTool
+from hanzo_mcp.tools.filesystem.search_content import SearchContentTool
+from hanzo_mcp.tools.filesystem.write_file import WriteFileTool
+
+# Export all tool classes
+__all__ = [
+    "ReadFilesTool",
+    "WriteFileTool",
+    "EditFileTool",
+    "DirectoryTreeTool",
+    "GetFileInfoTool",
+    "SearchContentTool",
+    "ContentReplaceTool",
+    "get_filesystem_tools",
+    "register_filesystem_tools",
+]
+
+def get_read_only_filesystem_tools(
+            document_context: DocumentContext, permission_manager: PermissionManager
+) -> list[BaseTool]:
+    """Create instances of read-only filesystem tools.
+    
+    Args:
+        document_context: Document context for tracking file contents
+        permission_manager: Permission manager for access control
+
+    Returns:
+        List of read-only filesystem tool instances
+    """
+    return [
+        ReadFilesTool(document_context, permission_manager),
+        DirectoryTreeTool(document_context, permission_manager),
+        GetFileInfoTool(document_context, permission_manager),
+        SearchContentTool(document_context, permission_manager),
+    ]
+
+
+def get_filesystem_tools(
+    document_context: DocumentContext, permission_manager: PermissionManager
+) -> list[BaseTool]:
+    """Create instances of all filesystem tools.
+    
+    Args:
+        document_context: Document context for tracking file contents
+        permission_manager: Permission manager for access control
+        
+    Returns:
+        List of filesystem tool instances
+    """
+    return [
+        ReadFilesTool(document_context, permission_manager),
+        WriteFileTool(document_context, permission_manager),
+        EditFileTool(document_context, permission_manager),
+        DirectoryTreeTool(document_context, permission_manager),
+        GetFileInfoTool(document_context, permission_manager),
+        SearchContentTool(document_context, permission_manager),
+        ContentReplaceTool(document_context, permission_manager),
+    ]
+
+
+def register_filesystem_tools(
+    mcp_server: FastMCP,
+    document_context: DocumentContext,
+    permission_manager: PermissionManager,
+) -> None:
+    """Register all filesystem tools with the MCP server.
+    
+    Args:
+        mcp_server: The FastMCP server instance
+        document_context: Document context for tracking file contents
+        permission_manager: Permission manager for access control
+    """
+    tools = get_filesystem_tools(document_context, permission_manager)
+    ToolRegistry.register_tools(mcp_server, tools)

hanzo_mcp/tools/filesystem/base.py

@@ -0,0 +1,113 @@
+"""Base functionality for filesystem tools.
+
+This module provides common functionality for filesystem tools including path handling,
+error formatting, and shared utilities for file operations.
+"""
+
+from abc import ABC
+from pathlib import Path
+from typing import Any
+
+from mcp.server.fastmcp import Context as MCPContext
+
+from hanzo_mcp.tools.common.base import FileSystemTool
+from hanzo_mcp.tools.common.context import ToolContext, create_tool_context
+
+
+class FilesystemBaseTool(FileSystemTool,ABC):
+    """Enhanced base class for all filesystem tools.
+    
+    Provides additional utilities specific to filesystem operations beyond
+    the base functionality in FileSystemTool.
+    """
+    
+    async def check_path_allowed(self, path: str, tool_ctx: Any, error_prefix: str = "Error") -> tuple[bool, str]:
+        """Check if a path is allowed and log an error if not.
+        
+        Args:
+            path: Path to check
+            tool_ctx: Tool context for logging
+            error_prefix: Prefix for error messages
+            
+        Returns:
+            tuple of (is_allowed, error_message)
+        """
+        if not self.is_path_allowed(path):
+            message = f"Access denied - path outside allowed directories: {path}"
+            await tool_ctx.error(message)
+            return False, f"{error_prefix}: {message}"
+        return True, ""
+        
+    async def check_path_exists(self, path: str, tool_ctx: Any, error_prefix: str = "Error") -> tuple[bool, str]:
+        """Check if a path exists and log an error if not.
+        
+        Args:
+            path: Path to check
+            tool_ctx: Tool context for logging
+            error_prefix: Prefix for error messages
+            
+        Returns:
+            tuple of (exists, error_message)
+        """
+        file_path = Path(path)
+        if not file_path.exists():
+            message = f"Path does not exist: {path}"
+            await tool_ctx.error(message)
+            return False, f"{error_prefix}: {message}"
+        return True, ""
+        
+    async def check_is_file(self, path: str, tool_ctx: Any, error_prefix: str = "Error") -> tuple[bool, str]:
+        """Check if a path is a file and log an error if not.
+        
+        Args:
+            path: Path to check
+            tool_ctx: Tool context for logging
+            error_prefix: Prefix for error messages
+            
+        Returns:
+            tuple of (is_file, error_message)
+        """
+        file_path = Path(path)
+        if not file_path.is_file():
+            message = f"Path is not a file: {path}"
+            await tool_ctx.error(message)
+            return False, f"{error_prefix}: {message}"
+        return True, ""
+        
+    async def check_is_directory(self, path: str, tool_ctx: Any, error_prefix: str = "Error") -> tuple[bool, str]:
+        """Check if a path is a directory and log an error if not.
+        
+        Args:
+            path: Path to check
+            tool_ctx: Tool context for logging
+            error_prefix: Prefix for error messages
+            
+        Returns:
+            tuple of (is_directory, error_message)
+        """
+        dir_path = Path(path)
+        if not dir_path.is_dir():
+            message = f"Path is not a directory: {path}"
+            await tool_ctx.error(message)
+            return False, f"{error_prefix}: {message}"
+        return True, ""
+        
+    def create_tool_context(self, ctx: MCPContext) -> ToolContext:
+        """Create a tool context with the tool name.
+        
+        Args:
+            ctx: MCP context
+            
+        Returns:
+            Tool context
+        """
+        tool_ctx = create_tool_context(ctx)
+        return tool_ctx
+        
+    def set_tool_context_info(self, tool_ctx: ToolContext) -> None:
+        """Set the tool info on the context.
+        
+        Args:
+            tool_ctx: Tool context
+        """
+        tool_ctx.set_tool_info(self.name)