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

hanzo_mcp/tools/common/palette.py

@@ -1,344 +0,0 @@
-"""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

@@ -1,108 +0,0 @@
-"""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/config/palette_tool.py

@@ -1,179 +0,0 @@
-"""Tool for managing development tool palettes."""
-
-from typing import Optional, override
-
-from mcp.server.fastmcp import Context as MCPContext
-
-from hanzo_mcp.tools.common.base import BaseTool
-from hanzo_mcp.tools.common.palette import PaletteRegistry, register_default_palettes
-from mcp.server import FastMCP
-
-
-class PaletteTool(BaseTool):
-    """Tool for managing tool palettes."""
-    
-    name = "palette"
-    
-    def __init__(self):
-        """Initialize the palette tool."""
-        super().__init__()
-        # Register default palettes on initialization
-        register_default_palettes()
-    
-    @property
-    @override
-    def description(self) -> str:
-        """Get the tool description."""
-        return """Manage tool palettes. Actions: list (default), activate, show, current.
-
-Usage:
-palette
-palette --action list
-palette --action activate python
-palette --action show javascript
-palette --action current"""
-    
-    @override
-    async def run(
-        self,
-        ctx: MCPContext,
-        action: str = "list",
-        name: Optional[str] = None,
-    ) -> str:
-        """Manage tool palettes.
-        
-        Args:
-            ctx: MCP context
-            action: Action to perform (list, activate, show, current)
-            name: Palette name (for activate/show actions)
-            
-        Returns:
-            Action result
-        """
-        if action == "list":
-            palettes = PaletteRegistry.list()
-            if not palettes:
-                return "No palettes registered"
-            
-            output = ["Available tool palettes:"]
-            active = PaletteRegistry.get_active()
-            
-            for palette in sorted(palettes, key=lambda p: p.name):
-                marker = " (active)" if active and active.name == palette.name else ""
-                author = f" by {palette.author}" if palette.author else ""
-                output.append(f"\n{palette.name}{marker}:")
-                output.append(f"  {palette.description}{author}")
-                output.append(f"  Tools: {len(palette.tools)} enabled")
-            
-            return "\n".join(output)
-        
-        elif action == "activate":
-            if not name:
-                return "Error: Palette name required for activate action"
-            
-            try:
-                PaletteRegistry.set_active(name)
-                palette = PaletteRegistry.get(name)
-                
-                output = [f"Activated palette: {palette.name}"]
-                if palette.author:
-                    output.append(f"Author: {palette.author}")
-                output.append(f"Description: {palette.description}")
-                output.append(f"\nEnabled tools ({len(palette.tools)}):")
-                
-                # Group tools by category
-                core_tools = []
-                package_tools = []
-                other_tools = []
-                
-                for tool in sorted(palette.tools):
-                    if tool in ["read", "write", "edit", "grep", "tree", "find", "bash"]:
-                        core_tools.append(tool)
-                    elif tool in ["npx", "uvx", "pip", "cargo", "gem"]:
-                        package_tools.append(tool)
-                    else:
-                        other_tools.append(tool)
-                
-                if core_tools:
-                    output.append(f"  Core: {', '.join(core_tools)}")
-                if package_tools:
-                    output.append(f"  Package managers: {', '.join(package_tools)}")
-                if other_tools:
-                    output.append(f"  Specialized: {', '.join(other_tools)}")
-                
-                if palette.environment:
-                    output.append("\nEnvironment variables:")
-                    for key, value in palette.environment.items():
-                        output.append(f"  {key}={value}")
-                
-                output.append("\nNote: Restart MCP session for changes to take full effect")
-                
-                return "\n".join(output)
-                
-            except ValueError as e:
-                return str(e)
-        
-        elif action == "show":
-            if not name:
-                return "Error: Palette name required for show action"
-            
-            palette = PaletteRegistry.get(name)
-            if not palette:
-                return f"Palette '{name}' not found"
-            
-            output = [f"Palette: {palette.name}"]
-            if palette.author:
-                output.append(f"Author: {palette.author}")
-            output.append(f"Description: {palette.description}")
-            output.append(f"\nTools ({len(palette.tools)}):")
-            
-            for tool in sorted(palette.tools):
-                output.append(f"  - {tool}")
-            
-            if palette.environment:
-                output.append("\nEnvironment:")
-                for key, value in palette.environment.items():
-                    output.append(f"  {key}={value}")
-            
-            return "\n".join(output)
-        
-        elif action == "current":
-            active = PaletteRegistry.get_active()
-            if not active:
-                return "No palette currently active\nUse 'palette --action activate <name>' to activate one"
-            
-            output = [f"Current palette: {active.name}"]
-            if active.author:
-                output.append(f"Author: {active.author}")
-            output.append(f"Description: {active.description}")
-            output.append(f"Enabled tools: {len(active.tools)}")
-            
-            return "\n".join(output)
-        
-        else:
-            return f"Unknown action: {action}. Use 'list', 'activate', 'show', or 'current'"
-
-    def register(self, server: FastMCP) -> None:
-        """Register the tool with the MCP server."""
-        tool_self = self
-        
-        @server.tool(name=self.name, description=self.description)
-        async def palette_handler(
-            ctx: MCPContext,
-            action: str = "list",
-            name: Optional[str] = None,
-        ) -> str:
-            """Handle palette tool calls."""
-            return await tool_self.run(ctx, action=action, name=name)
-    
-    async def call(self, ctx: MCPContext, **params) -> str:
-        """Call the tool with arguments."""
-        return await self.run(
-            ctx,
-            action=params.get("action", "list"),
-            name=params.get("name")
-        )
-
-
-# Create tool instance
-palette_tool = PaletteTool()