hanzo-mcp 0.6.10__py3-none-any.whl → 0.6.13__py3-none-any.whl

hanzo_mcp/__init__.py

@@ -1,3 +1,12 @@
-"""Hanzo MCP - Implementation of Hanzo capabilities using MCP."""
+"""Hanzo AI - Implementation of Hanzo capabilities using MCP."""
 
-__version__ = "0.6.10"
+# Configure FastMCP logging globally for stdio transport
+import os
+if os.environ.get("HANZO_MCP_TRANSPORT") == "stdio":
+    try:
+        from fastmcp.utilities.logging import configure_logging
+        configure_logging(level="ERROR")
+    except ImportError:
+        pass
+
+__version__ = "0.6.13"

hanzo_mcp/cli.py

@@ -1,7 +1,8 @@
-"""Command-line interface for the Hanzo MCP server."""
+"""Command-line interface for the Hanzo AI server."""
 
 import argparse
 import json
+import logging
 import os
 import signal
 import sys
@@ -12,14 +13,34 @@ from hanzo_mcp.server import HanzoMCPServer
 
 
 def main() -> None:
-    """Run the CLI for the Hanzo MCP server."""
-    # Set up signal handler to ensure clean exit
-    def signal_handler(signum, frame):
-        print("\nReceived interrupt signal, shutting down...")
-        sys.exit(0)
+    """Run the CLI for the Hanzo AI server."""
     
-    signal.signal(signal.SIGINT, signal_handler)
-    signal.signal(signal.SIGTERM, signal_handler)
+    # Pre-parse arguments to check transport type early
+    import sys
+    early_parser = argparse.ArgumentParser(add_help=False)
+    early_parser.add_argument("--transport", choices=["stdio", "sse"], default="stdio")
+    early_args, _ = early_parser.parse_known_args()
+    
+    # Configure logging VERY early based on transport
+    if early_args.transport == "stdio":
+        # Set environment variable for server to detect stdio mode
+        import os
+        os.environ["HANZO_MCP_TRANSPORT"] = "stdio"
+        
+        # For stdio transport, disable ALL logging immediately
+        from fastmcp.utilities.logging import configure_logging
+        # Set to ERROR to suppress INFO/WARNING messages from FastMCP
+        configure_logging(level="ERROR")
+        
+        # Also configure standard logging to ERROR level
+        logging.basicConfig(
+            level=logging.ERROR,  # Only show errors
+            handlers=[]  # No handlers for stdio to prevent protocol corruption
+        )
+        
+        # Redirect stderr to devnull for stdio transport to prevent any output
+        import sys
+        sys.stderr = open(os.devnull, 'w')
     
     parser = argparse.ArgumentParser(
         description="MCP server implementing Hanzo AI capabilities"
@@ -212,6 +233,32 @@ def main() -> None:
         )
         return
 
+    # Get logger
+    logger = logging.getLogger(__name__)
+    
+    # Set up signal handler to ensure clean exit
+    def signal_handler(signum, frame):
+        if transport != "stdio":
+            logger.info("\nReceived interrupt signal, shutting down...")
+        sys.exit(0)
+    
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+    
+    # Configure logging based on transport (stdio already configured early)
+    if transport != "stdio":
+        # For SSE transport, logging is fine
+        log_level_map = {
+            "DEBUG": logging.DEBUG,
+            "INFO": logging.INFO,
+            "WARNING": logging.WARNING,
+            "ERROR": logging.ERROR
+        }
+        logging.basicConfig(
+            level=log_level_map.get(log_level, logging.INFO),
+            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+
     # If no allowed paths are specified, use the current directory
     if not allowed_paths:
         allowed_paths = [os.getcwd()]
@@ -263,10 +310,11 @@ def main() -> None:
         # Transport will be automatically cast to Literal['stdio', 'sse'] by the server
         server.run(transport=transport)
     except KeyboardInterrupt:
-        print("\nShutting down...")
+        if transport != "stdio":
+            logger.info("\nShutting down...")
         sys.exit(0)
     except Exception as e:
-        print(f"Server error: {e}", file=sys.stderr)
+        logger.error(f"Server error: {e}")
         sys.exit(1)
 
 
@@ -342,27 +390,29 @@ def install_claude_desktop_config(
             existing_config["mcpServers"][name] = config["mcpServers"][name]
             config = existing_config
         except Exception as e:
-            print(f"Error reading existing config: {e}")
-            print("Creating new config file.")
+            logger = logging.getLogger(__name__)
+            logger.error(f"Error reading existing config: {e}")
+            logger.info("Creating new config file.")
 
     # Write the config file
     with open(config_file, mode="w") as f:
         json.dump(config, f, indent=2)
 
-    print(f"Successfully installed {name} in Claude Desktop configuration.")
-    print(f"Config file: {config_file}")
+    logger = logging.getLogger(__name__)
+    logger.info(f"Successfully installed {name} in Claude Desktop configuration.")
+    logger.info(f"Config file: {config_file}")
 
     if allowed_paths:
-        print("\nAllowed paths:")
+        logger.info("\nAllowed paths:")
         for path in allowed_paths:
-            print(f"- {path}")
+            logger.info(f"- {path}")
     else:
-        print(f"\nDefault allowed path: {home}")
+        logger.info(f"\nDefault allowed path: {home}")
 
-    print(
+    logger.info(
         "\nYou can modify allowed paths in the config file directly."
     )
-    print("Restart Claude Desktop for changes to take effect.")
+    logger.info("Restart Claude Desktop for changes to take effect.")
 
 
 if __name__ == "__main__":

hanzo_mcp/cli_enhanced.py

@@ -1,7 +1,8 @@
-"""Enhanced command-line interface for the Hanzo MCP server with full tool configuration."""
+"""Enhanced command-line interface for the Hanzo AI server with full tool configuration."""
 
 import argparse
 import json
+import logging
 import os
 import sys
 from pathlib import Path
@@ -14,7 +15,7 @@ from hanzo_mcp.server import HanzoMCPServer
 def create_parser() -> argparse.ArgumentParser:
     """Create the argument parser with all tool configuration options."""
     parser = argparse.ArgumentParser(
-        description="Hanzo MCP server with comprehensive tool configuration",
+        description="Hanzo AI server with comprehensive tool configuration",
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog="""
 Tool Configuration:
@@ -344,8 +345,9 @@ def apply_cli_overrides(args: argparse.Namespace) -> Dict[str, Any]:
 
 def list_tools(settings: HanzoMCPSettings) -> None:
     """List all tools and their current status."""
-    print("Hanzo MCP Tools Status:")
-    print("=" * 50)
+    logger = logging.getLogger(__name__)
+    logger.info("Hanzo AI Tools Status:")
+    logger.info("=" * 50)
     
     categories = {}
     for tool_name, tool_config in TOOL_REGISTRY.items():
@@ -358,18 +360,18 @@ def list_tools(settings: HanzoMCPSettings) -> None:
         categories[category].append((tool_name, status, tool_config.description))
     
     for category, tools in categories.items():
-        print(f"\n{category.upper()} TOOLS:")
-        print("-" * 30)
+        logger.info(f"\n{category.upper()} TOOLS:")
+        logger.info("-" * 30)
         for tool_name, status, description in tools:
-            print(f"  {status} {tool_name:<15} - {description}")
+            logger.info(f"  {status} {tool_name:<15} - {description}")
     
-    print(f"\nTotal: {len(TOOL_REGISTRY)} tools")
+    logger.info(f"\nTotal: {len(TOOL_REGISTRY)} tools")
     enabled_count = len(settings.get_enabled_tools())
-    print(f"Enabled: {enabled_count}, Disabled: {len(TOOL_REGISTRY) - enabled_count}")
+    logger.info(f"Enabled: {enabled_count}, Disabled: {len(TOOL_REGISTRY) - enabled_count}")
 
 
 def main() -> None:
-    """Run the enhanced CLI for the Hanzo MCP server."""
+    """Run the enhanced CLI for the Hanzo AI server."""
     parser = create_parser()
     args = parser.parse_args()
 
@@ -385,14 +387,15 @@ def main() -> None:
     settings = load_settings(project_dir=project_dir, config_overrides=config_overrides)
 
     # Handle configuration saving
+    logger = logging.getLogger(__name__)
     if hasattr(args, 'save_config') and args.save_config:
         saved_path = save_settings(settings, global_config=True)
-        print(f"Configuration saved to: {saved_path}")
+        logger.info(f"Configuration saved to: {saved_path}")
         return
     
     if hasattr(args, 'save_project_config') and args.save_project_config:
         saved_path = save_settings(settings, global_config=False)
-        print(f"Project configuration saved to: {saved_path}")
+        logger.info(f"Project configuration saved to: {saved_path}")
         return
 
     # Handle installation

hanzo_mcp/cli_plugin.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""CLI for managing Hanzo MCP plugins."""
+
+import argparse
+import sys
+from pathlib import Path
+
+from hanzo_mcp.tools.common.plugin_loader import create_plugin_template, list_plugin_tools
+
+
+def main():
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description="Hanzo MCP Plugin Manager",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Create a new plugin template
+  hanzo-plugin create mytool
+  
+  # List installed plugins
+  hanzo-plugin list
+  
+  # Create plugin in specific directory
+  hanzo-plugin create mytool --output /path/to/plugins
+"""
+    )
+    
+    subparsers = parser.add_subparsers(dest="command", help="Command to run")
+    
+    # Create command
+    create_parser = subparsers.add_parser("create", help="Create a new plugin template")
+    create_parser.add_argument("name", help="Name of the tool (e.g., 'mytool')")
+    create_parser.add_argument(
+        "--output", "-o",
+        type=Path,
+        default=Path.home() / ".hanzo" / "plugins",
+        help="Output directory for the plugin (default: ~/.hanzo/plugins)"
+    )
+    
+    # List command
+    list_parser = subparsers.add_parser("list", help="List installed plugins")
+    
+    args = parser.parse_args()
+    
+    if args.command == "create":
+        # Create plugin template
+        output_dir = args.output / args.name
+        try:
+            create_plugin_template(output_dir, args.name)
+            print(f"\n✅ Plugin template created successfully!")
+            print(f"\nTo use your plugin:")
+            print(f"1. Edit the tool implementation in {output_dir / f'{args.name}_tool.py'}")
+            print(f"2. Restart Hanzo MCP to load the plugin")
+            print(f"3. Add '{args.name}' to your mode's tool list")
+        except Exception as e:
+            print(f"❌ Error creating plugin: {e}", file=sys.stderr)
+            sys.exit(1)
+    
+    elif args.command == "list":
+        # List installed plugins
+        try:
+            from hanzo_mcp.tools.common.plugin_loader import load_user_plugins
+            plugins = load_user_plugins()
+            
+            if not plugins:
+                print("No plugins installed.")
+                print("\nPlugin directories:")
+                print("  ~/.hanzo/plugins/")
+                print("  ./.hanzo/plugins/")
+                print("  $HANZO_PLUGIN_PATH")
+            else:
+                print(f"Installed plugins ({len(plugins)}):")
+                for name, plugin in plugins.items():
+                    print(f"\n  {name}:")
+                    print(f"    Source: {plugin.source_path}")
+                    if plugin.metadata:
+                        print(f"    Version: {plugin.metadata.get('version', 'unknown')}")
+                        print(f"    Author: {plugin.metadata.get('author', 'unknown')}")
+                        print(f"    Description: {plugin.metadata.get('description', '')}")
+        except Exception as e:
+            print(f"❌ Error listing plugins: {e}", file=sys.stderr)
+            sys.exit(1)
+    
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

hanzo_mcp/config/__init__.py

@@ -1,4 +1,4 @@
-"""Configuration management for Hanzo MCP.
+"""Configuration management for Hanzo AI.
 
 This module provides a comprehensive configuration system that supports:
 - CLI arguments for individual tool control

hanzo_mcp/config/settings.py

@@ -1,4 +1,4 @@
-"""Settings management for Hanzo MCP.
+"""Settings management for Hanzo AI.
 
 Handles loading and saving configuration from multiple sources:
 1. Default settings
@@ -59,6 +59,7 @@ class AgentConfig:
     enabled: bool = False
     model: Optional[str] = None
     api_key: Optional[str] = None
+    hanzo_api_key: Optional[str] = None  # HANZO_API_KEY support
     base_url: Optional[str] = None
     max_tokens: Optional[int] = None
     max_iterations: int = 10
@@ -78,7 +79,7 @@ class ServerConfig:
 
 @dataclass
 class HanzoMCPSettings:
-    """Complete configuration for Hanzo MCP."""
+    """Complete configuration for Hanzo AI."""
     # Server settings
     server: ServerConfig = field(default_factory=ServerConfig)
     
@@ -106,6 +107,9 @@ class HanzoMCPSettings:
     projects: Dict[str, ProjectConfig] = field(default_factory=dict)
     current_project: Optional[str] = None
     
+    # Mode configuration
+    active_mode: Optional[str] = None
+    
     def __post_init__(self):
         """Initialize default tool states if not specified."""
         if not self.enabled_tools:
@@ -250,7 +254,7 @@ class HanzoMCPSettings:
 
 
 def get_config_dir() -> Path:
-    """Get the configuration directory for Hanzo MCP."""
+    """Get the configuration directory for Hanzo AI."""
     if os.name == "nt":  # Windows
         config_dir = Path(os.environ.get("APPDATA", "")) / "hanzo"
     else:  # Unix/macOS
@@ -341,6 +345,59 @@ def detect_project_from_path(file_path: str) -> Optional[Dict[str, str]]:
     return None
 
 
+def _load_from_env() -> Dict[str, Any]:
+    """Load configuration from environment variables."""
+    config = {}
+    
+    # Check for agent API keys
+    has_api_keys = False
+    
+    # HANZO_API_KEY
+    if hanzo_key := os.environ.get("HANZO_API_KEY"):
+        config.setdefault("agent", {})["hanzo_api_key"] = hanzo_key
+        config["agent"]["enabled"] = True
+        has_api_keys = True
+    
+    # Check for other API keys
+    api_key_env_vars = [
+        ("OPENAI_API_KEY", "openai"),
+        ("ANTHROPIC_API_KEY", "anthropic"), 
+        ("GOOGLE_API_KEY", "google"),
+        ("GROQ_API_KEY", "groq"),
+        ("TOGETHER_API_KEY", "together"),
+        ("MISTRAL_API_KEY", "mistral"),
+        ("PERPLEXITY_API_KEY", "perplexity"),
+    ]
+    
+    for env_var, provider in api_key_env_vars:
+        if os.environ.get(env_var):
+            has_api_keys = True
+            break
+    
+    # Auto-enable agent and consensus tools if API keys present
+    if has_api_keys:
+        config.setdefault("enabled_tools", {})
+        config["enabled_tools"]["agent"] = True
+        config["enabled_tools"]["consensus"] = True
+        config.setdefault("agent", {})["enabled"] = True
+    
+    # Check for MODE/PERSONALITY/HANZO_MODE
+    if mode := os.environ.get("HANZO_MODE") or os.environ.get("PERSONALITY") or os.environ.get("MODE"):
+        config["active_mode"] = mode
+    
+    # Check for other environment overrides
+    if project_dir := os.environ.get("HANZO_PROJECT_DIR"):
+        config["project_dir"] = project_dir
+    
+    if log_level := os.environ.get("HANZO_LOG_LEVEL"):
+        config.setdefault("server", {})["log_level"] = log_level
+    
+    if allowed_paths := os.environ.get("HANZO_ALLOWED_PATHS"):
+        config["allowed_paths"] = allowed_paths.split(":")
+    
+    return config
+
+
 def load_settings(
     project_dir: Optional[str] = None,
     config_overrides: Optional[Dict[str, Any]] = None
@@ -349,9 +406,10 @@ def load_settings(
     
     Priority (highest to lowest):
     1. config_overrides (usually from CLI)
-    2. Project-specific config file
-    3. Global config file
-    4. Defaults
+    2. Environment variables
+    3. Project-specific config file
+    4. Global config file
+    5. Defaults
     """
     # Start with defaults
     settings = HanzoMCPSettings()
@@ -364,7 +422,9 @@ def load_settings(
                 global_config = json.load(f)
                 settings = _merge_config(settings, global_config)
         except Exception as e:
-            print(f"Warning: Failed to load global config: {e}")
+            import logging
+            logger = logging.getLogger(__name__)
+            logger.warning(f"Failed to load global config: {e}")
     
     # Load project config
     project_config_path = get_project_config_path(project_dir)
@@ -374,7 +434,14 @@ def load_settings(
                 project_config = json.load(f)
                 settings = _merge_config(settings, project_config)
         except Exception as e:
-            print(f"Warning: Failed to load project config: {e}")
+            import logging
+            logger = logging.getLogger(__name__)
+            logger.warning(f"Failed to load project config: {e}")
+    
+    # Apply environment variables
+    env_config = _load_from_env()
+    if env_config:
+        settings = _merge_config(settings, env_config)
     
     # Apply CLI overrides
     if config_overrides:

hanzo_mcp/config/tool_config.py

@@ -1,4 +1,4 @@
-"""Tool configuration definitions for Hanzo MCP."""
+"""Tool configuration definitions for Hanzo AI."""
 
 from enum import Enum
 from typing import Dict, List, Optional
@@ -6,7 +6,7 @@ from dataclasses import dataclass
 
 
 class ToolCategory(str, Enum):
-    """Categories of tools available in Hanzo MCP."""
+    """Categories of tools available in Hanzo AI."""
     FILESYSTEM = "filesystem"
     SHELL = "shell"
     JUPYTER = "jupyter"

hanzo_mcp/dev_server.py

@@ -1,6 +1,7 @@
-"""Development server with hot reload for Hanzo MCP."""
+"""Development server with hot reload for Hanzo AI."""
 
 import asyncio
+import logging
 import os
 import sys
 import time
@@ -67,8 +68,9 @@ class MCPReloadHandler(FileSystemEventHandler):
         
         self.last_reload = current_time
         
-        print(f"\n🔄 File changed: {event.src_path}")
-        print("🔄 Reloading MCP server...")
+        logger = logging.getLogger(__name__)
+        logger.info(f"\n🔄 File changed: {event.src_path}")
+        logger.info("🔄 Reloading MCP server...")
         
         self.restart_callback()
 
@@ -133,9 +135,10 @@ class DevServer:
                 self.observer.schedule(handler, path, recursive=True)
         
         self.observer.start()
-        print(f"👀 Watching for changes in: {package_dir}")
+        logger = logging.getLogger(__name__)
+        logger.info(f"👀 Watching for changes in: {package_dir}")
         if self.project_dir:
-            print(f"👀 Also watching: {self.project_dir}")
+            logger.info(f"👀 Also watching: {self.project_dir}")
     
     def stop_file_watcher(self):
         """Stop the file watcher."""
@@ -146,18 +149,20 @@ class DevServer:
     def restart_server(self):
         """Restart the MCP server."""
         # Since MCP servers run in the same process, we need to handle this differently
-        # For now, we'll print a message indicating a restart is needed
-        print("\n⚠️  Server restart required. Please restart the MCP client to reload changes.")
-        print("💡 Tip: In development, consider using the MCP test client for easier reloading.")
+        # For now, we'll log a message indicating a restart is needed
+        logger = logging.getLogger(__name__)
+        logger.warning("\n⚠️  Server restart required. Please restart the MCP client to reload changes.")
+        logger.info("💡 Tip: In development, consider using the MCP test client for easier reloading.")
     
     async def run_async(self, transport: str = "stdio"):
         """Run the development server asynchronously."""
         self.running = True
         
-        print(f"\n🚀 Starting Hanzo MCP in development mode...")
-        print(f"🔧 Hot reload enabled - watching for file changes")
-        print(f"📁 Project: {self.project_dir or 'current directory'}")
-        print(f"🌐 Transport: {transport}\n")
+        logger = logging.getLogger(__name__)
+        logger.info(f"\n🚀 Starting Hanzo AI in development mode...")
+        logger.info(f"🔧 Hot reload enabled - watching for file changes")
+        logger.info(f"📁 Project: {self.project_dir or 'current directory'}")
+        logger.info(f"🌐 Transport: {transport}\n")
         
         # Start file watcher
         self.start_file_watcher()
@@ -170,11 +175,11 @@ class DevServer:
             server.run(transport=transport)
             
         except KeyboardInterrupt:
-            print("\n\n🛑 Shutting down development server...")
+            logger.info("\n\n🛑 Shutting down development server...")
         finally:
             self.running = False
             self.stop_file_watcher()
-            print("👋 Development server stopped")
+            logger.info("👋 Development server stopped")
     
     def run(self, transport: str = "stdio"):
         """Run the development server."""
@@ -189,7 +194,7 @@ def run_dev_server():
     """Entry point for development server."""
     import argparse
     
-    parser = argparse.ArgumentParser(description="Run Hanzo MCP in development mode with hot reload")
+    parser = argparse.ArgumentParser(description="Run Hanzo AI in development mode with hot reload")
     parser.add_argument(
         "--name",
         type=str,

hanzo_mcp/prompts/project_system.py

@@ -30,7 +30,7 @@ Recent commits:
 </project_info>
 
 <available_tools>
-Hanzo MCP provides 65+ tools organized by category. Key tools include:
+Hanzo AI provides 65+ tools organized by category. Key tools include:
 
 # File Operations
 - read, write, edit, multi_edit: File manipulation

hanzo_mcp/server.py

@@ -1,6 +1,7 @@
 """MCP server implementing Hanzo capabilities."""
 
 import atexit
+import logging
 import signal
 import threading
 import time
@@ -15,6 +16,9 @@ except ImportError:
     # Fallback for older MCP versions
     from mcp.server import FastMCP
 
+# Import our enhanced server
+from hanzo_mcp.server_enhanced import EnhancedFastMCP
+
 from hanzo_mcp.prompts import register_all_prompts
 from hanzo_mcp.tools import register_all_tools
 
@@ -48,7 +52,7 @@ class HanzoMCPServer:
         enabled_tools: dict[str, bool] | None = None,
         disabled_tools: list[str] | None = None,
     ):
-        """Initialize the Hanzo MCP server.
+        """Initialize the Hanzo AI server.
 
         Args:
             name: The name of the server
@@ -71,7 +75,8 @@ class HanzoMCPServer:
             enabled_tools: Dictionary of individual tool enable states (default: None)
             disabled_tools: List of tool names to disable (default: None)
         """
-        self.mcp = mcp_instance if mcp_instance is not None else FastMCP(name)
+        # Use enhanced server for automatic context normalization
+        self.mcp = mcp_instance if mcp_instance is not None else EnhancedFastMCP(name)
 
         # Initialize permissions and command executor
         self.permission_manager = PermissionManager()
@@ -154,7 +159,10 @@ class HanzoMCPServer:
         # Register signal handlers for graceful shutdown
         def signal_handler(signum, frame):
             import sys
-            print("\nShutting down gracefully...")
+            # Only log if not stdio transport
+            if hasattr(self, '_transport') and self._transport != 'stdio':
+                logger = logging.getLogger(__name__)
+                logger.info("\nShutting down gracefully...")
             self._cleanup_sessions()
             self._shutdown_event.set()
             sys.exit(0)
@@ -189,7 +197,10 @@ class HanzoMCPServer:
         try:
             cleared_count = SessionStorage.clear_all_sessions()
             if cleared_count > 0:
-                print(f"Cleaned up {cleared_count} tmux sessions on shutdown")
+                # Only log if not stdio transport
+                if hasattr(self, '_transport') and self._transport != 'stdio':
+                    logger = logging.getLogger(__name__)
+                    logger.info(f"Cleaned up {cleared_count} tmux sessions on shutdown")
         except Exception:
             # Ignore cleanup errors during shutdown
             pass
@@ -201,6 +212,9 @@ class HanzoMCPServer:
             transport: The transport to use (stdio or sse)
             allowed_paths: list of paths that the server is allowed to access
         """
+        # Store transport for later use
+        self._transport = transport
+        
         # Add allowed paths if provided
         allowed_paths_list = allowed_paths or []
         for path in allowed_paths_list: