hanzo-mcp 0.3.8__py3-none-any.whl → 0.5.0__py3-none-any.whl

hanzo_mcp/config/settings.py

@@ -0,0 +1,388 @@
+"""Settings management for Hanzo MCP.
+
+Handles loading and saving configuration from multiple sources:
+1. Default settings
+2. Global config file (~/.config/hanzo/mcp-settings.json)
+3. Project-specific config file
+4. Environment variables
+5. CLI arguments (highest priority)
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+from dataclasses import dataclass, asdict, field
+
+from .tool_config import TOOL_REGISTRY, ToolCategory
+
+
+@dataclass
+class MCPServerConfig:
+    """Configuration for an external MCP server."""
+    name: str
+    command: str
+    args: List[str] = field(default_factory=list)
+    enabled: bool = True
+    trusted: bool = False  # Whether this server is trusted
+    description: str = ""
+    capabilities: List[str] = field(default_factory=list)  # tools, prompts, resources
+    
+    
+@dataclass
+class VectorStoreConfig:
+    """Configuration for the vector store."""
+    enabled: bool = False
+    provider: str = "infinity"  # infinity, chroma, etc.
+    data_path: Optional[str] = None  # Will default to ~/.config/hanzo/vector-store
+    embedding_model: str = "text-embedding-3-small"
+    chunk_size: int = 1000
+    chunk_overlap: int = 200
+
+
+@dataclass  
+class ProjectConfig:
+    """Configuration specific to a project."""
+    name: str
+    root_path: str
+    rules: List[str] = field(default_factory=list)
+    workflows: Dict[str, Any] = field(default_factory=dict)
+    tasks: List[Dict[str, Any]] = field(default_factory=list)
+    enabled_tools: Dict[str, bool] = field(default_factory=dict)
+    disabled_tools: List[str] = field(default_factory=list)
+    mcp_servers: List[str] = field(default_factory=list)  # Names of enabled MCP servers for this project
+
+
+@dataclass
+class AgentConfig:
+    """Configuration for agent tools."""
+    enabled: bool = False
+    model: Optional[str] = None
+    api_key: Optional[str] = None
+    base_url: Optional[str] = None
+    max_tokens: Optional[int] = None
+    max_iterations: int = 10
+    max_tool_uses: int = 30
+
+
+@dataclass 
+class ServerConfig:
+    """Configuration for the MCP server."""
+    name: str = "hanzo-mcp"
+    host: str = "127.0.0.1"
+    port: int = 3000
+    transport: str = "stdio"  # stdio or sse
+    log_level: str = "INFO"
+    command_timeout: float = 120.0
+
+
+@dataclass
+class HanzoMCPSettings:
+    """Complete configuration for Hanzo MCP."""
+    # Server settings
+    server: ServerConfig = field(default_factory=ServerConfig)
+    
+    # Paths and permissions
+    allowed_paths: List[str] = field(default_factory=list)
+    project_paths: List[str] = field(default_factory=list)
+    project_dir: Optional[str] = None
+    
+    # Tool configuration
+    enabled_tools: Dict[str, bool] = field(default_factory=dict)
+    disabled_tools: List[str] = field(default_factory=list)
+    
+    # Agent configuration
+    agent: AgentConfig = field(default_factory=AgentConfig)
+    
+    # Vector store configuration
+    vector_store: VectorStoreConfig = field(default_factory=VectorStoreConfig)
+    
+    # MCP Hub configuration
+    mcp_servers: Dict[str, MCPServerConfig] = field(default_factory=dict)
+    hub_enabled: bool = False
+    trusted_servers: List[str] = field(default_factory=list)  # Whitelist of trusted server names
+    
+    # Project-specific configurations
+    projects: Dict[str, ProjectConfig] = field(default_factory=dict)
+    current_project: Optional[str] = None
+    
+    def __post_init__(self):
+        """Initialize default tool states if not specified."""
+        if not self.enabled_tools:
+            self.enabled_tools = {name: config.enabled for name, config in TOOL_REGISTRY.items()}
+        
+        # Apply disabled_tools list to enabled_tools dict
+        for tool_name in self.disabled_tools:
+            if tool_name in TOOL_REGISTRY:
+                self.enabled_tools[tool_name] = False
+    
+    def is_tool_enabled(self, tool_name: str) -> bool:
+        """Check if a specific tool is enabled."""
+        # Check disabled_tools list first (highest priority)
+        if tool_name in self.disabled_tools:
+            return False
+        return self.enabled_tools.get(tool_name, TOOL_REGISTRY.get(tool_name, type('obj', (object,), {'enabled': False})).enabled)
+    
+    def enable_tool(self, tool_name: str) -> bool:
+        """Enable a specific tool."""
+        if tool_name in TOOL_REGISTRY:
+            self.enabled_tools[tool_name] = True
+            # Remove from disabled list if present
+            if tool_name in self.disabled_tools:
+                self.disabled_tools.remove(tool_name)
+            return True
+        return False
+    
+    def disable_tool(self, tool_name: str) -> bool:
+        """Disable a specific tool."""
+        if tool_name in TOOL_REGISTRY:
+            self.enabled_tools[tool_name] = False
+            # Add to disabled list if not present
+            if tool_name not in self.disabled_tools:
+                self.disabled_tools.append(tool_name)
+            return True
+        return False
+    
+    def get_enabled_tools(self) -> List[str]:
+        """Get list of enabled tool names."""
+        return [name for name in TOOL_REGISTRY.keys() if self.is_tool_enabled(name)]
+    
+    def get_disabled_tools(self) -> List[str]:
+        """Get list of disabled tool names."""
+        return [name for name in TOOL_REGISTRY.keys() if not self.is_tool_enabled(name)]
+    
+    # MCP Server Management
+    def add_mcp_server(self, server_config: MCPServerConfig) -> bool:
+        """Add a new MCP server configuration."""
+        if server_config.name in self.mcp_servers:
+            return False  # Server already exists
+        self.mcp_servers[server_config.name] = server_config
+        return True
+    
+    def remove_mcp_server(self, server_name: str) -> bool:
+        """Remove an MCP server configuration."""
+        if server_name in self.mcp_servers:
+            del self.mcp_servers[server_name]
+            # Remove from trusted list if present
+            if server_name in self.trusted_servers:
+                self.trusted_servers.remove(server_name)
+            return True
+        return False
+    
+    def enable_mcp_server(self, server_name: str) -> bool:
+        """Enable an MCP server."""
+        if server_name in self.mcp_servers:
+            self.mcp_servers[server_name].enabled = True
+            return True
+        return False
+    
+    def disable_mcp_server(self, server_name: str) -> bool:
+        """Disable an MCP server."""
+        if server_name in self.mcp_servers:
+            self.mcp_servers[server_name].enabled = False
+            return True
+        return False
+    
+    def trust_mcp_server(self, server_name: str) -> bool:
+        """Add server to trusted list."""
+        if server_name in self.mcp_servers:
+            if server_name not in self.trusted_servers:
+                self.trusted_servers.append(server_name)
+            self.mcp_servers[server_name].trusted = True
+            return True
+        return False
+    
+    def get_enabled_mcp_servers(self) -> List[MCPServerConfig]:
+        """Get list of enabled MCP servers."""
+        return [server for server in self.mcp_servers.values() if server.enabled]
+    
+    def get_trusted_mcp_servers(self) -> List[MCPServerConfig]:
+        """Get list of trusted MCP servers."""
+        return [server for server in self.mcp_servers.values() if server.trusted]
+    
+    # Project Management
+    def add_project(self, project_config: ProjectConfig) -> bool:
+        """Add a project configuration."""
+        if project_config.name in self.projects:
+            return False  # Project already exists
+        self.projects[project_config.name] = project_config
+        return True
+    
+    def remove_project(self, project_name: str) -> bool:
+        """Remove a project configuration."""
+        if project_name in self.projects:
+            del self.projects[project_name]
+            if self.current_project == project_name:
+                self.current_project = None
+            return True
+        return False
+    
+    def set_current_project(self, project_name: str) -> bool:
+        """Set the current active project."""
+        if project_name in self.projects:
+            self.current_project = project_name
+            return True
+        return False
+    
+    def get_current_project(self) -> Optional[ProjectConfig]:
+        """Get the current project configuration."""
+        if self.current_project:
+            return self.projects.get(self.current_project)
+        return None
+    
+    def get_project_tools(self, project_name: Optional[str] = None) -> Dict[str, bool]:
+        """Get tool configuration for a specific project."""
+        if not project_name:
+            project_name = self.current_project
+        
+        if project_name and project_name in self.projects:
+            project = self.projects[project_name]
+            # Start with global tool settings
+            tools = self.enabled_tools.copy()
+            # Apply project-specific settings
+            tools.update(project.enabled_tools)
+            # Apply project-specific disabled tools
+            for tool_name in project.disabled_tools:
+                tools[tool_name] = False
+            return tools
+        
+        return self.enabled_tools
+
+
+def get_config_dir() -> Path:
+    """Get the configuration directory for Hanzo MCP."""
+    if os.name == "nt":  # Windows
+        config_dir = Path(os.environ.get("APPDATA", "")) / "hanzo"
+    else:  # Unix/macOS
+        config_dir = Path.home() / ".config" / "hanzo"
+    
+    config_dir.mkdir(parents=True, exist_ok=True)
+    return config_dir
+
+
+def get_global_config_path() -> Path:
+    """Get the path to the global configuration file."""
+    return get_config_dir() / "mcp-settings.json"
+
+
+def get_project_config_path(project_dir: Optional[str] = None) -> Optional[Path]:
+    """Get the path to the project-specific configuration file."""
+    if project_dir:
+        project_path = Path(project_dir)
+        config_candidates = [
+            project_path / ".hanzo" / "mcp-settings.json",
+            project_path / "hanzo-mcp.json",
+            project_path / ".hanzo-mcp.json",
+        ]
+        for config_path in config_candidates:
+            if config_path.exists():
+                return config_path
+    return None
+
+
+def load_settings(
+    project_dir: Optional[str] = None,
+    config_overrides: Optional[Dict[str, Any]] = None
+) -> HanzoMCPSettings:
+    """Load settings from all sources in priority order.
+    
+    Priority (highest to lowest):
+    1. config_overrides (usually from CLI)
+    2. Project-specific config file
+    3. Global config file
+    4. Defaults
+    """
+    # Start with defaults
+    settings = HanzoMCPSettings()
+    
+    # Load global config
+    global_config_path = get_global_config_path()
+    if global_config_path.exists():
+        try:
+            with open(global_config_path) as f:
+                global_config = json.load(f)
+                settings = _merge_config(settings, global_config)
+        except Exception as e:
+            print(f"Warning: Failed to load global config: {e}")
+    
+    # Load project config
+    project_config_path = get_project_config_path(project_dir)
+    if project_config_path:
+        try:
+            with open(project_config_path) as f:
+                project_config = json.load(f)
+                settings = _merge_config(settings, project_config)
+        except Exception as e:
+            print(f"Warning: Failed to load project config: {e}")
+    
+    # Apply CLI overrides
+    if config_overrides:
+        settings = _merge_config(settings, config_overrides)
+    
+    return settings
+
+
+def save_settings(settings: HanzoMCPSettings, global_config: bool = True) -> Path:
+    """Save settings to configuration file.
+    
+    Args:
+        settings: Settings to save
+        global_config: If True, save to global config, otherwise save to project config
+    
+    Returns:
+        Path where settings were saved
+    """
+    if global_config:
+        config_path = get_global_config_path()
+    else:
+        # Save to current directory project config
+        config_path = Path.cwd() / ".hanzo-mcp.json"
+    
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    with open(config_path, 'w') as f:
+        json.dump(asdict(settings), f, indent=2)
+    
+    return config_path
+
+
+def _merge_config(base_settings: HanzoMCPSettings, config_dict: Dict[str, Any]) -> HanzoMCPSettings:
+    """Merge configuration dictionary into settings object."""
+    # Convert to dict, merge, then convert back
+    base_dict = asdict(base_settings)
+    
+    def deep_merge(base: Dict[str, Any], update: Dict[str, Any]) -> Dict[str, Any]:
+        """Deep merge two dictionaries."""
+        for key, value in update.items():
+            if key in base and isinstance(base[key], dict) and isinstance(value, dict):
+                base[key] = deep_merge(base[key], value)
+            else:
+                base[key] = value
+        return base
+    
+    merged = deep_merge(base_dict, config_dict)
+    
+    # Reconstruct the settings object
+    mcp_servers = {}
+    for name, server_data in merged.get("mcp_servers", {}).items():
+        mcp_servers[name] = MCPServerConfig(**server_data)
+    
+    projects = {}
+    for name, project_data in merged.get("projects", {}).items():
+        projects[name] = ProjectConfig(**project_data)
+    
+    return HanzoMCPSettings(
+        server=ServerConfig(**merged.get("server", {})),
+        allowed_paths=merged.get("allowed_paths", []),
+        project_paths=merged.get("project_paths", []),
+        project_dir=merged.get("project_dir"),
+        enabled_tools=merged.get("enabled_tools", {}),
+        disabled_tools=merged.get("disabled_tools", []),
+        agent=AgentConfig(**merged.get("agent", {})),
+        vector_store=VectorStoreConfig(**merged.get("vector_store", {})),
+        mcp_servers=mcp_servers,
+        hub_enabled=merged.get("hub_enabled", False),
+        trusted_servers=merged.get("trusted_servers", []),
+        projects=projects,
+        current_project=merged.get("current_project"),
+    )

hanzo_mcp/config/tool_config.py

@@ -0,0 +1,197 @@
+"""Tool configuration definitions for Hanzo MCP."""
+
+from enum import Enum
+from typing import Dict, List, Optional
+from dataclasses import dataclass
+
+
+class ToolCategory(str, Enum):
+    """Categories of tools available in Hanzo MCP."""
+    FILESYSTEM = "filesystem"
+    SHELL = "shell"
+    JUPYTER = "jupyter"
+    TODO = "todo"
+    AGENT = "agent"
+    COMMON = "common"
+    VECTOR = "vector"
+
+
+@dataclass
+class ToolConfig:
+    """Configuration for an individual tool."""
+    name: str
+    category: ToolCategory
+    enabled: bool = True
+    description: str = ""
+    requires_permissions: bool = True
+    cli_flag: str = ""
+    
+    def __post_init__(self):
+        """Generate CLI flag if not provided."""
+        if not self.cli_flag:
+            self.cli_flag = f"--{'enable' if self.enabled else 'disable'}-{self.name.replace('_', '-')}"
+
+
+# Complete tool registry with all 17 tools
+TOOL_REGISTRY: Dict[str, ToolConfig] = {
+    # Filesystem Tools (8)
+    "read": ToolConfig(
+        name="read",
+        category=ToolCategory.FILESYSTEM,
+        description="Read file contents with line numbers and truncation support",
+        cli_flag="--disable-read"
+    ),
+    "write": ToolConfig(
+        name="write", 
+        category=ToolCategory.FILESYSTEM,
+        description="Write content to files, create new files or overwrite existing ones",
+        cli_flag="--disable-write"
+    ),
+    "edit": ToolConfig(
+        name="edit",
+        category=ToolCategory.FILESYSTEM, 
+        description="Make precise string replacements in files with validation",
+        cli_flag="--disable-edit"
+    ),
+    "multi_edit": ToolConfig(
+        name="multi_edit",
+        category=ToolCategory.FILESYSTEM,
+        description="Perform multiple edits to a single file in one operation", 
+        cli_flag="--disable-multi-edit"
+    ),
+    "directory_tree": ToolConfig(
+        name="directory_tree",
+        category=ToolCategory.FILESYSTEM,
+        description="Display directory structure as a tree",
+        cli_flag="--disable-directory-tree"
+    ),
+    "grep": ToolConfig(
+        name="grep",
+        category=ToolCategory.FILESYSTEM,
+        description="Fast content search using ripgrep or fallback Python implementation",
+        cli_flag="--disable-grep"
+    ),
+    "grep_ast": ToolConfig(
+        name="grep_ast", 
+        category=ToolCategory.FILESYSTEM,
+        description="Search source code with AST context using tree-sitter",
+        cli_flag="--disable-grep-ast"
+    ),
+    "content_replace": ToolConfig(
+        name="content_replace",
+        category=ToolCategory.FILESYSTEM,
+        description="Bulk text replacement across multiple files",
+        cli_flag="--disable-content-replace"
+    ),
+    
+    # Shell Tools (1)
+    "run_command": ToolConfig(
+        name="run_command",
+        category=ToolCategory.SHELL,
+        description="Execute shell commands with session support",
+        cli_flag="--disable-run-command"
+    ),
+    
+    # Jupyter Tools (2)
+    "notebook_read": ToolConfig(
+        name="notebook_read",
+        category=ToolCategory.JUPYTER,
+        description="Read Jupyter notebook files (.ipynb)",
+        cli_flag="--disable-notebook-read"
+    ),
+    "notebook_edit": ToolConfig(
+        name="notebook_edit",
+        category=ToolCategory.JUPYTER,
+        description="Edit Jupyter notebook cells (replace, insert, delete)",
+        cli_flag="--disable-notebook-edit"
+    ),
+    
+    # Todo Tools (2)
+    "todo_read": ToolConfig(
+        name="todo_read",
+        category=ToolCategory.TODO,
+        description="Read the current todo list for a session",
+        cli_flag="--disable-todo-read"
+    ),
+    "todo_write": ToolConfig(
+        name="todo_write", 
+        category=ToolCategory.TODO,
+        description="Create and manage structured task lists",
+        cli_flag="--disable-todo-write"
+    ),
+    
+    # Agent Tools (1)
+    "dispatch_agent": ToolConfig(
+        name="dispatch_agent",
+        category=ToolCategory.AGENT,
+        enabled=False,  # Disabled by default
+        description="Delegate tasks to sub-agents for concurrent/specialized processing",
+        cli_flag="--enable-dispatch-agent"
+    ),
+    
+    # Common Tools (3)
+    "think": ToolConfig(
+        name="think",
+        category=ToolCategory.COMMON,
+        description="Provide structured thinking space for complex reasoning",
+        cli_flag="--disable-think"
+    ),
+    "batch": ToolConfig(
+        name="batch",
+        category=ToolCategory.COMMON,
+        description="Execute multiple tools in parallel or serial",
+        cli_flag="--disable-batch"
+    ),
+    
+    # Vector Tools (2)
+    "vector_index": ToolConfig(
+        name="vector_index",
+        category=ToolCategory.VECTOR,
+        enabled=False,  # Disabled by default
+        description="Index documents in local vector database for semantic search",
+        cli_flag="--enable-vector-index"
+    ),
+    "vector_search": ToolConfig(
+        name="vector_search",
+        category=ToolCategory.VECTOR,
+        enabled=False,  # Disabled by default
+        description="Search documents using semantic similarity in vector database",
+        cli_flag="--enable-vector-search"
+    ),
+}
+
+
+def get_tools_by_category(category: ToolCategory) -> List[ToolConfig]:
+    """Get all tools in a specific category."""
+    return [tool for tool in TOOL_REGISTRY.values() if tool.category == category]
+
+
+def get_enabled_tools() -> List[ToolConfig]:
+    """Get all enabled tools."""
+    return [tool for tool in TOOL_REGISTRY.values() if tool.enabled]
+
+
+def get_disabled_tools() -> List[ToolConfig]:
+    """Get all disabled tools."""
+    return [tool for tool in TOOL_REGISTRY.values() if not tool.enabled]
+
+
+def enable_tool(tool_name: str) -> bool:
+    """Enable a specific tool. Returns True if successful."""
+    if tool_name in TOOL_REGISTRY:
+        TOOL_REGISTRY[tool_name].enabled = True
+        return True
+    return False
+
+
+def disable_tool(tool_name: str) -> bool:
+    """Disable a specific tool. Returns True if successful."""
+    if tool_name in TOOL_REGISTRY:
+        TOOL_REGISTRY[tool_name].enabled = False
+        return True
+    return False
+
+
+def is_tool_enabled(tool_name: str) -> bool:
+    """Check if a tool is enabled."""
+    return TOOL_REGISTRY.get(tool_name, ToolConfig("", ToolCategory.COMMON, False)).enabled

hanzo_mcp/prompts/__init__.py

@@ -0,0 +1,117 @@
+import os
+
+from fastmcp import FastMCP
+
+from hanzo_mcp.prompts.compact_conversation import COMPACT_CONVERSATION_PROMPT
+from hanzo_mcp.prompts.create_release import CREATE_RELEASE_PROMPT
+from hanzo_mcp.prompts.project_system import PROJECT_SYSTEM_PROMPT
+from hanzo_mcp.prompts.project_todo_reminder import (
+    PROJECT_TODO_EMPTY_REMINDER,
+    get_project_todo_reminder,
+)
+from hanzo_mcp.prompts.utils import (
+    get_directory_structure,
+    get_git_info,
+    get_os_info,
+)
+
+CONTINUE_FROM_LAST_SESSION_PROMPT = """<system-reminder>
+This is a reminder that your todo list is currently empty. DO NOT mention this to the user explicitly because they are already aware. If you are working on tasks that would benefit from a todo list please use the TodoWrite tool to create one. If not, please feel free to ignore. Again do not mention this message to the user.
+</system-reminder>
+"""
+
+
+def create_project_system_prompt(project_path: str):
+    """Factory function to create a project system prompt function."""
+
+    def project_system_prompt() -> str:
+        """
+        Summarize the conversation so far for a specific project.
+        """
+        working_directory = project_path
+        is_git_repo = os.path.isdir(os.path.join(working_directory, ".git"))
+        platform, _, os_version = get_os_info()
+
+        # Get directory structure
+        directory_structure = get_directory_structure(
+            working_directory, max_depth=3, include_filtered=False
+        )
+
+        # Get git information
+        git_info = get_git_info(working_directory)
+        current_branch = git_info.get("current_branch", "")
+        main_branch = git_info.get("main_branch", "")
+        git_status = git_info.get("git_status", "")
+        recent_commits = git_info.get("recent_commits", "")
+
+        return PROJECT_SYSTEM_PROMPT.format(
+            working_directory=working_directory,
+            is_git_repo=is_git_repo,
+            platform=platform,
+            os_version=os_version,
+            directory_structure=directory_structure,
+            current_branch=current_branch,
+            main_branch=main_branch,
+            git_status=git_status,
+            recent_commits=recent_commits,
+        )
+
+    return project_system_prompt
+
+
+def register_all_prompts(
+    mcp_server: FastMCP, projects: list[str] | None = None
+) -> None:
+    @mcp_server.prompt(name="Compact current conversation")
+    def compact() -> str:
+        """
+        Summarize the conversation so far.
+        """
+        return COMPACT_CONVERSATION_PROMPT
+
+    @mcp_server.prompt(name="Create a new release")
+    def create_release() -> str:
+        """
+        Create a new release for my project.
+        """
+        return CREATE_RELEASE_PROMPT
+
+    @mcp_server.prompt(name="Continue todo by session id")
+    def continue_todo_by_session_id(session_id: str) -> str:
+        """
+        Continue from the last todo list for the current session.
+        """
+        return get_project_todo_reminder(session_id)
+
+    @mcp_server.prompt(name="Continue latest todo")
+    def continue_latest_todo() -> str:
+        """
+        Continue from the last todo list for the current session.
+        """
+        return get_project_todo_reminder()
+
+    @mcp_server.prompt(name="System prompt")
+    def manual_project_system_prompt(project_path: str) -> str:
+        """
+        Detailed system prompt include env,git etc information about the specified project.
+        """
+        return create_project_system_prompt(project_path)()
+
+    if projects is None:
+        return
+
+    for project in projects:
+        # Register the prompt with the factory function
+        mcp_server.prompt(
+            name=f"System prompt for {os.path.basename(project)}",
+            description=f"Detailed system prompt include env,git etc information about {project}",
+        )(create_project_system_prompt(project))
+
+    return
+
+
+__all__ = [
+    "register_all_prompts",
+    "get_project_todo_reminder",
+    "PROJECT_TODO_EMPTY_REMINDER",
+]