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

hanzo_mcp/analytics/__init__.py

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

hanzo_mcp/analytics/posthog_analytics.py

@@ -0,0 +1,364 @@
+"""PostHog analytics integration for Hanzo MCP.
+
+This module provides analytics tracking for:
+- Tool usage and performance
+- Error tracking and debugging
+- Feature adoption and user behavior
+- A/B testing and feature flags
+"""
+
+import os
+import time
+import functools
+import traceback
+from typing import Dict, Any, Optional, Callable, TypeVar
+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])
+
+
+@dataclass
+class AnalyticsConfig:
+    """Configuration for analytics."""
+    api_key: Optional[str] = None
+    host: str = "https://us.i.posthog.com"
+    enabled: bool = True
+    debug: bool = False
+    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
+            )
+    
+    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 = {
+                "timestamp": datetime.utcnow().isoformat(),
+                "platform": platform.system(),
+                "python_version": platform.python_version(),
+                "mcp_version": "0.6.13",  # TODO: Get from package
+                **(properties or {})
+            }
+            
+            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 {}
+            )
+        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:
+        """Track tool usage event."""
+        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:
+        """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 {})
+        }
+        
+        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
+            )
+        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
+            )
+        except Exception:
+            return default
+    
+    def flush(self) -> None:
+        """Flush any pending events."""
+        if self.is_enabled():
+            try:
+                self._client.flush()
+            except Exception:
+                pass
+    
+    def shutdown(self) -> None:
+        """Shutdown analytics client."""
+        if self.is_enabled():
+            try:
+                self._client.shutdown()
+            except Exception:
+                pass
+
+
+# Global analytics instance
+_analytics = None
+
+
+def get_analytics() -> Analytics:
+    """Get or create the global analytics instance."""
+    global _analytics
+    if _analytics is None:
+        _analytics = Analytics()
+    return _analytics
+
+
+def track_event(event: str, properties: Optional[Dict[str, Any]] = None) -> None:
+    """Track a custom event."""
+    get_analytics().capture(event, properties)
+
+
+def track_tool_usage(tool_name: str, **kwargs) -> None:
+    """Track tool usage."""
+    get_analytics().track_tool_usage(tool_name, **kwargs)
+
+
+def track_error(error: Exception, context: Optional[Dict[str, Any]] = None) -> None:
+    """Track an error."""
+    get_analytics().track_error(error, context)
+
+
+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):
+            start_time = time.time()
+            error = None
+            try:
+                result = await func(*args, **kwargs)
+                return result
+            except Exception as e:
+                error = e
+                track_error(e, {"tool": tool_name})
+                raise
+            finally:
+                duration_ms = (time.time() - start_time) * 1000
+                track_tool_usage(
+                    tool_name,
+                    duration_ms=duration_ms,
+                    success=error is None,
+                    error=str(error) if error else None
+                )
+        
+        @functools.wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            start_time = time.time()
+            error = None
+            try:
+                result = func(*args, **kwargs)
+                return result
+            except Exception as e:
+                error = e
+                track_error(e, {"tool": tool_name})
+                raise
+            finally:
+                duration_ms = (time.time() - start_time) * 1000
+                track_tool_usage(
+                    tool_name,
+                    duration_ms=duration_ms,
+                    success=error is 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):
+            if get_analytics().feature_enabled(flag_key, default):
+                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
+        )
+        
+        # Don't suppress exceptions
+        return False
+
+
+# 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
+        )
+        
+        # Don't suppress exceptions
+        return False

hanzo_mcp/cli.py

@@ -157,8 +157,8 @@ def main() -> None:
         "--port",
         dest="port",
         type=int,
-        default=3000,
-        help="Port for SSE server (default: 3000)",
+        default=8888,
+        help="Port for SSE server (default: 8888)",
     )
 
     _ = parser.add_argument(
@@ -324,7 +324,7 @@ def install_claude_desktop_config(
     disable_write_tools: bool = False,
     disable_search_tools: bool = False,
     host: str = "127.0.0.1",
-    port: int = 3000,
+    port: int = 8888,
 ) -> None:
     """Install the server configuration in Claude Desktop.
 

hanzo_mcp/cli_enhanced.py

@@ -59,8 +59,8 @@ Examples:
     server_group.add_argument(
         "--port",
         type=int,
-        default=3000,
-        help="Port for SSE server (default: 3000)",
+        default=8888,
+        help="Port for SSE server (default: 8888)",
     )
     server_group.add_argument(
         "--log-level",
@@ -242,7 +242,7 @@ def apply_cli_overrides(args: argparse.Namespace) -> Dict[str, Any]:
         server_config["name"] = args.name
     if hasattr(args, 'host') and args.host != "127.0.0.1":
         server_config["host"] = args.host
-    if hasattr(args, 'port') and args.port != 3000:
+    if hasattr(args, 'port') and args.port != 8888:
         server_config["port"] = args.port
     if hasattr(args, 'transport') and args.transport != "stdio":
         server_config["transport"] = args.transport

hanzo_mcp/config/settings.py

@@ -71,7 +71,7 @@ class ServerConfig:
     """Configuration for the MCP server."""
     name: str = "hanzo-mcp"
     host: str = "127.0.0.1"
-    port: int = 3000
+    port: int = 8888
     transport: str = "stdio"  # stdio or sse
     log_level: str = "INFO"
     command_timeout: float = 120.0

hanzo_mcp/config/tool_config.py

@@ -71,11 +71,11 @@ TOOL_REGISTRY: Dict[str, ToolConfig] = {
         description="Fast content search using ripgrep or fallback Python implementation",
         cli_flag="--disable-grep"
     ),
-    "grep_ast": ToolConfig(
-        name="grep_ast", 
+    "ast": ToolConfig(
+        name="ast", 
         category=ToolCategory.FILESYSTEM,
         description="Search source code with AST context using tree-sitter",
-        cli_flag="--disable-grep-ast"
+        cli_flag="--disable-ast"
     ),
     "content_replace": ToolConfig(
         name="content_replace",
@@ -120,7 +120,7 @@ TOOL_REGISTRY: Dict[str, ToolConfig] = {
         cli_flag="--disable-todo-write"
     ),
     
-    # Agent Tools (1)
+    # Agent Tools (3)
     "dispatch_agent": ToolConfig(
         name="dispatch_agent",
         category=ToolCategory.AGENT,
@@ -128,6 +128,20 @@ TOOL_REGISTRY: Dict[str, ToolConfig] = {
         description="Delegate tasks to sub-agents for concurrent/specialized processing",
         cli_flag="--enable-dispatch-agent"
     ),
+    "swarm": ToolConfig(
+        name="swarm",
+        category=ToolCategory.AGENT,
+        enabled=False,  # Disabled by default
+        description="Execute multiple agent tasks in parallel across different files",
+        cli_flag="--enable-swarm"
+    ),
+    "hierarchical_swarm": ToolConfig(
+        name="hierarchical_swarm",
+        category=ToolCategory.AGENT,
+        enabled=False,  # Disabled by default
+        description="Execute hierarchical agent swarms with Claude Code integration",
+        cli_flag="--enable-hierarchical-swarm"
+    ),
     
     # Common Tools (3)
     "think": ToolConfig(

hanzo_mcp/server.py

@@ -48,7 +48,7 @@ class HanzoMCPServer:
         disable_write_tools: bool = False,
         disable_search_tools: bool = False,
         host: str = "127.0.0.1",
-        port: int = 3000,
+        port: int = 8888,
         enabled_tools: dict[str, bool] | None = None,
         disabled_tools: list[str] | None = None,
     ):
@@ -226,3 +226,36 @@ class HanzoMCPServer:
         # Run the server
         transport_type = cast(Literal["stdio", "sse"], transport)
         self.mcp.run(transport=transport_type)
+
+
+def create_server(
+    name: str = "hanzo-mcp",
+    allowed_paths: list[str] | None = None,
+    enable_all_tools: bool = False,
+    **kwargs
+) -> HanzoMCPServer:
+    """Create a Hanzo MCP server instance.
+    
+    Args:
+        name: Server name
+        allowed_paths: List of allowed file paths
+        enable_all_tools: Enable all tools including agent tools
+        **kwargs: Additional server configuration
+        
+    Returns:
+        HanzoMCPServer instance
+    """
+    if enable_all_tools:
+        kwargs['enable_agent_tool'] = True
+        
+    return HanzoMCPServer(
+        name=name,
+        allowed_paths=allowed_paths,
+        **kwargs
+    )
+
+
+def main():
+    """Main entry point for the server."""
+    from hanzo_mcp.cli import main as cli_main
+    cli_main()

hanzo_mcp/tools/__init__.py

@@ -25,6 +25,14 @@ from hanzo_mcp.tools.shell import register_shell_tools
 from hanzo_mcp.tools.todo import register_todo_tools
 from hanzo_mcp.tools.vector import register_vector_tools
 from hanzo_mcp.tools.database import register_database_tools, DatabaseManager
+
+# Try to import memory tools, but don't fail if hanzo-memory is not installed
+try:
+    from hanzo_mcp.tools.memory import register_memory_tools
+    MEMORY_TOOLS_AVAILABLE = True
+except ImportError:
+    MEMORY_TOOLS_AVAILABLE = False
+    register_memory_tools = None
 from hanzo_mcp.tools.mcp import MCPTool, McpAddTool, McpRemoveTool, McpStatsTool
 from hanzo_mcp.tools.editor import NeovimEditTool, NeovimCommandTool, NeovimSessionTool
 from hanzo_mcp.tools.llm import LLMTool, LLMTool, ConsensusTool, LLMManageTool, create_provider_tools
@@ -33,6 +41,13 @@ from hanzo_mcp.tools.common.mode_loader import ModeLoader
 from hanzo_mcp.tools.common.mode import activate_mode_from_env
 from hanzo_mcp.tools.common.plugin_loader import load_user_plugins
 
+# Try to import LSP tool
+try:
+    from hanzo_mcp.tools.lsp import LSPTool, create_lsp_tool
+    LSP_TOOL_AVAILABLE = True
+except ImportError:
+    LSP_TOOL_AVAILABLE = False
+
 
 def register_all_tools(
     mcp_server: FastMCP,
@@ -122,6 +137,8 @@ def register_all_tools(
         "find_files": is_tool_enabled("find_files", True),
         "rules": is_tool_enabled("rules", True),
         "search": is_tool_enabled("search", not disable_search_tools),
+        "unified_search": is_tool_enabled("unified_search", True),  # Primary search tool
+        "find": is_tool_enabled("find", True),  # Fast file finder
     }
     
     # Vector tools setup (needed for search)
@@ -175,7 +192,9 @@ def register_all_tools(
 
     # Register agent tools if enabled
     agent_enabled = enable_agent_tool or is_tool_enabled("agent", False) or is_tool_enabled("dispatch_agent", False)
-    if agent_enabled:
+    swarm_enabled = is_tool_enabled("swarm", False)
+    
+    if agent_enabled or swarm_enabled:
         agent_tools = register_agent_tools(
             mcp_server,
             permission_manager,
@@ -186,8 +205,15 @@ def register_all_tools(
             agent_max_iterations=agent_max_iterations,
             agent_max_tool_uses=agent_max_tool_uses,
         )
+        # Filter based on what's enabled
         for tool in agent_tools:
-            all_tools[tool.name] = tool
+            if tool.name == "agent" and agent_enabled:
+                all_tools[tool.name] = tool
+            elif tool.name == "swarm" and swarm_enabled:
+                all_tools[tool.name] = tool
+            elif tool.name in ["claude", "codex", "gemini", "grok", "code_auth"]:
+                # CLI tools and auth are always included when agent tools are enabled
+                all_tools[tool.name] = tool
 
     # Register todo tools if enabled
     todo_enabled = {
@@ -375,6 +401,43 @@ def register_all_tools(
                 tool.register(mcp_server)
                 all_tools[tool.name] = tool
     
+    # Register memory tools if enabled
+    memory_enabled = {
+        "recall_memories": is_tool_enabled("recall_memories", True),
+        "create_memories": is_tool_enabled("create_memories", True),
+        "update_memories": is_tool_enabled("update_memories", True),
+        "delete_memories": is_tool_enabled("delete_memories", True),
+        "manage_memories": is_tool_enabled("manage_memories", True),
+        "recall_facts": is_tool_enabled("recall_facts", True),
+        "store_facts": is_tool_enabled("store_facts", True),
+        "summarize_to_memory": is_tool_enabled("summarize_to_memory", True),
+        "manage_knowledge_bases": is_tool_enabled("manage_knowledge_bases", True),
+    }
+    
+    if any(memory_enabled.values()) and MEMORY_TOOLS_AVAILABLE:
+        try:
+            memory_tools = register_memory_tools(
+                mcp_server,
+                permission_manager,
+                user_id="default",
+                project_id="default"
+            )
+            # Filter based on enabled state
+            for tool in memory_tools:
+                if memory_enabled.get(tool.name, True):
+                    all_tools[tool.name] = tool
+        except Exception as e:
+            logger.warning(f"Failed to register memory tools: {e}")
+    
+    # Register LSP tool if enabled
+    if is_tool_enabled("lsp", True) and LSP_TOOL_AVAILABLE:
+        try:
+            tool = create_lsp_tool()
+            tool.register(mcp_server)
+            all_tools[tool.name] = tool
+        except Exception as e:
+            logger.warning(f"Failed to register LSP tool: {e}")
+    
     # Register user plugins last (so they can override built-in tools)
     for plugin_name, plugin in plugins.items():
         if is_tool_enabled(plugin_name, True):