hanzo-mcp 0.5.2__py3-none-any.whl → 0.6.1__py3-none-any.whl

hanzo_mcp/tools/common/palette.py

@@ -0,0 +1,344 @@
+"""Tool palette system for organizing development tools."""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Set
+
+from hanzo_mcp.tools.common.base import BaseTool
+
+
+@dataclass
+class ToolPalette:
+    """A collection of tools for a specific development environment."""
+    
+    name: str
+    description: str
+    author: Optional[str] = None
+    tools: List[str] = field(default_factory=list)
+    dependencies: List[str] = field(default_factory=list)
+    environment: Dict[str, str] = field(default_factory=dict)
+    
+    def __post_init__(self):
+        """Validate palette configuration."""
+        if not self.name:
+            raise ValueError("Palette name is required")
+        if not self.tools:
+            raise ValueError("Palette must include at least one tool")
+
+
+class PaletteRegistry:
+    """Registry for tool palettes."""
+    
+    _palettes: Dict[str, ToolPalette] = {}
+    _active_palette: Optional[str] = None
+    
+    @classmethod
+    def register(cls, palette: ToolPalette) -> None:
+        """Register a tool palette."""
+        cls._palettes[palette.name] = palette
+    
+    @classmethod
+    def get(cls, name: str) -> Optional[ToolPalette]:
+        """Get a palette by name."""
+        return cls._palettes.get(name)
+    
+    @classmethod
+    def list(cls) -> List[ToolPalette]:
+        """List all registered palettes."""
+        return list(cls._palettes.values())
+    
+    @classmethod
+    def set_active(cls, name: str) -> None:
+        """Set the active palette."""
+        if name not in cls._palettes:
+            raise ValueError(f"Palette '{name}' not found")
+        cls._active_palette = name
+    
+    @classmethod
+    def get_active(cls) -> Optional[ToolPalette]:
+        """Get the active palette."""
+        if cls._active_palette:
+            return cls._palettes.get(cls._active_palette)
+        return None
+    
+    @classmethod
+    def get_active_tools(cls) -> Set[str]:
+        """Get the set of tools from the active palette."""
+        palette = cls.get_active()
+        if palette:
+            return set(palette.tools)
+        return set()
+
+
+# Pre-defined palettes for famous programmers and ecosystems
+
+# Python palette - Guido van Rossum style
+python_palette = ToolPalette(
+    name="python",
+    description="Python development tools following Guido's philosophy",
+    author="Guido van Rossum",
+    tools=[
+        # Core tools
+        "bash", "read", "write", "edit", "grep", "tree", "find",
+        # Python specific
+        "uvx", "process",
+        # Python tooling commands via uvx
+        "ruff",      # Linting and formatting
+        "black",     # Code formatting
+        "mypy",      # Type checking
+        "pytest",    # Testing
+        "poetry",    # Dependency management
+        "pip-tools", # Requirements management
+        "jupyter",   # Interactive notebooks
+        "sphinx",    # Documentation
+    ],
+    environment={
+        "PYTHONDONTWRITEBYTECODE": "1",
+        "PYTHONUNBUFFERED": "1",
+    }
+)
+
+# Ruby palette - Yukihiro Matsumoto (Matz) style
+ruby_palette = ToolPalette(
+    name="ruby",
+    description="Ruby development tools for programmer happiness by Yukihiro Matsumoto",
+    author="Yukihiro Matsumoto",
+    tools=[
+        # Core tools
+        "bash", "read", "write", "edit", "grep", "tree", "find",
+        # Ruby specific
+        "process",
+        # Ruby tooling - optimized for happiness
+        "ruby",          # Ruby interpreter
+        "gem",           # Package manager
+        "bundler",       # Dependency management
+        "rake",          # Task automation
+        "irb",           # Interactive Ruby
+        "pry",           # Enhanced REPL and debugging
+        "rubocop",       # Style guide enforcement
+        "rspec",         # Behavior-driven testing
+        "minitest",      # Lightweight testing
+        "yard",          # Documentation generator
+        "rails",         # Web application framework
+        "sinatra",       # Lightweight web framework
+        "sidekiq",       # Background processing
+        "capistrano",    # Deployment automation
+    ],
+    environment={
+        "RUBYOPT": "-W:deprecated",
+        "BUNDLE_JOBS": "4",
+        "BUNDLE_RETRY": "3",
+    }
+)
+
+# JavaScript/Node palette - Brendan Eich / Ryan Dahl style
+javascript_palette = ToolPalette(
+    name="javascript",
+    description="JavaScript/Node.js development tools by Brendan Eich / Ryan Dahl",
+    author="Brendan Eich / Ryan Dahl",
+    tools=[
+        # Core tools
+        "bash", "read", "write", "edit", "grep", "tree", "find",
+        # JavaScript specific
+        "npx", "process",
+        # Package managers
+        "npm", "yarn", "pnpm", "bun",
+        # Core tooling via npx
+        "node",              # Node.js runtime
+        "prettier",          # Code formatting
+        "eslint",            # Linting and static analysis
+        "typescript",        # TypeScript compiler
+        "jest",              # Testing framework
+        "vitest",            # Fast testing with Vite
+        "playwright",        # End-to-end testing
+        # Build tools
+        "webpack",           # Module bundler
+        "vite",              # Fast dev server and bundler
+        "rollup",            # Module bundler
+        "esbuild",           # Fast bundler
+        # Frameworks and scaffolding
+        "create-react-app",  # React scaffolding
+        "create-next-app",   # Next.js scaffolding
+        "nuxt",              # Vue.js framework
+        "svelte",            # Component framework
+    ],
+    environment={
+        "NODE_ENV": "development",
+        "NPM_CONFIG_PROGRESS": "false",
+        "FORCE_COLOR": "1",
+    }
+)
+
+# Go palette - Rob Pike / Ken Thompson style
+go_palette = ToolPalette(
+    name="go",
+    description="Go development tools emphasizing simplicity by Rob Pike / Ken Thompson",
+    author="Rob Pike / Ken Thompson",
+    tools=[
+        # Core tools
+        "bash", "read", "write", "edit", "grep", "tree", "find",
+        # Go specific
+        "process",
+        # Go tooling - emphasizing simplicity
+        "go",            # Compiler and standard tools (go build, go test, go mod)
+        "gofmt",         # Code formatting
+        "goimports",     # Import management
+        "golangci-lint", # Modern linting (replaces golint)
+        "godoc",         # Documentation
+        "delve",         # Debugger (dlv)
+        "go-outline",    # Code outline
+        "guru",          # Code analysis
+        "goreleaser",    # Release automation
+    ],
+    environment={
+        "GO111MODULE": "on",
+        "GOPROXY": "https://proxy.golang.org,direct",
+        "GOSUMDB": "sum.golang.org",
+        "CGO_ENABLED": "0",  # Rob Pike prefers pure Go when possible
+    }
+)
+
+# Rust palette - Graydon Hoare style  
+rust_palette = ToolPalette(
+    name="rust",
+    description="Rust development tools for systems programming by Graydon Hoare",
+    author="Graydon Hoare",
+    tools=[
+        # Core tools
+        "bash", "read", "write", "edit", "grep", "tree", "find",
+        # Rust specific
+        "process",
+        # Rust tooling - all via cargo/rustup
+        "cargo",         # Build system and package manager
+        "rustfmt",       # Code formatting (cargo fmt)
+        "clippy",        # Linting (cargo clippy)
+        "rustdoc",       # Documentation (cargo doc)
+        "rust-analyzer", # Language server
+        "miri",          # Interpreter for unsafe code checking
+        "rustup",        # Rust toolchain manager
+        "sccache",       # Shared compilation cache
+        "wasm-pack",     # WebAssembly workflow
+    ],
+    environment={
+        "RUST_BACKTRACE": "1",
+        "RUSTFLAGS": "-D warnings",
+        "CARGO_INCREMENTAL": "1",
+    }
+)
+
+# DevOps palette - Infrastructure and operations
+devops_palette = ToolPalette(
+    name="devops",
+    description="DevOps and infrastructure tools",
+    tools=[
+        # Core tools
+        "bash", "read", "write", "edit", "grep", "tree", "find",
+        "process", "open",
+        # DevOps tooling
+        "docker",        # Containerization
+        "kubectl",       # Kubernetes
+        "terraform",     # Infrastructure as code
+        "ansible",       # Configuration management
+        "helm",          # Kubernetes package manager
+        "prometheus",    # Monitoring
+        "grafana",       # Visualization
+    ],
+    environment={
+        "DOCKER_BUILDKIT": "1",
+    }
+)
+
+# Full stack palette - Everything enabled
+fullstack_palette = ToolPalette(
+    name="fullstack",
+    description="All development tools enabled",
+    tools=[
+        # All filesystem tools
+        "read", "write", "edit", "multi_edit", "grep", "tree", "find",
+        "symbols", "git_search", "watch",
+        # All shell tools
+        "bash", "npx", "uvx", "process", "open",
+        # All other tools
+        "agent", "thinking", "llm", "mcp", "sql", "graph", "config",
+        "todo", "jupyter", "vim",
+    ]
+)
+
+# Minimal palette - Just the essentials
+minimal_palette = ToolPalette(
+    name="minimal",
+    description="Minimal set of essential tools",
+    tools=[
+        "read", "write", "edit", "bash", "grep", "tree"
+    ]
+)
+
+# C/C++ palette - Dennis Ritchie / Bjarne Stroustrup style
+cpp_palette = ToolPalette(
+    name="cpp",
+    description="C/C++ development tools for systems programming by Dennis Ritchie / Bjarne Stroustrup",
+    author="Dennis Ritchie / Bjarne Stroustrup",
+    tools=[
+        # Core tools
+        "bash", "read", "write", "edit", "grep", "tree", "find",
+        # C/C++ specific
+        "process",
+        # Compilers and build systems
+        "gcc", "clang", "g++", "clang++",
+        "make", "cmake", "ninja",
+        # Debugging and analysis
+        "gdb", "lldb", "valgrind",
+        "clang-format", "clang-tidy",
+        # Package management
+        "conan", "vcpkg",
+        # Documentation
+        "doxygen",
+    ],
+    environment={
+        "CC": "clang",
+        "CXX": "clang++",
+        "CFLAGS": "-Wall -Wextra",
+        "CXXFLAGS": "-Wall -Wextra -std=c++20",
+    }
+)
+
+# Data Science palette - Scientific computing
+datascience_palette = ToolPalette(
+    name="datascience",
+    description="Data science and machine learning tools",
+    author="Scientific Computing Community",
+    tools=[
+        # Core tools
+        "bash", "read", "write", "edit", "grep", "tree", "find",
+        # Python for data science
+        "uvx", "process", "jupyter",
+        # Data science tooling via uvx/pip
+        "pandas", "numpy", "scipy", "matplotlib", "seaborn",
+        "scikit-learn", "tensorflow", "pytorch",
+        "plotly", "bokeh", "streamlit",
+        "dvc", "mlflow", "wandb",
+        "black", "isort", "mypy",
+    ],
+    environment={
+        "PYTHONDONTWRITEBYTECODE": "1",
+        "PYTHONUNBUFFERED": "1",
+        "JUPYTER_ENABLE_LAB": "yes",
+    }
+)
+
+# Register all pre-defined palettes
+def register_default_palettes():
+    """Register all default tool palettes."""
+    for palette in [
+        python_palette,
+        ruby_palette,
+        javascript_palette,
+        go_palette,
+        rust_palette,
+        cpp_palette,
+        datascience_palette,
+        devops_palette,
+        fullstack_palette,
+        minimal_palette,
+    ]:
+        PaletteRegistry.register(palette)

hanzo_mcp/tools/common/palette_loader.py

@@ -0,0 +1,108 @@
+"""Tool palette loader for dynamic tool configuration."""
+
+import os
+from typing import Dict, List, Optional, Set
+
+from hanzo_mcp.tools.common.palette import PaletteRegistry, register_default_palettes
+
+
+class PaletteLoader:
+    """Loads and manages tool palettes for dynamic configuration."""
+    
+    @staticmethod
+    def initialize_palettes() -> None:
+        """Initialize the palette system with defaults."""
+        register_default_palettes()
+        
+        # Check for environment variable to set default palette
+        default_palette = os.environ.get("HANZO_MCP_PALETTE", "python")
+        if PaletteRegistry.get(default_palette):
+            PaletteRegistry.set_active(default_palette)
+    
+    @staticmethod
+    def get_enabled_tools_from_palette(
+        base_enabled_tools: Optional[Dict[str, bool]] = None,
+        force_palette: Optional[str] = None
+    ) -> Dict[str, bool]:
+        """Get enabled tools configuration from active palette.
+        
+        Args:
+            base_enabled_tools: Base configuration to merge with
+            force_palette: Force a specific palette (overrides active)
+            
+        Returns:
+            Dictionary of tool enable states
+        """
+        # Initialize if needed
+        if not PaletteRegistry.list():
+            PaletteLoader.initialize_palettes()
+        
+        # Get palette to use
+        if force_palette:
+            PaletteRegistry.set_active(force_palette)
+        
+        palette = PaletteRegistry.get_active()
+        if not palette:
+            # No active palette, 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 (this is a superset for safety)
+        all_possible_tools = {
+            # Filesystem tools
+            "read", "write", "edit", "multi_edit", "grep", "tree", "find",
+            "symbols", "git_search", "content_replace", "batch_search",
+            "find_files", "unified_search", "watch",
+            # Shell tools
+            "bash", "npx", "uvx", "process", "open",
+            # Database tools
+            "sql", "graph",
+            # Config tools
+            "config", "palette",
+            # LLM tools
+            "llm", "agent", "thinking",
+            # MCP tools
+            "mcp",
+            # Todo tools
+            "todo",
+            # Jupyter tools
+            "jupyter",
+            # Editor tools
+            "vim",
+            # Stats/system tools
+            "stats", "tool_enable", "tool_disable", "tool_list",
+        }
+        
+        # Disable all tools first (clean slate for palette)
+        for tool in all_possible_tools:
+            result[tool] = False
+        
+        # Enable tools from palette
+        for tool in palette.tools:
+            result[tool] = True
+        
+        # Always enable palette tool itself (meta)
+        result["palette"] = True
+        
+        return result
+    
+    @staticmethod
+    def get_environment_from_palette() -> Dict[str, str]:
+        """Get environment variables from active palette.
+        
+        Returns:
+            Dictionary of environment variables
+        """
+        palette = PaletteRegistry.get_active()
+        if palette and palette.environment:
+            return palette.environment.copy()
+        return {}
+    
+    @staticmethod
+    def apply_palette_environment() -> None:
+        """Apply environment variables from active palette to process."""
+        env_vars = PaletteLoader.get_environment_from_palette()
+        for key, value in env_vars.items():
+            os.environ[key] = value

hanzo_mcp/tools/common/stats.py

@@ -7,7 +7,7 @@ from typing import TypedDict, Unpack, final, override
 from datetime import datetime
 from pathlib import Path
 
-from fastmcp import Context as MCPContext
+from mcp.server.fastmcp import Context as MCPContext
 
 from hanzo_mcp.tools.common.base import BaseTool
 from hanzo_mcp.tools.common.context import create_tool_context

hanzo_mcp/tools/common/thinking_tool.py

@@ -5,9 +5,8 @@ This module provides the ThinkingTool for Claude to engage in structured thinkin
 
 from typing import Annotated, TypedDict, Unpack, final, override
 
-from fastmcp import Context as MCPContext
-from fastmcp import FastMCP
-from fastmcp.server.dependencies import get_context
+from mcp.server.fastmcp import Context as MCPContext
+from mcp.server import FastMCP
 from pydantic import Field
 
 from hanzo_mcp.tools.common.base import BaseTool
@@ -146,8 +145,7 @@ Feature Implementation Planning
 
         @mcp_server.tool(name=self.name, description=self.description)
         async def think(
-            ctx: MCPContext,
             thought: Thought,
+            ctx: MCPContext
         ) -> str:
-            ctx = get_context()
             return await tool_self.call(ctx, thought=thought)

hanzo_mcp/tools/common/tool_disable.py

@@ -2,7 +2,7 @@
 
 from typing import Annotated, TypedDict, Unpack, final, override
 
-from fastmcp import Context as MCPContext
+from mcp.server.fastmcp import Context as MCPContext
 from pydantic import Field
 
 from hanzo_mcp.tools.common.base import BaseTool

hanzo_mcp/tools/common/tool_enable.py

@@ -4,7 +4,7 @@ import json
 from typing import Annotated, TypedDict, Unpack, final, override
 from pathlib import Path
 
-from fastmcp import Context as MCPContext
+from mcp.server.fastmcp import Context as MCPContext
 from pydantic import Field
 
 from hanzo_mcp.tools.common.base import BaseTool

hanzo_mcp/tools/common/tool_list.py

@@ -2,7 +2,7 @@
 
 from typing import Annotated, TypedDict, Unpack, final, override, Optional
 
-from fastmcp import Context as MCPContext
+from mcp.server.fastmcp import Context as MCPContext
 from pydantic import Field
 
 from hanzo_mcp.tools.common.base import BaseTool
@@ -54,75 +54,72 @@ class ToolListTool(BaseTool):
             ("write", "Write contents to files"),
             ("edit", "Edit specific parts of files"),
             ("multi_edit", "Make multiple edits to a file"),
-            ("directory_tree", "Display directory structure"),
-            ("grep", "Search file contents with patterns"),
-            ("grep_ast", "Search code with AST patterns"),
+            ("tree", "Directory tree visualization (Unix-style)"),
+            ("find", "Find text in files (rg/ag/ack/grep)"),
+            ("symbols", "Code symbols search with tree-sitter"),
+            ("search", "Unified search (parallel grep/symbols/vector/git)"),
             ("git_search", "Search git history"),
-            ("batch_search", "Run multiple searches in parallel"),
-            ("find_files", "Find files by name pattern"),
+            ("glob", "Find files by name pattern"),
             ("content_replace", "Replace content across files"),
         ],
         "shell": [
-            ("run_command", "Execute shell commands"),
-            ("run_background", "Run commands in background"),
+            ("run_command", "Execute shell commands (--background option)"),
             ("processes", "List background processes"),
             ("pkill", "Kill background processes"),
             ("logs", "View process logs"),
-            ("uvx", "Run Python packages"),
-            ("uvx_background", "Run Python servers"),
-            ("npx", "Run Node.js packages"),
-            ("npx_background", "Run Node.js servers"),
+            ("uvx", "Run Python packages (--background option)"),
+            ("npx", "Run Node.js packages (--background option)"),
         ],
         "database": [
-            ("sql_query", "Execute SQL queries"),
-            ("sql_search", "Search in SQLite databases"),
-            ("sql_stats", "SQLite database statistics"),
-            ("graph_add", "Add nodes/edges to graph"),
-            ("graph_remove", "Remove nodes/edges from graph"),
-            ("graph_query", "Query graph relationships"),
-            ("graph_search", "Search in graph database"),
-            ("graph_stats", "Graph database statistics"),
+            ("sql", "SQLite operations (query/search/schema/stats)"),
+            ("graph", "Graph database (query/add/remove/search/stats)"),
+            ("vector", "Semantic search (search/index/stats/clear)"),
         ],
-        "vector": [
-            ("vector_index", "Index files into vector store"),
-            ("vector_search", "Semantic search in vector store"),
+        "ai": [
+            ("llm", "LLM interface (query/consensus/list/models/enable/disable)"),
+            ("agent", "AI agents (run/start/call/stop/list with A2A support)"),
+            ("mcp", "MCP servers (list/add/remove/enable/disable/restart)"),
         ],
-        "mcp": [
-            ("mcp_add", "Add MCP servers"),
-            ("mcp_remove", "Remove MCP servers"),
-            ("mcp_stats", "MCP server statistics"),
-        ],
-        "system": [
-            ("stats", "System and resource statistics"),
+        "config": [
+            ("config", "Git-style configuration (get/set/list/toggle)"),
             ("tool_enable", "Enable tools"),
             ("tool_disable", "Disable tools"),
             ("tool_list", "List all tools (this tool)"),
         ],
-        "editor": [
-            ("neovim_edit", "Open files in Neovim"),
-            ("neovim_command", "Execute Neovim commands"),
-            ("neovim_session", "Manage Neovim sessions"),
-        ],
-        "llm": [
-            ("llm", "Query any LLM via LiteLLM"),
-            ("consensus", "Get consensus from multiple LLMs"),
-            ("llm_manage", "Manage LLM providers"),
-            ("openai", "Query OpenAI models"),
-            ("anthropic", "Query Anthropic Claude models"),
-            ("gemini", "Query Google Gemini models"),
-            ("groq", "Query Groq fast models"),
-            ("mistral", "Query Mistral models"),
-            ("perplexity", "Query Perplexity with search"),
-        ],
-        "other": [
+        "productivity": [
+            ("todo", "Todo management (list/add/update/remove/clear)"),
+            ("jupyter", "Jupyter notebooks (read/edit/create/delete/execute)"),
             ("think", "Structured thinking space"),
-            ("dispatch_agent", "Delegate tasks to sub-agents"),
-            ("todo_read", "Read todo list"),
-            ("todo_write", "Write todo list"),
-            ("notebook_read", "Read Jupyter notebooks"),
-            ("notebook_edit", "Edit Jupyter notebooks"),
+        ],
+        "system": [
+            ("stats", "System and resource statistics"),
             ("batch", "Run multiple tools in parallel"),
         ],
+        "legacy": [
+            ("directory_tree", "Legacy: Use 'tree' instead"),
+            ("grep", "Legacy: Use 'find' instead"),
+            ("grep_ast", "Legacy: Use 'symbols' instead"),
+            ("batch_search", "Legacy: Use 'search' instead"),
+            ("find_files", "Legacy: Use 'glob' instead"),
+            ("run_background", "Legacy: Use 'run_command --background'"),
+            ("uvx_background", "Legacy: Use 'uvx --background'"),
+            ("npx_background", "Legacy: Use 'npx --background'"),
+            ("sql_query", "Legacy: Use 'sql' instead"),
+            ("sql_search", "Legacy: Use 'sql --action search'"),
+            ("sql_stats", "Legacy: Use 'sql --action stats'"),
+            ("graph_add", "Legacy: Use 'graph --action add'"),
+            ("graph_remove", "Legacy: Use 'graph --action remove'"),
+            ("graph_query", "Legacy: Use 'graph' instead"),
+            ("graph_search", "Legacy: Use 'graph --action search'"),
+            ("graph_stats", "Legacy: Use 'graph --action stats'"),
+            ("vector_index", "Legacy: Use 'vector --action index'"),
+            ("vector_search", "Legacy: Use 'vector' instead"),
+            ("dispatch_agent", "Legacy: Use 'agent' instead"),
+            ("todo_read", "Legacy: Use 'todo' instead"),
+            ("todo_write", "Legacy: Use 'todo --action add/update'"),
+            ("notebook_read", "Legacy: Use 'jupyter' instead"),
+            ("notebook_edit", "Legacy: Use 'jupyter --action edit'"),
+        ],
     }
 
     def __init__(self):

hanzo_mcp/tools/config/__init__.py

@@ -0,0 +1,10 @@
+"""Configuration tools for Hanzo MCP."""
+
+from hanzo_mcp.tools.config.config_tool import ConfigTool
+from hanzo_mcp.tools.config.index_config import IndexConfig, IndexScope
+
+__all__ = [
+    "ConfigTool",
+    "IndexConfig", 
+    "IndexScope",
+]