hanzo-mcp 0.7.7__tar.gz → 0.8.0__tar.gz

{hanzo_mcp-0.7.7 → hanzo_mcp-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hanzo-mcp
-Version: 0.7.7
+Version: 0.8.0
 Summary: The Zen of Hanzo MCP: One server to rule them all. The ultimate MCP that orchestrates all others.
 Author-email: Hanzo Industries Inc <dev@hanzo.ai>
 License: MIT

{hanzo_mcp-0.7.7 → hanzo_mcp-0.8.0}/hanzo_mcp/__init__.py

@@ -2,9 +2,15 @@
 
 # Configure FastMCP logging globally for stdio transport
 import os
+import warnings
+
+# Suppress litellm deprecation warnings about event loop
+warnings.filterwarnings("ignore", message="There is no current event loop", category=DeprecationWarning)
+
 if os.environ.get("HANZO_MCP_TRANSPORT") == "stdio":
     try:
         from fastmcp.utilities.logging import configure_logging
+
         configure_logging(level="ERROR")
     except ImportError:
         pass

{hanzo_mcp-0.7.7 → hanzo_mcp-0.8.0}/hanzo_mcp/__main__.py

@@ -3,4 +3,4 @@
 from hanzo_mcp.cli import main
 
 if __name__ == "__main__":
-    main()
+    main()

{hanzo_mcp-0.7.7 → hanzo_mcp-0.8.0}/hanzo_mcp/analytics/__init__.py

@@ -1,5 +1,5 @@
 """Analytics module for Hanzo MCP using PostHog."""
 
-from .posthog_analytics import Analytics, track_event, track_tool_usage, track_error
+from .posthog_analytics import Analytics, track_error, track_event, track_tool_usage
 
-__all__ = ["Analytics", "track_event", "track_tool_usage", "track_error"]
+__all__ = ["Analytics", "track_event", "track_tool_usage", "track_error"]

{hanzo_mcp-0.7.7 → hanzo_mcp-0.8.0}/hanzo_mcp/analytics/posthog_analytics.py

@@ -9,29 +9,31 @@ This module provides analytics tracking for:
 
 import os
 import time
+import asyncio
+import platform
 import functools
 import traceback
-from typing import Dict, Any, Optional, Callable, TypeVar
+from typing import Any, Dict, TypeVar, Callable, Optional
 from datetime import datetime
-import platform
-import asyncio
 from dataclasses import dataclass
 
 # Try to import PostHog, but make it optional
 try:
     from posthog import Posthog
+
     POSTHOG_AVAILABLE = True
 except ImportError:
     POSTHOG_AVAILABLE = False
     Posthog = None
 
 
-F = TypeVar('F', bound=Callable[..., Any])
+F = TypeVar("F", bound=Callable[..., Any])
 
 
 @dataclass
 class AnalyticsConfig:
     """Configuration for analytics."""
+
     api_key: Optional[str] = None
     host: str = "https://us.i.posthog.com"
     enabled: bool = True
@@ -39,56 +41,57 @@ class AnalyticsConfig:
     capture_errors: bool = True
     capture_performance: bool = True
     distinct_id: Optional[str] = None
-    
+
 
 class Analytics:
     """Main analytics class for Hanzo MCP."""
-    
+
     def __init__(self, config: Optional[AnalyticsConfig] = None):
         """Initialize analytics with configuration."""
         self.config = config or AnalyticsConfig()
         self._client = None
-        
+
         # Load from environment if not provided
         if not self.config.api_key:
             self.config.api_key = os.environ.get("POSTHOG_API_KEY")
-            
+
         if not self.config.distinct_id:
             # Use machine ID or generate one
             self.config.distinct_id = self._get_distinct_id()
-            
+
         # Initialize PostHog if available and configured
         if POSTHOG_AVAILABLE and self.config.api_key and self.config.enabled:
             self._client = Posthog(
                 self.config.api_key,
                 host=self.config.host,
                 debug=self.config.debug,
-                enable_exception_autocapture=self.config.capture_errors
+                enable_exception_autocapture=self.config.capture_errors,
             )
-    
+
     def _get_distinct_id(self) -> str:
         """Get a distinct ID for this installation."""
         # Try to get from environment
         distinct_id = os.environ.get("HANZO_DISTINCT_ID")
         if distinct_id:
             return distinct_id
-            
+
         # Use hostname + username as fallback
         import socket
         import getpass
+
         hostname = socket.gethostname()
         username = getpass.getuser()
         return f"{hostname}:{username}"
-    
+
     def is_enabled(self) -> bool:
         """Check if analytics is enabled."""
         return bool(self._client and self.config.enabled)
-    
+
     def capture(self, event: str, properties: Optional[Dict[str, Any]] = None) -> None:
         """Capture an analytics event."""
         if not self.is_enabled():
             return
-            
+
         try:
             # Add common properties
             props = {
@@ -96,97 +99,84 @@ class Analytics:
                 "platform": platform.system(),
                 "python_version": platform.python_version(),
                 "mcp_version": "0.6.13",  # TODO: Get from package
-                **(properties or {})
+                **(properties or {}),
             }
-            
-            self._client.capture(
-                self.config.distinct_id,
-                event,
-                properties=props
-            )
+
+            self._client.capture(self.config.distinct_id, event, properties=props)
         except Exception as e:
             if self.config.debug:
                 print(f"Analytics error: {e}")
-    
+
     def identify(self, properties: Optional[Dict[str, Any]] = None) -> None:
         """Identify the current user/installation."""
         if not self.is_enabled():
             return
-            
+
         try:
-            self._client.identify(
-                self.config.distinct_id,
-                properties=properties or {}
-            )
+            self._client.identify(self.config.distinct_id, properties=properties or {})
         except Exception as e:
             if self.config.debug:
                 print(f"Analytics identify error: {e}")
-    
-    def track_tool_usage(self, 
-                        tool_name: str,
-                        duration_ms: Optional[float] = None,
-                        success: bool = True,
-                        error: Optional[str] = None,
-                        metadata: Optional[Dict[str, Any]] = None) -> None:
+
+    def track_tool_usage(
+        self,
+        tool_name: str,
+        duration_ms: Optional[float] = None,
+        success: bool = True,
+        error: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> None:
         """Track tool usage event."""
-        properties = {
-            "tool_name": tool_name,
-            "success": success,
-            **(metadata or {})
-        }
-        
+        properties = {"tool_name": tool_name, "success": success, **(metadata or {})}
+
         if duration_ms is not None:
             properties["duration_ms"] = duration_ms
-            
+
         if error:
             properties["error"] = str(error)
-            
+
         self.capture("tool_used", properties)
-    
-    def track_error(self,
-                   error: Exception,
-                   context: Optional[Dict[str, Any]] = None) -> None:
+
+    def track_error(
+        self, error: Exception, context: Optional[Dict[str, Any]] = None
+    ) -> None:
         """Track an error event."""
         if not self.config.capture_errors:
             return
-            
+
         properties = {
             "error_type": type(error).__name__,
             "error_message": str(error),
             "error_traceback": traceback.format_exc(),
-            **(context or {})
+            **(context or {}),
         }
-        
+
         self.capture("error_occurred", properties)
-    
+
     def feature_enabled(self, flag_key: str, default: bool = False) -> bool:
         """Check if a feature flag is enabled."""
         if not self.is_enabled():
             return default
-            
+
         try:
             return self._client.feature_enabled(
-                flag_key,
-                self.config.distinct_id,
-                default=default
+                flag_key, self.config.distinct_id, default=default
             )
         except Exception:
             return default
-    
+
     def get_feature_flag(self, flag_key: str, default: Any = None) -> Any:
         """Get feature flag value."""
         if not self.is_enabled():
             return default
-            
+
         try:
             return self._client.get_feature_flag(
-                flag_key,
-                self.config.distinct_id,
-                default=default
+                flag_key, self.config.distinct_id, default=default
             )
         except Exception:
             return default
-    
+
     def flush(self) -> None:
         """Flush any pending events."""
         if self.is_enabled():
@@ -194,7 +184,7 @@ class Analytics:
                 self._client.flush()
             except Exception:
                 pass
-    
+
     def shutdown(self) -> None:
         """Shutdown analytics client."""
         if self.is_enabled():
@@ -233,6 +223,7 @@ def track_error(error: Exception, context: Optional[Dict[str, Any]] = None) -> N
 
 def with_analytics(tool_name: str):
     """Decorator to track tool usage with analytics."""
+
     def decorator(func: F) -> F:
         @functools.wraps(func)
         async def async_wrapper(*args, **kwargs):
@@ -251,9 +242,9 @@ def with_analytics(tool_name: str):
                     tool_name,
                     duration_ms=duration_ms,
                     success=error is None,
-                    error=str(error) if error else None
+                    error=str(error) if error else None,
                 )
-        
+
         @functools.wraps(func)
         def sync_wrapper(*args, **kwargs):
             start_time = time.time()
@@ -271,20 +262,21 @@ def with_analytics(tool_name: str):
                     tool_name,
                     duration_ms=duration_ms,
                     success=error is None,
-                    error=str(error) if error else None
+                    error=str(error) if error else None,
                 )
-        
+
         # Return appropriate wrapper based on function type
         if asyncio.iscoroutinefunction(func):
             return async_wrapper
         else:
             return sync_wrapper
-    
+
     return decorator
 
 
 def feature_flag(flag_key: str, default: bool = False):
     """Decorator to conditionally enable features based on flags."""
+
     def decorator(func: F) -> F:
         @functools.wraps(func)
         def wrapper(*args, **kwargs):
@@ -292,40 +284,42 @@ def feature_flag(flag_key: str, default: bool = False):
                 return func(*args, **kwargs)
             else:
                 raise NotImplementedError(f"Feature '{flag_key}' is not enabled")
+
         return wrapper
+
     return decorator
 
 
 # Tool usage context manager
 class ToolUsageTracker:
     """Context manager for tracking tool usage."""
-    
+
     def __init__(self, tool_name: str, metadata: Optional[Dict[str, Any]] = None):
         self.tool_name = tool_name
         self.metadata = metadata or {}
         self.start_time = None
         self.error = None
-    
+
     def __enter__(self):
         self.start_time = time.time()
         return self
-    
+
     def __exit__(self, exc_type, exc_val, exc_tb):
         duration_ms = (time.time() - self.start_time) * 1000
         success = exc_type is None
-        
+
         if exc_type:
             self.error = str(exc_val)
             track_error(exc_val, {"tool": self.tool_name, **self.metadata})
-        
+
         track_tool_usage(
             self.tool_name,
             duration_ms=duration_ms,
             success=success,
             error=self.error,
-            metadata=self.metadata
+            metadata=self.metadata,
         )
-        
+
         # Don't suppress exceptions
         return False
 
@@ -333,32 +327,32 @@ class ToolUsageTracker:
 # Async context manager version
 class AsyncToolUsageTracker:
     """Async context manager for tracking tool usage."""
-    
+
     def __init__(self, tool_name: str, metadata: Optional[Dict[str, Any]] = None):
         self.tool_name = tool_name
         self.metadata = metadata or {}
         self.start_time = None
         self.error = None
-    
+
     async def __aenter__(self):
         self.start_time = time.time()
         return self
-    
+
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         duration_ms = (time.time() - self.start_time) * 1000
         success = exc_type is None
-        
+
         if exc_type:
             self.error = str(exc_val)
             track_error(exc_val, {"tool": self.tool_name, **self.metadata})
-        
+
         track_tool_usage(
             self.tool_name,
             duration_ms=duration_ms,
             success=success,
             error=self.error,
-            metadata=self.metadata
+            metadata=self.metadata,
         )
-        
+
         # Don't suppress exceptions
-        return False
+        return False

{hanzo_mcp-0.7.7 → hanzo_mcp-0.8.0}/hanzo_mcp/cli.py

@@ -1,57 +1,59 @@
 """Command-line interface for the Hanzo AI server."""
 
-import argparse
-import json
-import logging
 import os
-import signal
 import sys
-from pathlib import Path
+import json
+import signal
+import logging
+import argparse
 from typing import Any, cast
+from pathlib import Path
 
 from hanzo_mcp.server import HanzoMCPServer
 
 
 def main() -> None:
     """Run the CLI for the Hanzo AI server."""
-    
+
     # 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
+            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')
-    
+
+        sys.stderr = open(os.devnull, "w")
+
     from hanzo_mcp import __version__
-    
+
     parser = argparse.ArgumentParser(
         description="MCP server implementing Hanzo AI capabilities"
     )
-    
+
     parser.add_argument(
-        "--version",
-        action="version",
-        version=f"hanzo-mcp {__version__}"
+        "--version", action="version", version=f"hanzo-mcp {__version__}"
     )
 
     _ = parser.add_argument(
@@ -188,7 +190,7 @@ def main() -> None:
         action="store_true",
         help="Run in development mode with hot reload",
     )
-    
+
     _ = parser.add_argument(
         "--install",
         action="store_true",
@@ -232,27 +234,22 @@ def main() -> None:
 
     if install:
         install_claude_desktop_config(
-            name, 
-            allowed_paths, 
-            disable_write_tools, 
-            disable_search_tools, 
-            host, 
-            port
+            name, allowed_paths, disable_write_tools, disable_search_tools, host, port
         )
         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
@@ -260,11 +257,11 @@ def main() -> None:
             "DEBUG": logging.DEBUG,
             "INFO": logging.INFO,
             "WARNING": logging.WARNING,
-            "ERROR": logging.ERROR
+            "ERROR": logging.ERROR,
         }
         logging.basicConfig(
             level=log_level_map.get(log_level, logging.INFO),
-            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+            format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
         )
 
     # If no allowed paths are specified, use the current directory
@@ -274,7 +271,7 @@ def main() -> None:
     # Run in dev mode if requested
     if dev:
         from hanzo_mcp.dev_server import DevServer
-        
+
         dev_server = DevServer(
             name=name,
             allowed_paths=allowed_paths,
@@ -315,7 +312,7 @@ def main() -> None:
         host=host,
         port=port,
     )
-    
+
     try:
         # Transport will be automatically cast to Literal['stdio', 'sse'] by the server
         server.run(transport=transport)
@@ -378,7 +375,7 @@ def install_claude_desktop_config(
     # Add tool disable flags if specified
     if disable_write_tools:
         args.append("--disable-write-tools")
-    
+
     if disable_search_tools:
         args.append("--disable-search-tools")
 
@@ -419,9 +416,7 @@ def install_claude_desktop_config(
     else:
         logger.info(f"\nDefault allowed path: {home}")
 
-    logger.info(
-        "\nYou can modify allowed paths in the config file directly."
-    )
+    logger.info("\nYou can modify allowed paths in the config file directly.")
     logger.info("Restart Claude Desktop for changes to take effect.")