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

hanzo_mcp/tools/common/mode.py

@@ -0,0 +1,116 @@
+"""Mode system for organizing development tools based on programmer personalities."""
+
+import os
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Set
+
+from hanzo_mcp.tools.common.personality import (
+    ToolPersonality,
+    register_default_personalities,
+    ensure_agent_enabled,
+    personalities
+)
+
+
+@dataclass
+class Mode(ToolPersonality):
+    """Development mode combining tool preferences and environment settings."""
+    # Inherits all fields from ToolPersonality
+    # Adds mode-specific functionality
+    
+    @property
+    def is_active(self) -> bool:
+        """Check if this mode is currently active."""
+        return ModeRegistry.get_active() == self
+
+
+class ModeRegistry:
+    """Registry for development modes."""
+    
+    _modes: Dict[str, Mode] = {}
+    _active_mode: Optional[str] = None
+    
+    @classmethod
+    def register(cls, mode: Mode) -> None:
+        """Register a development mode."""
+        # Ensure agent is enabled if API keys present
+        mode = ensure_agent_enabled(mode)
+        cls._modes[mode.name] = mode
+    
+    @classmethod
+    def get(cls, name: str) -> Optional[Mode]:
+        """Get a mode by name."""
+        return cls._modes.get(name)
+    
+    @classmethod
+    def list(cls) -> List[Mode]:
+        """List all registered modes."""
+        return list(cls._modes.values())
+    
+    @classmethod
+    def set_active(cls, name: str) -> None:
+        """Set the active mode."""
+        if name not in cls._modes:
+            raise ValueError(f"Mode '{name}' not found")
+        cls._active_mode = name
+        
+        # Apply environment variables from the mode
+        mode = cls._modes[name]
+        if mode.environment:
+            for key, value in mode.environment.items():
+                os.environ[key] = value
+    
+    @classmethod
+    def get_active(cls) -> Optional[Mode]:
+        """Get the active mode."""
+        if cls._active_mode:
+            return cls._modes.get(cls._active_mode)
+        return None
+    
+    @classmethod
+    def get_active_tools(cls) -> Set[str]:
+        """Get the set of tools from the active mode."""
+        mode = cls.get_active()
+        if mode:
+            return set(mode.tools)
+        return set()
+
+
+def register_default_modes():
+    """Register all default development modes."""
+    # Convert personalities to modes
+    for personality in personalities:
+        mode = Mode(
+            name=personality.name,
+            programmer=personality.programmer,
+            description=personality.description,
+            tools=personality.tools,
+            environment=personality.environment,
+            philosophy=personality.philosophy,
+        )
+        ModeRegistry.register(mode)
+
+
+def get_mode_from_env() -> Optional[str]:
+    """Get mode name from environment variables."""
+    # Check for HANZO_MODE, PERSONALITY, or MODE env vars
+    return (
+        os.environ.get("HANZO_MODE") or
+        os.environ.get("PERSONALITY") or
+        os.environ.get("MODE")
+    )
+
+
+def activate_mode_from_env():
+    """Activate mode based on environment variables."""
+    mode_name = get_mode_from_env()
+    if mode_name:
+        try:
+            ModeRegistry.set_active(mode_name)
+            return True
+        except ValueError:
+            # Mode not found, ignore
+            pass
+    return False
+
+

hanzo_mcp/tools/common/mode_loader.py

@@ -0,0 +1,105 @@
+"""Tool mode loader for dynamic tool configuration."""
+
+import os
+from typing import Dict, List, Optional, Set
+
+from hanzo_mcp.tools.common.mode import ModeRegistry, register_default_modes, activate_mode_from_env
+
+
+class ModeLoader:
+    """Loads and manages tool modes for dynamic configuration."""
+    
+    @staticmethod
+    def initialize_modes() -> None:
+        """Initialize the mode system with defaults."""
+        # Initialize modes
+        register_default_modes()
+        
+        # Check for mode from environment
+        activate_mode_from_env()
+        
+        # If no mode set, use default
+        if not ModeRegistry.get_active():
+            default_mode = os.environ.get("HANZO_DEFAULT_MODE", "hanzo")
+            if ModeRegistry.get(default_mode):
+                ModeRegistry.set_active(default_mode)
+    
+    @staticmethod
+    def get_enabled_tools_from_mode(
+        base_enabled_tools: Optional[Dict[str, bool]] = None,
+        force_mode: Optional[str] = None
+    ) -> Dict[str, bool]:
+        """Get enabled tools configuration from active mode.
+        
+        Args:
+            base_enabled_tools: Base configuration to merge with
+            force_mode: Force a specific mode (overrides active)
+            
+        Returns:
+            Dictionary of tool enable states
+        """
+        # Initialize if needed
+        if not ModeRegistry.list():
+            ModeLoader.initialize_modes()
+        
+        # Get mode to use
+        tools_list = None
+        
+        if force_mode:
+            # Set and get mode
+            if ModeRegistry.get(force_mode):
+                ModeRegistry.set_active(force_mode)
+                mode = ModeRegistry.get_active()
+                tools_list = mode.tools if mode else None
+        else:
+            # Check active mode
+            mode = ModeRegistry.get_active()
+            if mode:
+                tools_list = mode.tools
+        
+        if not tools_list:
+            # No active mode, return base config
+            return base_enabled_tools or {}
+        
+        # Start with base configuration
+        result = base_enabled_tools.copy() if base_enabled_tools else {}
+        
+        # Get all possible tools from registry
+        from hanzo_mcp.config.tool_config import TOOL_REGISTRY
+        all_possible_tools = set(TOOL_REGISTRY.keys())
+        
+        # Disable all tools first (clean slate for mode)
+        for tool in all_possible_tools:
+            result[tool] = False
+        
+        # Enable tools from mode
+        for tool in tools_list:
+            result[tool] = True
+        
+        # Always enable mode tool (meta)
+        result["mode"] = True
+        
+        return result
+    
+    @staticmethod
+    def get_environment_from_mode() -> Dict[str, str]:
+        """Get environment variables from active mode.
+        
+        Returns:
+            Dictionary of environment variables
+        """
+        # Check mode
+        mode = ModeRegistry.get_active()
+        if mode and mode.environment:
+            return mode.environment.copy()
+        
+        return {}
+    
+    @staticmethod
+    def apply_environment_from_mode() -> None:
+        """Apply environment variables from active mode."""
+        env_vars = ModeLoader.get_environment_from_mode()
+        for key, value in env_vars.items():
+            os.environ[key] = value
+
+

hanzo_mcp/tools/common/permissions.py

@@ -1,4 +1,4 @@
-"""Permission system for the Hanzo MCP server."""
+"""Permission system for the Hanzo AI server."""
 
 import json
 import os