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

hanzo_mcp/tools/vector/vector.py

@@ -0,0 +1,311 @@
+"""Unified vector store tool."""
+
+from typing import Annotated, TypedDict, Unpack, final, override, Optional, List, Dict, Any
+from pathlib import Path
+
+from mcp.server.fastmcp import Context as MCPContext
+from pydantic import Field
+
+from hanzo_mcp.tools.common.base import BaseTool
+from hanzo_mcp.tools.common.permissions import PermissionManager
+from hanzo_mcp.tools.vector.project_manager import ProjectVectorManager
+
+
+# Parameter types
+Action = Annotated[
+    str,
+    Field(
+        description="Action: search (default), index, stats, clear",
+        default="search",
+    ),
+]
+
+Query = Annotated[
+    Optional[str],
+    Field(
+        description="Search query for semantic similarity",
+        default=None,
+    ),
+]
+
+Path = Annotated[
+    Optional[str],
+    Field(
+        description="Path to index or search within",
+        default=".",
+    ),
+]
+
+Include = Annotated[
+    Optional[str],
+    Field(
+        description="File pattern to include (e.g., '*.py')",
+        default=None,
+    ),
+]
+
+Exclude = Annotated[
+    Optional[str],
+    Field(
+        description="File pattern to exclude",
+        default=None,
+    ),
+]
+
+Limit = Annotated[
+    int,
+    Field(
+        description="Maximum results to return",
+        default=10,
+    ),
+]
+
+IncludeGit = Annotated[
+    bool,
+    Field(
+        description="Include git history in indexing",
+        default=True,
+    ),
+]
+
+ForceReindex = Annotated[
+    bool,
+    Field(
+        description="Force reindexing even if up to date",
+        default=False,
+    ),
+]
+
+
+class VectorParams(TypedDict, total=False):
+    """Parameters for vector tool."""
+    action: str
+    query: Optional[str]
+    path: Optional[str]
+    include: Optional[str]
+    exclude: Optional[str]
+    limit: int
+    include_git: bool
+    force_reindex: bool
+
+
+@final
+class VectorTool(BaseTool):
+    """Unified vector store tool for semantic search."""
+    
+    def __init__(self, permission_manager: PermissionManager, project_manager: ProjectVectorManager):
+        """Initialize the vector tool."""
+        super().__init__(permission_manager)
+        self.project_manager = project_manager
+
+    @property
+    @override
+    def name(self) -> str:
+        """Get the tool name."""
+        return "vector"
+
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description."""
+        return """Semantic search with embeddings. Actions: search (default), index, stats, clear.
+
+Usage:
+vector "find authentication logic"
+vector --action index --path ./src --include "*.py"
+vector --action stats
+vector --action clear --path ./old_code
+"""
+
+    @override
+    async def call(
+        self,
+        ctx: MCPContext,
+        **params: Unpack[VectorParams],
+    ) -> str:
+        """Execute vector operation."""
+        tool_ctx = self.create_tool_context(ctx)
+
+        # Extract action
+        action = params.get("action", "search")
+        
+        # Route to appropriate handler
+        if action == "search":
+            return await self._handle_search(params, tool_ctx)
+        elif action == "index":
+            return await self._handle_index(params, tool_ctx)
+        elif action == "stats":
+            return await self._handle_stats(params, tool_ctx)
+        elif action == "clear":
+            return await self._handle_clear(params, tool_ctx)
+        else:
+            return f"Error: Unknown action '{action}'. Valid actions: search, index, stats, clear"
+
+    async def _handle_search(self, params: Dict[str, Any], tool_ctx) -> str:
+        """Handle semantic search."""
+        query = params.get("query")
+        if not query:
+            return "Error: query is required for search action"
+        
+        path = params.get("path", ".")
+        limit = params.get("limit", 10)
+        
+        # Validate path
+        allowed, error_msg = await self.check_path_allowed(path, tool_ctx)
+        if not allowed:
+            return error_msg
+        
+        try:
+            # Determine search scope
+            project = self.project_manager.get_project_for_path(path)
+            if not project:
+                return "Error: No indexed project found for this path. Run 'vector --action index' first."
+            
+            # Search
+            await tool_ctx.info(f"Searching for: {query}")
+            results = project.search(query, k=limit)
+            
+            if not results:
+                return f"No results found for: {query}"
+            
+            # Format results
+            output = [f"=== Vector Search Results for '{query}' ==="]
+            output.append(f"Found {len(results)} matches\n")
+            
+            for i, result in enumerate(results, 1):
+                score = result.get("score", 0)
+                file_path = result.get("file_path", "unknown")
+                content = result.get("content", "")
+                chunk_type = result.get("metadata", {}).get("type", "content")
+                
+                output.append(f"Result {i} - Score: {score:.1%}")
+                output.append(f"File: {file_path}")
+                if chunk_type != "content":
+                    output.append(f"Type: {chunk_type}")
+                output.append("-" * 60)
+                
+                # Truncate content if too long
+                if len(content) > 300:
+                    content = content[:300] + "..."
+                output.append(content)
+                output.append("")
+            
+            return "\n".join(output)
+            
+        except Exception as e:
+            await tool_ctx.error(f"Search failed: {str(e)}")
+            return f"Error during search: {str(e)}"
+
+    async def _handle_index(self, params: Dict[str, Any], tool_ctx) -> str:
+        """Handle indexing files."""
+        path = params.get("path", ".")
+        include = params.get("include")
+        exclude = params.get("exclude")
+        include_git = params.get("include_git", True)
+        force = params.get("force_reindex", False)
+        
+        # Validate path
+        allowed, error_msg = await self.check_path_allowed(path, tool_ctx)
+        if not allowed:
+            return error_msg
+        
+        try:
+            await tool_ctx.info(f"Indexing {path}...")
+            
+            # Get or create project
+            project = self.project_manager.get_or_create_project(path)
+            
+            # Index files
+            stats = await project.index_directory(
+                path,
+                include_pattern=include,
+                exclude_pattern=exclude,
+                force_reindex=force
+            )
+            
+            # Index git history if requested
+            if include_git and Path(path).joinpath(".git").exists():
+                await tool_ctx.info("Indexing git history...")
+                git_stats = await project.index_git_history(path)
+                stats["git_commits"] = git_stats.get("commits_indexed", 0)
+            
+            # Format output
+            output = [f"=== Indexing Complete ==="]
+            output.append(f"Path: {path}")
+            output.append(f"Files indexed: {stats.get('files_indexed', 0)}")
+            output.append(f"Chunks created: {stats.get('chunks_created', 0)}")
+            if stats.get("git_commits"):
+                output.append(f"Git commits indexed: {stats['git_commits']}")
+            output.append(f"Total documents: {project.get_stats().get('total_documents', 0)}")
+            
+            return "\n".join(output)
+            
+        except Exception as e:
+            await tool_ctx.error(f"Indexing failed: {str(e)}")
+            return f"Error during indexing: {str(e)}"
+
+    async def _handle_stats(self, params: Dict[str, Any], tool_ctx) -> str:
+        """Get vector store statistics."""
+        path = params.get("path")
+        
+        try:
+            if path:
+                # Stats for specific project
+                project = self.project_manager.get_project_for_path(path)
+                if not project:
+                    return f"No indexed project found for path: {path}"
+                
+                stats = project.get_stats()
+                output = [f"=== Vector Store Stats for {project.name} ==="]
+            else:
+                # Global stats
+                stats = self.project_manager.get_global_stats()
+                output = ["=== Global Vector Store Stats ==="]
+            
+            output.append(f"Total documents: {stats.get('total_documents', 0)}")
+            output.append(f"Total size: {stats.get('total_size_mb', 0):.1f} MB")
+            
+            if stats.get("projects"):
+                output.append(f"\nProjects indexed: {len(stats['projects'])}")
+                for proj in stats["projects"]:
+                    output.append(f"  - {proj['name']}: {proj['documents']} docs, {proj['size_mb']:.1f} MB")
+            
+            return "\n".join(output)
+            
+        except Exception as e:
+            await tool_ctx.error(f"Failed to get stats: {str(e)}")
+            return f"Error getting stats: {str(e)}"
+
+    async def _handle_clear(self, params: Dict[str, Any], tool_ctx) -> str:
+        """Clear vector store."""
+        path = params.get("path")
+        
+        if not path:
+            return "Error: path is required for clear action"
+        
+        # Validate path
+        allowed, error_msg = await self.check_path_allowed(path, tool_ctx)
+        if not allowed:
+            return error_msg
+        
+        try:
+            project = self.project_manager.get_project_for_path(path)
+            if not project:
+                return f"No indexed project found for path: {path}"
+            
+            # Get stats before clearing
+            stats = project.get_stats()
+            doc_count = stats.get("total_documents", 0)
+            
+            # Clear
+            project.clear()
+            
+            return f"Cleared {doc_count} documents from vector store for {project.name}"
+            
+        except Exception as e:
+            await tool_ctx.error(f"Failed to clear: {str(e)}")
+            return f"Error clearing vector store: {str(e)}"
+
+    def register(self, mcp_server) -> None:
+        """Register this tool with the MCP server."""
+        pass

hanzo_mcp/tools/vector/vector_index.py

@@ -3,7 +3,7 @@
 from typing import Dict, List, Optional, TypedDict, Unpack, final
 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/vector/vector_search.py

@@ -4,7 +4,7 @@ from typing import Dict, List, Optional, TypedDict, Unpack, final
 import json
 import asyncio
 
-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
@@ -48,13 +48,18 @@ class VectorSearchTool(BaseTool):
     @property
     def description(self) -> str:
         """Get the tool description."""
-        return """Search for documents using semantic similarity across project-aware vector databases.
-        
-Performs intelligent text search that understands meaning and context, not just keywords.
-Can search across all projects, specific projects, or just the global database. Projects are
-automatically detected based on LLM.md files.
+        return """Pure semantic/vector search using Infinity embedded database.
+
+Searches indexed documents using vector embeddings to find semantically similar content.
+This is NOT keyword search - it finds documents based on meaning and context similarity.
+
+Features:
+- Searches across project-specific vector databases
+- Returns similarity scores (0-1, higher is better)
+- Supports filtering by project or file
+- Automatically detects projects via LLM.md files
 
-Returns ranked results with similarity scores, project context, and document metadata."""
+Use 'grep' for exact text/pattern matching, 'vector_search' for semantic similarity."""
     
     async def call(
         self,

hanzo_mcp-0.6.1.dist-info/METADATA

@@ -0,0 +1,336 @@
+Metadata-Version: 2.4
+Name: hanzo-mcp
+Version: 0.6.1
+Summary: The Zen of Hanzo MCP: One server to rule them all. The ultimate MCP that orchestrates all others.
+Author-email: Hanzo Industries Inc <dev@hanzo.ai>
+License: MIT
+Project-URL: Homepage, https://github.com/hanzoai/mcp
+Project-URL: Bug Tracker, https://github.com/hanzoai/mcp/issues
+Project-URL: Documentation, https://mcp.hanzo.ai
+Keywords: mcp,claude,hanzo,code,agent
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp>=1.6.0
+Requires-Dist: fastmcp>=2.8.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: uvicorn>=0.23.1
+Requires-Dist: openai>=1.50.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: litellm>=1.40.14
+Requires-Dist: grep-ast>=0.8.1
+Requires-Dist: bashlex>=0.18
+Requires-Dist: libtmux>=0.39.0
+Requires-Dist: nbformat>=5.10.4
+Requires-Dist: psutil>=6.1.0
+Requires-Dist: pydantic>=2.10.0
+Requires-Dist: typing-extensions>=4.12.2
+Requires-Dist: watchdog>=3.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: black>=23.3.0; extra == "dev"
+Requires-Dist: sphinx>=8.0.0; extra == "dev"
+Requires-Dist: sphinx-rtd-theme>=3.0.0; extra == "dev"
+Requires-Dist: myst-parser>=4.0.0; extra == "dev"
+Requires-Dist: sphinx-copybutton>=0.5.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=8.0.0; extra == "docs"
+Requires-Dist: sphinx-rtd-theme>=3.0.0; extra == "docs"
+Requires-Dist: myst-parser>=4.0.0; extra == "docs"
+Requires-Dist: sphinx-copybutton>=0.5.0; extra == "docs"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == "test"
+Requires-Dist: pytest-cov>=4.1.0; extra == "test"
+Requires-Dist: pytest-mock>=3.10.0; extra == "test"
+Requires-Dist: pytest-asyncio>=0.25.3; extra == "test"
+Requires-Dist: twisted; extra == "test"
+Provides-Extra: performance
+Requires-Dist: ujson>=5.7.0; extra == "performance"
+Requires-Dist: orjson>=3.9.0; extra == "performance"
+Provides-Extra: publish
+Requires-Dist: twine>=4.0.2; extra == "publish"
+Requires-Dist: build>=1.0.3; extra == "publish"
+Dynamic: license-file
+
+# Hanzo MCP - The Zen of Model Context Protocol
+
+[![Documentation](https://img.shields.io/badge/docs-mcp.hanzo.ai-blue?style=for-the-badge)](https://mcp.hanzo.ai)
+[![PyPI](https://img.shields.io/pypi/v/hanzo-mcp?style=for-the-badge)](https://pypi.org/project/hanzo-mcp/)
+[![License](https://img.shields.io/github/license/hanzoai/mcp?style=for-the-badge)](https://github.com/hanzoai/mcp/blob/main/LICENSE)
+[![Join our Discord](https://img.shields.io/discord/YOUR_DISCORD_ID?style=for-the-badge&logo=discord)](https://discord.gg/hanzoai)
+
+## 🥷 One MCP to Rule Them All
+
+**Start here. Add other MCPs later. Control everything through one opinionated interface.**
+
+Hanzo MCP isn't just another Model Context Protocol server—it's **THE** MCP server. While others give you fragments, we give you the complete toolkit. One server that orchestrates all others, with the power to add, remove, and control any MCP server dynamically.
+
+```bash
+# Install and rule your development world
+uvx hanzo-mcp
+```
+
+## 🎯 Why Hanzo MCP?
+
+### The Problem with Other MCPs
+- **Fragmented Experience**: Install 10 different MCPs for 10 different tasks
+- **Inconsistent Interfaces**: Each MCP has its own conventions and quirks  
+- **Limited Scope**: Most MCPs do one thing, leaving you to juggle multiple servers
+- **No Orchestration**: No way to coordinate between different MCP servers
+
+### The Hanzo Way
+- **One Installation**: 65+ professional tools out of the box
+- **Unified Philosophy**: Consistent, opinionated interface following Unix principles
+- **MCP Orchestration**: Install and control other MCP servers through Hanzo
+- **Swappable Opinions**: Don't like our way? Load a different palette and change everything
+
+## 🚀 Features That Set Us Apart
+
+### 🎨 Palette System - Opinions Are Just Configurations
+```python
+# Don't like our shell tools? Swap the palette
+palette_load(palette="minimal")  # Just the essentials
+palette_load(palette="pentesting")  # Security focused tools  
+palette_load(palette="data-science")  # Jupyter, pandas, numpy focused
+palette_load(palette="your-custom")  # Your tools, your way
+```
+
+### 🔌 MCP Server Orchestration
+```python
+# Add any MCP server dynamically
+mcp_add(url="github.com/someone/their-mcp", alias="their")
+
+# Use their tools through our unified interface
+their_tool(action="whatever", params=...)
+
+# Remove when done
+mcp_remove(alias="their")
+```
+
+### 🛠️ 65+ Battle-Tested Tools
+
+#### Intelligent Multi-Modal Search
+- **search**: Combines grep, AST analysis, vector embeddings, and git history
+- **symbols**: Find any code symbol across languages instantly
+- **git_search**: Search through git history, branches, and commits
+
+#### Advanced Development
+- **agent**: Delegate complex tasks to specialized AI agents
+- **llm**: Query multiple LLM providers with consensus
+- **jupyter**: Full Jupyter notebook support
+- **neovim**: Integrated Neovim for power users
+
+#### File Operations That Just Work
+- **edit/multi_edit**: Intelligent pattern-based editing
+- **read/write**: Automatic encoding detection
+- **tree**: Visual directory structures
+- **watch**: Monitor file changes in real-time
+
+#### Process & System Control  
+- **run_command**: Secure command execution with timeout
+- **processes**: Monitor and manage system processes
+- **npx/uvx**: Package runners with background support
+
+#### And So Much More
+- Database tools (SQL, Graph)
+- Vector search and indexing
+- Todo management
+- Configuration management
+- MCP server management
+- Statistical analysis
+- Batch operations
+
+## 🎯 The Zen of Hanzo
+
+1. **One Tool, One Purpose** - Each tool does one thing exceptionally well
+2. **Actions Over Tools** - Complex tools support multiple actions, not multiple interfaces
+3. **Parallel by Default** - Run multiple operations concurrently
+4. **Smart Fallbacks** - Automatically choose the best available backend
+5. **Secure by Design** - Fine-grained permissions and audit trails
+6. **Opinionated but Flexible** - Strong defaults with palette customization
+
+## 🚀 Quick Start
+
+### Installation
+
+```bash
+# Install globally with uvx (recommended)
+uvx hanzo-mcp
+
+# Or install with pip
+pip install hanzo-mcp
+
+# Or install from source for development
+git clone https://github.com/hanzoai/mcp
+cd mcp
+make install
+```
+
+### Add to Claude Desktop
+
+```bash
+# Automatic installation
+make install-desktop
+
+# Or manual configuration
+cat >> ~/Library/Application\ Support/Claude/claude_desktop_config.json << 'EOF'
+{
+  "mcpServers": {
+    "hanzo": {
+      "command": "uvx",
+      "args": ["hanzo-mcp"]
+    }
+  }
+}
+EOF
+```
+
+### Your First Session
+
+1. Open Claude Desktop
+2. Start with `search` to explore any codebase
+3. Use `tree` to understand structure  
+4. Edit files with `edit` or `multi_edit`
+5. Run commands with `run_command`
+6. Add other MCP servers with `mcp_add`
+
+## 🎨 Palette System
+
+Palettes let you completely transform Hanzo MCP's behavior:
+
+```python
+# List available palettes
+palette_list()
+
+# Load a different personality
+palette_load(palette="minimal")  # Just core tools
+palette_load(palette="academic")  # Research and writing focused
+palette_load(palette="devops")   # Infrastructure and deployment
+
+# Create your own
+palette_create(
+    name="my-workflow",
+    tools=["read", "write", "edit", "search", "my-custom-tool"],
+    config={"editor": "vim", "search_backend": "ripgrep"}
+)
+```
+
+## 🔌 MCP Orchestration
+
+Hanzo MCP can manage other MCP servers:
+
+```python
+# Add any MCP server
+mcp_add(url="github.com/modelcontextprotocol/servers/tree/main/postgres")
+
+# List installed servers
+mcp_stats()
+
+# Use tools from other servers seamlessly
+postgres_query(query="SELECT * FROM users")
+
+# Remove when done
+mcp_remove(alias="postgres")
+```
+
+## 📊 Advanced Features
+
+### Intelligent Search
+```python
+# Multi-modal search across your codebase
+results = search(
+    query="authentication",
+    include_git=True,      # Search git history
+    include_vector=True,   # Semantic search
+    include_ast=True,      # AST symbol search
+    parallel=True          # Search all modes concurrently
+)
+```
+
+### Agent Orchestration  
+```python
+# Delegate complex tasks to specialized agents
+agent(
+    task="Refactor this codebase to use async/await",
+    files=["src/**/*.py"],
+    instructions="Maintain backwards compatibility"
+)
+```
+
+### Consensus LLM Queries
+```python
+# Query multiple LLMs and get consensus
+llm(
+    action="consensus",
+    prompt="Is this code secure?",
+    providers=["openai", "anthropic", "google"],
+    threshold=0.8
+)
+```
+
+## 🏗️ Architecture
+
+Built on modern Python with:
+- **FastMCP**: High-performance MCP framework
+- **UV**: Lightning-fast Python package management
+- **Parallel Execution**: Concurrent operations by default
+- **Smart Backends**: Automatic selection of best available tools
+- **Type Safety**: Full type hints and validation
+
+## 🤝 Contributing
+
+We welcome contributions! The codebase is designed for extensibility:
+
+1. **Add a Tool**: Drop a file in `hanzo_mcp/tools/`
+2. **Create a Palette**: Define tool collections and configurations
+3. **Improve Existing Tools**: Each tool is independently testable
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+## 📚 Documentation
+
+- **[Quick Start Guide](https://mcp.hanzo.ai/quickstart)** - Get running in 5 minutes
+- **[Tool Reference](https://mcp.hanzo.ai/tools)** - Detailed documentation for all 65+ tools  
+- **[Palette System](https://mcp.hanzo.ai/palettes)** - Customize your experience
+- **[MCP Orchestration](https://mcp.hanzo.ai/orchestration)** - Control other MCP servers
+- **[Best Practices](https://mcp.hanzo.ai/best-practices)** - Tips from power users
+
+## 🌟 Why Developers Choose Hanzo MCP
+
+> "I replaced 12 different MCP servers with just Hanzo. The palette system means I can switch contexts instantly—from web dev to data science to DevOps." - *Power User*
+
+> "The agent orchestration is incredible. I can delegate entire refactoring tasks and it just works." - *Sr. Engineer*
+
+> "Finally, an MCP that thinks like a developer. Smart defaults, great errors, and everything is parallel." - *Tech Lead*
+
+## 📈 Stats
+
+- **65+** Professional Tools
+- **10x** Faster than installing multiple MCPs
+- **1** Unified interface to rule them all
+- **∞** Possibilities with the palette system
+
+## 📄 License
+
+MIT - Use it, extend it, make it yours.
+
+## 🔗 Links
+
+- [GitHub](https://github.com/hanzoai/mcp)
+- [Documentation](https://mcp.hanzo.ai)
+- [PyPI](https://pypi.org/project/hanzo-mcp/)
+- [Discord Community](https://discord.gg/hanzoai)
+- [Report Issues](https://github.com/hanzoai/mcp/issues)
+
+---
+
+<p align="center">
+  <b>The Zen of Hanzo MCP</b><br>
+  <i>One server. All tools. Your way.</i><br><br>
+  <code>uvx hanzo-mcp</code>
+</p>