hanzo-mcp 0.1.34__tar.gz → 0.1.36__tar.gz

{hanzo_mcp-0.1.34 → hanzo_mcp-0.1.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hanzo-mcp
-Version: 0.1.34
+Version: 0.1.36
 Summary: MCP implementation of Hanzo capabilities
 Author-email: Hanzo Industries Inc <dev@hanzo.ai>
 License: MIT
@@ -146,14 +146,19 @@ make bump-patch    # Increment patch version (0.1.x → 0.1.x+1)
 make bump-minor    # Increment minor version (0.x.0 → 0.x+1.0)
 make bump-major    # Increment major version (x.0.0 → x+1.0.0)
 
+# Manual version bumping (alternative to make commands)
+python -m scripts.bump_version patch  # Increment patch version
+python -m scripts.bump_version minor  # Increment minor version
+python -m scripts.bump_version major  # Increment major version
+
 # Publishing (creates git tag and pushes it to GitHub)
 make publish                     # Publish using configured credentials in .pypirc
 PYPI_TOKEN=your_token make publish  # Publish with token from environment variable
 
-# Version bump and publish in one step (with automatic git tagging)
-make publish-patch  # Bump patch version, publish, and create git tag
-make publish-minor  # Bump minor version, publish, and create git tag
-make publish-major  # Bump major version, publish, and create git tag
+# Publishing (creates git tag, pushes to GitHub, and publishes to PyPI)
+make patch    # Bump patch version, build, publish, create git tag, and push
+make minor    # Bump minor version, build, publish, create git tag, and push
+make major    # Bump major version, build, publish, create git tag, and push
 
 # Publish to Test PyPI
 make publish-test

{hanzo_mcp-0.1.34 → hanzo_mcp-0.1.36}/README.md

@@ -105,14 +105,19 @@ make bump-patch    # Increment patch version (0.1.x → 0.1.x+1)
 make bump-minor    # Increment minor version (0.x.0 → 0.x+1.0)
 make bump-major    # Increment major version (x.0.0 → x+1.0.0)
 
+# Manual version bumping (alternative to make commands)
+python -m scripts.bump_version patch  # Increment patch version
+python -m scripts.bump_version minor  # Increment minor version
+python -m scripts.bump_version major  # Increment major version
+
 # Publishing (creates git tag and pushes it to GitHub)
 make publish                     # Publish using configured credentials in .pypirc
 PYPI_TOKEN=your_token make publish  # Publish with token from environment variable
 
-# Version bump and publish in one step (with automatic git tagging)
-make publish-patch  # Bump patch version, publish, and create git tag
-make publish-minor  # Bump minor version, publish, and create git tag
-make publish-major  # Bump major version, publish, and create git tag
+# Publishing (creates git tag, pushes to GitHub, and publishes to PyPI)
+make patch    # Bump patch version, build, publish, create git tag, and push
+make minor    # Bump minor version, build, publish, create git tag, and push
+make major    # Bump major version, build, publish, create git tag, and push
 
 # Publish to Test PyPI
 make publish-test

{hanzo_mcp-0.1.34 → hanzo_mcp-0.1.36}/hanzo_mcp/__init__.py

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

{hanzo_mcp-0.1.34 → hanzo_mcp-0.1.36}/hanzo_mcp/cli.py

@@ -8,6 +8,7 @@ from pathlib import Path
 from typing import Any, cast
 
 from hanzo_mcp.server import HanzoServer
+from hanzo_mcp.tools.common.path_utils import PathUtils
 
 
 def main() -> None:
@@ -113,21 +114,18 @@ def main() -> None:
     # If no allowed paths are specified, use the user's home directory
     if not allowed_paths:
         allowed_paths = [str(Path.home())]
+        
+    # Normalize all allowed paths
+    allowed_paths = [PathUtils.normalize_path(path) for path in allowed_paths]
 
-    # If project directory is specified, add it to allowed paths
-    if project_dir and project_dir not in allowed_paths:
-        allowed_paths.append(project_dir)
-
-    # Set project directory as initial working directory if provided
+    # If project directory is specified, normalize it and add to allowed paths
     if project_dir:
-        # Expand user paths
-        project_dir = os.path.expanduser(project_dir)
-        # Make absolute
-        if not os.path.isabs(project_dir):
-            project_dir = os.path.abspath(project_dir)
+        project_dir = PathUtils.normalize_path(project_dir)
+        if project_dir not in allowed_paths:
+            allowed_paths.append(project_dir)
 
     # If no specific project directory, use the first allowed path
-    elif allowed_paths:
+    if not project_dir and allowed_paths:
         project_dir = allowed_paths[0]
 
     # Run the server

{hanzo_mcp-0.1.34 → hanzo_mcp-0.1.36}/hanzo_mcp/server.py

@@ -6,6 +6,7 @@ from mcp.server.fastmcp import FastMCP
 
 from hanzo_mcp.tools import register_all_tools
 from hanzo_mcp.tools.common.context import DocumentContext
+from hanzo_mcp.tools.common.path_utils import PathUtils
 from hanzo_mcp.tools.common.permissions import PermissionManager
 from hanzo_mcp.tools.project.analysis import ProjectAnalyzer, ProjectManager
 from hanzo_mcp.tools.shell.command_executor import CommandExecutor
@@ -70,8 +71,10 @@ class HanzoServer:
         # Add allowed paths
         if allowed_paths:
             for path in allowed_paths:
-                self.permission_manager.add_allowed_path(path)
-                self.document_context.add_allowed_path(path)
+                # Path should already be normalized from CLI, but normalize here for safety
+                normalized_path = PathUtils.normalize_path(path)
+                self.permission_manager.add_allowed_path(normalized_path)
+                self.document_context.add_allowed_path(normalized_path)
 
         # Store agent options
         self.agent_model = agent_model
@@ -104,8 +107,10 @@ class HanzoServer:
         # Add allowed paths if provided
         allowed_paths_list = allowed_paths or []
         for path in allowed_paths_list:
-            self.permission_manager.add_allowed_path(path)
-            self.document_context.add_allowed_path(path)
+            # Normalize path before adding
+            normalized_path = PathUtils.normalize_path(path)
+            self.permission_manager.add_allowed_path(normalized_path)
+            self.document_context.add_allowed_path(normalized_path)
 
         # Run the server
         transport_type = cast(Literal["stdio", "sse"], transport)

{hanzo_mcp-0.1.34 → hanzo_mcp-0.1.36}/hanzo_mcp/tools/__init__.py

@@ -12,7 +12,7 @@ to delegate tasks to sub-agents for concurrent execution and specialized process
 from mcp.server.fastmcp import FastMCP
 
 from hanzo_mcp.tools.agent import register_agent_tools
-from hanzo_mcp.tools.common import register_thinking_tool, register_version_tool
+from hanzo_mcp.tools.common import register_think_tool, register_version_tool
 from hanzo_mcp.tools.common.context import DocumentContext
 from hanzo_mcp.tools.common.permissions import PermissionManager
 from hanzo_mcp.tools.filesystem import register_filesystem_tools
@@ -78,7 +78,7 @@ def register_all_tools(
         )
     
     # Initialize and register thinking tool
-    register_thinking_tool(mcp_server)
+    register_think_tool(mcp_server)
     
     # Register version tool
     register_version_tool(mcp_server)

{hanzo_mcp-0.1.34 → hanzo_mcp-0.1.36}/hanzo_mcp/tools/common/__init__.py

@@ -3,11 +3,12 @@
 from mcp.server.fastmcp import FastMCP
 
 from hanzo_mcp.tools.common.base import ToolRegistry
-from hanzo_mcp.tools.common.thinking_tool import ThinkingTool
+from hanzo_mcp.tools.common.path_utils import PathUtils
+from hanzo_mcp.tools.common.think_tool import ThinkingTool
 from hanzo_mcp.tools.common.version_tool import VersionTool
 
 
-def register_thinking_tool(
+def register_think_tool(
     mcp_server: FastMCP,
 ) -> None:
     """Register all thinking tools with the MCP server. 
@@ -15,8 +16,8 @@ def register_thinking_tool(
     Args:
         mcp_server: The FastMCP server instance
     """
-    thinking_tool = ThinkingTool()
-    ToolRegistry.register_tool(mcp_server, thinking_tool)
+    think_tool = ThinkingTool()
+    ToolRegistry.register_tool(mcp_server, think_tool)
 
 
 def register_version_tool(

{hanzo_mcp-0.1.34 → hanzo_mcp-0.1.36}/hanzo_mcp/tools/common/context.py

@@ -14,6 +14,8 @@ from typing import Any, ClassVar, final
 from mcp.server.fastmcp import Context as MCPContext
 from mcp.server.lowlevel.helper_types import ReadResourceContents
 
+from hanzo_mcp.tools.common.path_utils import PathUtils
+
 
 @final
 class ToolContext:
@@ -179,9 +181,9 @@ class DocumentContext:
         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()
+        # Normalize path (expand user paths and make absolute)
+        normalized_path = PathUtils.normalize_path(path)
+        resolved_path: Path = Path(normalized_path).resolve()
         self.allowed_paths.add(resolved_path)
 
     def is_path_allowed(self, path: str) -> bool:
@@ -193,9 +195,9 @@ class DocumentContext:
         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()
+        # Normalize path (expand user paths and make absolute)
+        normalized_path = PathUtils.normalize_path(path)
+        resolved_path: Path = Path(normalized_path).resolve()
 
         # Check if the path is within any allowed path
         for allowed_path in self.allowed_paths:

hanzo_mcp-0.1.36/hanzo_mcp/tools/common/path_utils.py

@@ -0,0 +1,51 @@
+"""Path utilities for Hanzo MCP.
+
+This module provides path normalization and validation utilities.
+"""
+
+import os
+from pathlib import Path
+from typing import final
+
+
+@final
+class PathUtils:
+    """Utilities for path handling."""
+
+    @staticmethod
+    def normalize_path(path: str) -> str:
+        """Normalize a path by expanding user paths and making it absolute.
+        
+        Args:
+            path: The path to normalize
+            
+        Returns:
+            The normalized path
+        """
+        # Expand user paths (e.g., ~/ or $HOME)
+        expanded_path = os.path.expanduser(path)
+        
+        # Make the path absolute if it isn't already
+        if not os.path.isabs(expanded_path):
+            expanded_path = os.path.abspath(expanded_path)
+            
+        # Normalize the path (resolve symlinks, etc.)
+        try:
+            normalized_path = os.path.normpath(expanded_path)
+            return normalized_path
+        except Exception:
+            # Return the expanded path if normalization fails
+            return expanded_path
+            
+    @staticmethod
+    def is_dot_directory(path: Path) -> bool:
+        """Check if a path is a dot directory (e.g., .git, .vscode).
+        
+        Args:
+            path: The path to check
+            
+        Returns:
+            True if the path is a dot directory, False otherwise
+        """
+        # Consider any directory starting with "." to be a dot directory
+        return path.is_dir() and path.name.startswith(".")

{hanzo_mcp-0.1.34 → hanzo_mcp-0.1.36}/hanzo_mcp/tools/common/permissions.py

@@ -6,6 +6,8 @@ from collections.abc import Awaitable, Callable
 from pathlib import Path
 from typing import Any, TypeVar, final
 
+from hanzo_mcp.tools.common.path_utils import PathUtils
+
 # Define type variables for better type annotations
 T = TypeVar("T")
 P = TypeVar("P")
@@ -69,9 +71,9 @@ 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()
+        # Normalize path (expand user paths and make absolute)
+        normalized_path = PathUtils.normalize_path(path)
+        resolved_path: Path = Path(normalized_path).resolve()
         self.allowed_paths.add(resolved_path)
 
     def remove_allowed_path(self, path: str) -> None:
@@ -110,9 +112,9 @@ 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()
+        # Normalize path (expand user paths and make absolute)
+        normalized_path = PathUtils.normalize_path(path)
+        resolved_path: Path = Path(normalized_path).resolve()
 
         # Check exclusions first
         if self._is_path_excluded(resolved_path):

{hanzo_mcp-0.1.34 → hanzo_mcp-0.1.36}/hanzo_mcp/tools/common/version_tool.py

@@ -1,9 +1,6 @@
 """Version tool for displaying project version information."""
 
-import importlib.metadata
-import os
-import tomllib
-from typing import Any, Dict, TypedDict, cast, final, override
+from typing import Any, Dict, TypedDict, final, override
 
 from mcp.server.fastmcp import Context as MCPContext
 from mcp.server.fastmcp import FastMCP
@@ -101,21 +98,10 @@ class VersionTool(BaseTool):
         Returns:
             A dictionary containing the package name and version
         """
-        try:
-            version = importlib.metadata.version("hanzo-mcp")
-        except importlib.metadata.PackageNotFoundError:
-            # If package not installed, try to read from pyproject.toml
-            try:
-                root_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", ".."))
-                toml_path = os.path.join(root_dir, "pyproject.toml")
-                
-                with open(toml_path, "rb") as f:
-                    pyproject = tomllib.load(f)
-                    version = cast(str, pyproject.get("project", {}).get("version", "unknown"))
-            except Exception:
-                version = "unknown"
+        # Directly use the __version__ from the hanzo_mcp package
+        from hanzo_mcp import __version__
         
-        return {"version": version, "package_name": "hanzo-mcp"}
+        return {"version": __version__, "package_name": "hanzo-mcp"}
         
     @override
     def register(self, mcp_server: FastMCP) -> None:

{hanzo_mcp-0.1.34 → hanzo_mcp-0.1.36}/hanzo_mcp/tools/filesystem/directory_tree.py

@@ -3,12 +3,14 @@
 This module provides the DirectoryTreeTool for viewing file and directory structures.
 """
 
+import os
 from pathlib import Path
 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.path_utils import PathUtils
 from hanzo_mcp.tools.filesystem.base import FilesystemBaseTool
 
 
@@ -137,17 +139,47 @@ requested. Only works within allowed directories."""
             if not is_dir:
                 return error_msg
 
-            # Define filtered directories
+            # Define filtered directories based on common patterns and .gitignore
             FILTERED_DIRECTORIES = {
-                ".git", "node_modules", ".venv", "venv", 
-                "__pycache__", ".pytest_cache", ".idea", 
-                ".vs", ".vscode", "dist", "build", "target",
-                ".ruff_cache",".llm-context"
+                # Hidden/dot directories
+                ".git", ".github", ".gitignore", ".hg", ".svn", ".venv", ".env",
+                ".idea", ".vscode", ".vs", ".cache", ".config", ".local",
+                ".pytest_cache", ".ruff_cache", ".mypy_cache", ".pytype",
+                ".coverage", ".tox", ".nox", ".circleci", ".llm-context",
+                # Cache directories
+                "__pycache__", ".ipynb_checkpoints", "htmlcov", ".eggs",
+                # Build artifacts
+                "dist", "build", "target", "out", "site", "coverage", 
+                # Dependency directories
+                "node_modules", "venv", "env", "ENV", "lib", "libs", "vendor",
+                "eggs", "sdist", "wheels", "share"
             }
             
             # Log filtering settings
             await tool_ctx.info(f"Directory tree filtering: include_filtered={include_filtered}")
             
+            # Try to get additional patterns from .gitignore if it exists
+            gitignore_patterns = set()
+            gitignore_path = dir_path / ".gitignore"
+            if gitignore_path.exists() and gitignore_path.is_file():
+                try:
+                    with open(gitignore_path, "r") as f:
+                        for line in f:
+                            line = line.strip()
+                            if line and not line.startswith("#"):
+                                # Strip trailing slashes for directory patterns
+                                if line.endswith("/"):
+                                    line = line[:-1]
+                                # Extract the actual pattern without path
+                                pattern = line.split("/")[-1]
+                                if pattern and "*" not in pattern and "?" not in pattern:
+                                    gitignore_patterns.add(pattern)
+                except Exception as e:
+                    await tool_ctx.warning(f"Error reading .gitignore: {str(e)}")
+            
+            # Add gitignore patterns to filtered directories
+            FILTERED_DIRECTORIES.update(gitignore_patterns)
+                
             # Check if a directory should be filtered
             def should_filter(current_path: Path) -> bool:
                 # Don't filter if it's the explicitly requested path
@@ -155,8 +187,15 @@ requested. Only works within allowed directories."""
                     # Don't filter explicitly requested paths
                     return False
                     
-                # Filter based on directory name if filtering is enabled
-                return current_path.name in FILTERED_DIRECTORIES and not include_filtered
+                # First check standard filtered directories
+                if current_path.name in FILTERED_DIRECTORIES and not include_filtered:
+                    return True
+                    
+                # Also filter hidden directories (dot directories) unless explicitly included
+                if PathUtils.is_dot_directory(current_path) and not include_filtered:
+                    return True
+                    
+                return False
             
             # Track stats for summary
             stats = {

{hanzo_mcp-0.1.34 → hanzo_mcp-0.1.36}/hanzo_mcp/tools/shell/command_executor.py

@@ -14,6 +14,8 @@ from collections.abc import Awaitable, Callable
 from pathlib import Path
 from typing import Dict, Optional, final
 
+from hanzo_mcp.tools.common.path_utils import PathUtils
+
 from mcp.server.fastmcp import Context as MCPContext
 from mcp.server.fastmcp import FastMCP
 
@@ -134,8 +136,8 @@ class CommandExecutor:
             path: The path to set as the current working directory
         """
         session = self.get_session_manager(session_id)
-        expanded_path = os.path.expanduser(path)
-        session.set_working_dir(Path(expanded_path))
+        normalized_path = PathUtils.normalize_path(path)
+        session.set_working_dir(Path(normalized_path))
 
     def get_working_dir(self, session_id: str) -> str:
         """Get the current working directory for the session.
@@ -249,11 +251,8 @@ class CommandExecutor:
                     session_cwd = self.get_working_dir(session_id)
                     target_dir = os.path.join(session_cwd, target_dir)
                 
-                # Expand user paths
-                target_dir = os.path.expanduser(target_dir)
-                
-                # Normalize path
-                target_dir = os.path.normpath(target_dir)
+                # Normalize path (expand user and make absolute)
+                target_dir = PathUtils.normalize_path(target_dir)
                 
                 if os.path.isdir(target_dir):
                     self.set_working_dir(session_id, target_dir)

{hanzo_mcp-0.1.34 → hanzo_mcp-0.1.36}/hanzo_mcp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hanzo-mcp
-Version: 0.1.34
+Version: 0.1.36
 Summary: MCP implementation of Hanzo capabilities
 Author-email: Hanzo Industries Inc <dev@hanzo.ai>
 License: MIT
@@ -146,14 +146,19 @@ make bump-patch    # Increment patch version (0.1.x → 0.1.x+1)
 make bump-minor    # Increment minor version (0.x.0 → 0.x+1.0)
 make bump-major    # Increment major version (x.0.0 → x+1.0.0)
 
+# Manual version bumping (alternative to make commands)
+python -m scripts.bump_version patch  # Increment patch version
+python -m scripts.bump_version minor  # Increment minor version
+python -m scripts.bump_version major  # Increment major version
+
 # Publishing (creates git tag and pushes it to GitHub)
 make publish                     # Publish using configured credentials in .pypirc
 PYPI_TOKEN=your_token make publish  # Publish with token from environment variable
 
-# Version bump and publish in one step (with automatic git tagging)
-make publish-patch  # Bump patch version, publish, and create git tag
-make publish-minor  # Bump minor version, publish, and create git tag
-make publish-major  # Bump major version, publish, and create git tag
+# Publishing (creates git tag, pushes to GitHub, and publishes to PyPI)
+make patch    # Bump patch version, build, publish, create git tag, and push
+make minor    # Bump minor version, build, publish, create git tag, and push
+make major    # Bump major version, build, publish, create git tag, and push
 
 # Publish to Test PyPI
 make publish-test

{hanzo_mcp-0.1.34 → hanzo_mcp-0.1.36}/hanzo_mcp.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 LICENSE
 README.md
 pyproject.toml
+setup.py
 hanzo_mcp/__init__.py
 hanzo_mcp/cli.py
 hanzo_mcp/server.py
@@ -18,9 +19,10 @@ hanzo_mcp/tools/agent/tool_adapter.py
 hanzo_mcp/tools/common/__init__.py
 hanzo_mcp/tools/common/base.py
 hanzo_mcp/tools/common/context.py
+hanzo_mcp/tools/common/path_utils.py
 hanzo_mcp/tools/common/permissions.py
 hanzo_mcp/tools/common/session.py
-hanzo_mcp/tools/common/thinking_tool.py
+hanzo_mcp/tools/common/think_tool.py
 hanzo_mcp/tools/common/validation.py
 hanzo_mcp/tools/common/version_tool.py
 hanzo_mcp/tools/filesystem/__init__.py

{hanzo_mcp-0.1.34 → hanzo_mcp-0.1.36}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hanzo-mcp"
-version = "0.1.34"
+version = "0.1.36"
 description = "MCP implementation of Hanzo capabilities"
 readme = "README.md"
 requires-python = ">=3.12"

hanzo_mcp-0.1.36/setup.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python
+"""Setup script for hanzo-mcp."""
+
+import os
+import subprocess
+import sys
+from setuptools import setup
+from setuptools.command.build_py import build_py
+from setuptools.command.develop import develop
+
+
+class UpdateVersionBuildPy(build_py):
+    """Custom build_py command that updates version before building."""
+    
+    def run(self):
+        """Run the command."""
+        # Run the version update script before building
+        update_script = os.path.join('scripts', 'update_version.py')
+        if os.path.exists(update_script):
+            print("Running version update script...")
+            subprocess.check_call([sys.executable, update_script])
+        else:
+            print(f"Warning: Version update script not found at {update_script}")
+        
+        # Continue with the regular build process
+        super().run()
+
+
+class UpdateVersionDevelop(develop):
+    """Custom develop command that updates version before installing in development mode."""
+    
+    def run(self):
+        """Run the command."""
+        # Run the version update script before installing
+        update_script = os.path.join('scripts', 'update_version.py')
+        if os.path.exists(update_script):
+            print("Running version update script...")
+            subprocess.check_call([sys.executable, update_script])
+        else:
+            print(f"Warning: Version update script not found at {update_script}")
+        
+        # Continue with the regular develop process
+        super().run()
+
+
+setup(
+    cmdclass={
+        'build_py': UpdateVersionBuildPy,
+        'develop': UpdateVersionDevelop,
+    },
+)