hanzo-mcp 0.3.8__py3-none-any.whl → 0.5.1__py3-none-any.whl

hanzo_mcp/tools/common/context.py

@@ -11,7 +11,7 @@ from collections.abc import Iterable
 from pathlib import Path
 from typing import Any, ClassVar, final
 
-from mcp.server.fastmcp import Context as MCPContext
+from fastmcp import Context as MCPContext
 from mcp.server.lowlevel.helper_types import ReadResourceContents
 
 
@@ -87,7 +87,11 @@ class ToolContext:
         Args:
             message: The message to log
         """
-        await self._mcp_context.info(self._format_message(message))
+        try:
+            await self._mcp_context.info(self._format_message(message))
+        except Exception:
+            # Silently ignore errors when client has disconnected
+            pass
 
     async def debug(self, message: str) -> None:
         """Log a debug message.
@@ -95,7 +99,11 @@ class ToolContext:
         Args:
             message: The message to log
         """
-        await self._mcp_context.debug(self._format_message(message))
+        try:
+            await self._mcp_context.debug(self._format_message(message))
+        except Exception:
+            # Silently ignore errors when client has disconnected
+            pass
 
     async def warning(self, message: str) -> None:
         """Log a warning message.
@@ -103,7 +111,11 @@ class ToolContext:
         Args:
             message: The message to log
         """
-        await self._mcp_context.warning(self._format_message(message))
+        try:
+            await self._mcp_context.warning(self._format_message(message))
+        except Exception:
+            # Silently ignore errors when client has disconnected
+            pass
 
     async def error(self, message: str) -> None:
         """Log an error message.
@@ -111,7 +123,11 @@ class ToolContext:
         Args:
             message: The message to log
         """
-        await self._mcp_context.error(self._format_message(message))
+        try:
+            await self._mcp_context.error(self._format_message(message))
+        except Exception:
+            # Silently ignore errors when client has disconnected
+            pass
 
     def _format_message(self, message: str) -> str:
         """Format a message with tool information if available.
@@ -135,7 +151,11 @@ class ToolContext:
             current: Current progress value
             total: Total progress value
         """
-        await self._mcp_context.report_progress(current, total)
+        try:
+            await self._mcp_context.report_progress(current, total)
+        except Exception:
+            # Silently ignore errors when client has disconnected
+            pass
 
     async def read_resource(self, uri: str) -> Iterable[ReadResourceContents]:
         """Read a resource via the MCP protocol.
@@ -160,289 +180,3 @@ def create_tool_context(mcp_context: MCPContext) -> ToolContext:
         A new ToolContext
     """
     return ToolContext(mcp_context)
-
-
-@final
-class DocumentContext:
-    """Manages document context and codebase understanding."""
-
-    def __init__(self) -> None:
-        """Initialize the document context."""
-        self.documents: dict[str, str] = {}
-        self.document_metadata: dict[str, dict[str, Any]] = {}
-        self.modified_times: dict[str, float] = {}
-        self.allowed_paths: set[Path] = set()
-
-    def add_allowed_path(self, path: str) -> None:
-        """Add a path to the allowed paths.
-
-        Args:
-            path: The path to allow
-        """
-        # Expand user path (e.g., ~/ or $HOME)
-        expanded_path = os.path.expanduser(path)
-        resolved_path: Path = Path(expanded_path).resolve()
-        self.allowed_paths.add(resolved_path)
-
-    def is_path_allowed(self, path: str) -> bool:
-        """Check if a path is allowed.
-
-        Args:
-            path: The path to check
-
-        Returns:
-            True if the path is allowed, False otherwise
-        """
-        # Expand user path (e.g., ~/ or $HOME)
-        expanded_path = os.path.expanduser(path)
-        resolved_path: Path = Path(expanded_path).resolve()
-
-        # Check if the path is within any allowed path
-        for allowed_path in self.allowed_paths:
-            try:
-                _ = resolved_path.relative_to(allowed_path)
-                return True
-            except ValueError:
-                continue
-
-        return False
-
-    def add_document(
-        self, path: str, content: str, metadata: dict[str, Any] | None = None
-    ) -> None:
-        """Add a document to the context.
-
-        Args:
-            path: The path of the document
-            content: The content of the document
-            metadata: Optional metadata about the document
-        """
-        self.documents[path] = content
-        self.modified_times[path] = time.time()
-
-        if metadata:
-            self.document_metadata[path] = metadata
-        else:
-            # Try to infer metadata
-            self.document_metadata[path] = self._infer_metadata(path, content)
-
-    def get_document(self, path: str) -> str | None:
-        """Get a document from the context.
-
-        Args:
-            path: The path of the document
-
-        Returns:
-            The document content, or None if not found
-        """
-        return self.documents.get(path)
-
-    def get_document_metadata(self, path: str) -> dict[str, Any] | None:
-        """Get document metadata.
-
-        Args:
-            path: The path of the document
-
-        Returns:
-            The document metadata, or None if not found
-        """
-        return self.document_metadata.get(path)
-
-    def update_document(self, path: str, content: str) -> None:
-        """Update a document in the context.
-
-        Args:
-            path: The path of the document
-            content: The new content of the document
-        """
-        self.documents[path] = content
-        self.modified_times[path] = time.time()
-
-        # Update metadata
-        self.document_metadata[path] = self._infer_metadata(path, content)
-
-    def remove_document(self, path: str) -> None:
-        """Remove a document from the context.
-
-        Args:
-            path: The path of the document
-        """
-        if path in self.documents:
-            del self.documents[path]
-
-        if path in self.document_metadata:
-            del self.document_metadata[path]
-
-        if path in self.modified_times:
-            del self.modified_times[path]
-
-    def _infer_metadata(self, path: str, content: str) -> dict[str, Any]:
-        """Infer metadata about a document.
-
-        Args:
-            path: The path of the document
-            content: The content of the document
-
-        Returns:
-            Inferred metadata
-        """
-        extension: str = Path(path).suffix.lower()
-
-        metadata: dict[str, Any] = {
-            "extension": extension,
-            "size": len(content),
-            "line_count": content.count("\n") + 1,
-        }
-
-        # Infer language based on extension
-        language_map: dict[str, list[str]] = {
-            "python": [".py"],
-            "javascript": [".js", ".jsx"],
-            "typescript": [".ts", ".tsx"],
-            "java": [".java"],
-            "c++": [".c", ".cpp", ".h", ".hpp"],
-            "go": [".go"],
-            "rust": [".rs"],
-            "ruby": [".rb"],
-            "php": [".php"],
-            "html": [".html", ".htm"],
-            "css": [".css"],
-            "markdown": [".md"],
-            "json": [".json"],
-            "yaml": [".yaml", ".yml"],
-            "xml": [".xml"],
-            "sql": [".sql"],
-            "shell": [".sh", ".bash"],
-        }
-
-        # Find matching language
-        for language, extensions in language_map.items():
-            if extension in extensions:
-                metadata["language"] = language
-                break
-        else:
-            metadata["language"] = "text"
-
-        return metadata
-
-    def load_directory(
-        self,
-        directory: str,
-        recursive: bool = True,
-        exclude_patterns: list[str] | None = None,
-    ) -> None:
-        """Load all files in a directory into the context.
-
-        Args:
-            directory: The directory to load
-            recursive: Whether to load subdirectories
-            exclude_patterns: Patterns to exclude
-        """
-        if not self.is_path_allowed(directory):
-            raise ValueError(f"Directory not allowed: {directory}")
-
-        dir_path: Path = Path(directory)
-
-        if not dir_path.exists() or not dir_path.is_dir():
-            raise ValueError(f"Not a valid directory: {directory}")
-
-        if exclude_patterns is None:
-            exclude_patterns = []
-
-        # Common directories and files to exclude
-        default_excludes: list[str] = [
-            "__pycache__",
-            ".git",
-            ".github",
-            ".ssh",
-            ".gnupg",
-            ".config",
-            "node_modules",
-            "__pycache__",
-            ".venv",
-            "venv",
-            "env",
-            ".idea",
-            ".vscode",
-            ".DS_Store",
-        ]
-
-        exclude_patterns.extend(default_excludes)
-
-        def should_exclude(path: Path) -> bool:
-            """Check if a path should be excluded.
-
-            Args:
-                path: The path to check
-
-            Returns:
-                True if the path should be excluded, False otherwise
-            """
-            for pattern in exclude_patterns:
-                if pattern.startswith("*"):
-                    if path.name.endswith(pattern[1:]):
-                        return True
-                elif pattern in str(path):
-                    return True
-            return False
-
-        # Walk the directory
-        for root, dirs, files in os.walk(dir_path):
-            # Skip excluded directories
-            dirs[:] = [d for d in dirs if not should_exclude(Path(root) / d)]
-
-            # Process files
-            for file in files:
-                file_path: Path = Path(root) / file
-
-                if should_exclude(file_path):
-                    continue
-
-                try:
-                    with open(file_path, "r", encoding="utf-8") as f:
-                        content: str = f.read()
-
-                    # Add to context
-                    self.add_document(str(file_path), content)
-                except UnicodeDecodeError:
-                    # Skip binary files
-                    continue
-
-            # Stop if not recursive
-            if not recursive:
-                break
-
-    def to_json(self) -> str:
-        """Convert the context to a JSON string.
-
-        Returns:
-            A JSON string representation of the context
-        """
-        data: dict[str, Any] = {
-            "documents": self.documents,
-            "metadata": self.document_metadata,
-            "modified_times": self.modified_times,
-            "allowed_paths": [str(p) for p in self.allowed_paths],
-        }
-
-        return json.dumps(data)
-
-    @classmethod
-    def from_json(cls, json_str: str) -> "DocumentContext":
-        """Create a context from a JSON string.
-
-        Args:
-            json_str: The JSON string
-
-        Returns:
-            A new DocumentContext instance
-        """
-        data: dict[str, Any] = json.loads(json_str)
-
-        context = cls()
-        context.documents = data.get("documents", {})
-        context.document_metadata = data.get("metadata", {})
-        context.modified_times = data.get("modified_times", {})
-        context.allowed_paths = set(Path(p) for p in data.get("allowed_paths", []))
-
-        return context

hanzo_mcp/tools/common/permissions.py

@@ -2,6 +2,8 @@
 
 import json
 import os
+import sys
+import tempfile
 from collections.abc import Awaitable, Callable
 from pathlib import Path
 from typing import Any, TypeVar, final
@@ -18,9 +20,14 @@ class PermissionManager:
     def __init__(self) -> None:
         """Initialize the permission manager."""
         # Allowed paths
-        self.allowed_paths: set[Path] = set(
-            [Path("/tmp").resolve(), Path("/var").resolve()]
-        )
+        self.allowed_paths: set[Path] = set()
+
+        # Allowed paths based on platform
+        if sys.platform == "win32":  # Windows
+            self.allowed_paths.add(Path(tempfile.gettempdir()).resolve())
+        else:  # Unix/Linux/Mac
+            self.allowed_paths.add(Path("/tmp").resolve())
+            self.allowed_paths.add(Path("/var").resolve())
 
         # Excluded paths
         self.excluded_paths: set[Path] = set()
@@ -33,17 +40,14 @@ class PermissionManager:
         """Add default exclusions for sensitive files and directories."""
         # Sensitive directories
         sensitive_dirs: list[str] = [
-            # ".git" is now allowed by default
             ".ssh",
             ".gnupg",
-            ".config",
             "node_modules",
             "__pycache__",
             ".venv",
             "venv",
             "env",
             ".idea",
-            ".vscode",
             ".DS_Store",
         ]
         self.excluded_patterns.extend(sensitive_dirs)
@@ -69,9 +73,7 @@ class PermissionManager:
         Args:
             path: The path to allow
         """
-        # Expand user path (e.g., ~/ or $HOME)
-        expanded_path = os.path.expanduser(path)
-        resolved_path: Path = Path(expanded_path).resolve()
+        resolved_path: Path = Path(path).resolve()
         self.allowed_paths.add(resolved_path)
 
     def remove_allowed_path(self, path: str) -> None:
@@ -110,9 +112,7 @@ class PermissionManager:
         Returns:
             True if the path is allowed, False otherwise
         """
-        # Expand user path (e.g., ~/ or $HOME)
-        expanded_path = os.path.expanduser(path)
-        resolved_path: Path = Path(expanded_path).resolve()
+        resolved_path: Path = Path(path).resolve()
 
         # Check exclusions first
         if self._is_path_excluded(resolved_path):

hanzo_mcp/tools/common/thinking_tool.py

@@ -0,0 +1,153 @@
+"""Thinking tool implementation.
+
+This module provides the ThinkingTool for Claude to engage in structured thinking.
+"""
+
+from typing import Annotated, TypedDict, Unpack, final, override
+
+from fastmcp import Context as MCPContext
+from fastmcp import FastMCP
+from fastmcp.server.dependencies import get_context
+from pydantic import Field
+
+from hanzo_mcp.tools.common.base import BaseTool
+from hanzo_mcp.tools.common.context import create_tool_context
+
+
+Thought = Annotated[
+    str,
+    Field(
+        description="The detailed thought process to record",
+        min_length=1,
+    ),
+]
+
+
+class ThinkingToolParams(TypedDict):
+    """Parameters for the ThinkingTool.
+
+    Attributes:
+        thought: The detailed thought process to record
+    """
+
+    thought: Thought
+
+
+@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. 
+Ensure thinking content is concise and accurate, without needing to include code details
+
+Common use cases:
+1. When exploring a repository and discovering 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
+2. After receiving test results, use this tool to brainstorm ways to fix failing tests
+3. When planning a complex refactoring, use this tool to outline different approaches and their tradeoffs
+4. When designing a new feature, use this tool to think through architecture decisions and implementation details
+5. When debugging a complex issue, use this tool to organize your thoughts and hypotheses
+6. When considering changes to the plan or shifts in thinking that the user has not previously mentioned, consider whether it is necessary to confirm with the user. 
+
+<think_example>
+Feature Implementation Planning
+- New code search feature requirements:
+* Search for code patterns across multiple files
+* Identify function usages and references
+* Analyze import relationships
+* Generate summary of matching patterns
+- Implementation considerations:
+* Need to leverage existing search mechanisms
+* Should use regex for pattern matching
+* Results need consistent format with other search methods
+* Must handle large codebases efficiently
+- Design approach:
+1. Create new CodeSearcher class that follows existing search patterns
+2. Implement core pattern matching algorithm
+3. Add result formatting methods
+4. Integrate with file traversal system
+5. Add caching for performance optimization
+- Testing strategy:
+* Unit tests for search accuracy
+* Integration tests with existing components
+* Performance tests with large codebases
+</think_example>"""
+
+    def __init__(self) -> None:
+        """Initialize the thinking tool."""
+        pass
+
+    @override
+    async def call(
+        self,
+        ctx: MCPContext,
+        **params: Unpack[ThinkingToolParams],
+    ) -> 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.description)
+        async def think(
+            ctx: MCPContext,
+            thought: Thought,
+        ) -> str:
+            ctx = get_context()
+            return await tool_self.call(ctx, thought=thought)

hanzo_mcp/tools/common/validation.py

@@ -3,7 +3,7 @@
 This module provides utilities for validating parameters in tool functions.
 """
 
-from typing import Any, TypeVar, final
+from typing import TypeVar, final
 
 T = TypeVar("T")
 
@@ -32,48 +32,6 @@ class ValidationResult:
         return not self.is_valid
 
 
-def validate_parameter(
-    parameter: Any, parameter_name: str, allow_empty: bool = False
-) -> ValidationResult:
-    """Validate a single parameter.
-
-    Args:
-        parameter: The parameter value to validate
-        parameter_name: The name of the parameter (for error messages)
-        allow_empty: Whether to allow empty strings, lists, etc.
-
-    Returns:
-        A ValidationResult indicating whether the parameter is valid
-    """
-    # Check for None
-    if parameter is None:
-        return ValidationResult(
-            is_valid=False,
-            error_message=f"Parameter '{parameter_name}' is required but was None",
-        )
-
-    # Check for empty strings
-    if isinstance(parameter, str) and not allow_empty and parameter.strip() == "":
-        return ValidationResult(
-            is_valid=False,
-            error_message=f"Parameter '{parameter_name}' is required but was empty string",
-        )
-
-    # Check for empty collections
-    if (
-        isinstance(parameter, (list, tuple, dict, set))
-        and not allow_empty
-        and len(parameter) == 0
-    ):
-        return ValidationResult(
-            is_valid=False,
-            error_message=f"Parameter '{parameter_name}' is required but was empty {type(parameter).__name__}",
-        )
-
-    # Parameter is valid
-    return ValidationResult(is_valid=True)
-
-
 def validate_path_parameter(
     path: str | None, parameter_name: str = "path"
 ) -> ValidationResult:
@@ -102,23 +60,3 @@ def validate_path_parameter(
 
     # Path is valid
     return ValidationResult(is_valid=True)
-
-
-def validate_parameters(**kwargs: Any) -> ValidationResult:
-    """Validate multiple parameters.
-
-    Accepts keyword arguments where the key is the parameter name and the value is the parameter value.
-
-    Args:
-        **kwargs: Parameters to validate as name=value pairs
-
-    Returns:
-        A ValidationResult for the first invalid parameter, or a valid result if all are valid
-    """
-    for name, value in kwargs.items():
-        result = validate_parameter(value, name)
-        if result.is_error:
-            return result
-
-    # All parameters are valid
-    return ValidationResult(is_valid=True)