hanzo-mcp 0.7.7__py3-none-any.whl → 0.8.0__py3-none-any.whl

hanzo_mcp/tools/config/index_config.py

@@ -4,36 +4,37 @@ This module manages indexing configuration for different scopes.
 """
 
 import json
-from pathlib import Path
-from typing import Dict, Any, Optional
 from enum import Enum
+from typing import Any, Dict, Optional
+from pathlib import Path
 
 
 class IndexScope(Enum):
     """Indexing scope options."""
+
     PROJECT = "project"  # Per-project indexing
-    GLOBAL = "global"    # Global indexing
-    AUTO = "auto"        # Auto-detect based on git root
+    GLOBAL = "global"  # Global indexing
+    AUTO = "auto"  # Auto-detect based on git root
 
 
 class IndexConfig:
     """Manages indexing configuration."""
-    
+
     def __init__(self, config_dir: Optional[Path] = None):
         """Initialize index configuration."""
         self.config_dir = config_dir or Path.home() / ".hanzo" / "mcp"
         self.config_file = self.config_dir / "index_config.json"
         self._config = self._load_config()
-        
+
     def _load_config(self) -> Dict[str, Any]:
         """Load configuration from disk."""
         if self.config_file.exists():
             try:
                 with open(self.config_file, "r") as f:
                     return json.load(f)
-            except:
+            except Exception:
                 pass
-        
+
         # Default configuration
         return {
             "default_scope": IndexScope.AUTO.value,
@@ -56,40 +57,40 @@ class IndexConfig:
                 "graph": {
                     "enabled": True,
                     "per_project": True,
-                }
-            }
+                },
+            },
         }
-    
+
     def save_config(self) -> None:
         """Save configuration to disk."""
         self.config_dir.mkdir(parents=True, exist_ok=True)
         with open(self.config_file, "w") as f:
             json.dump(self._config, f, indent=2)
-    
+
     def get_scope(self, path: Optional[str] = None) -> IndexScope:
         """Get indexing scope for a path."""
         if not path:
             return IndexScope(self._config["default_scope"])
-            
+
         # Check project-specific config
         project_root = self._find_project_root(path)
         if project_root:
             project_config = self._config["project_configs"].get(str(project_root))
             if project_config and "scope" in project_config:
                 return IndexScope(project_config["scope"])
-        
+
         # Use default
         scope = IndexScope(self._config["default_scope"])
-        
+
         # Handle auto mode
         if scope == IndexScope.AUTO:
             if project_root:
                 return IndexScope.PROJECT
             else:
                 return IndexScope.GLOBAL
-                
+
         return scope
-    
+
     def set_scope(self, scope: IndexScope, path: Optional[str] = None) -> None:
         """Set indexing scope."""
         if path:
@@ -98,40 +99,42 @@ class IndexConfig:
             if project_root:
                 if str(project_root) not in self._config["project_configs"]:
                     self._config["project_configs"][str(project_root)] = {}
-                self._config["project_configs"][str(project_root)]["scope"] = scope.value
+                self._config["project_configs"][str(project_root)][
+                    "scope"
+                ] = scope.value
         else:
             # Set global default
             self._config["default_scope"] = scope.value
-            
+
         self.save_config()
-    
+
     def get_index_path(self, tool: str, path: Optional[str] = None) -> Path:
         """Get index path for a tool and location."""
         scope = self.get_scope(path)
-        
+
         if scope == IndexScope.PROJECT and path:
             project_root = self._find_project_root(path)
             if project_root:
                 return Path(project_root) / ".hanzo" / "index" / tool
-        
+
         # Global index
         return self.config_dir / "index" / tool
-    
+
     def is_indexing_enabled(self, tool: str) -> bool:
         """Check if indexing is enabled for a tool."""
         return self._config["index_settings"].get(tool, {}).get("enabled", True)
-    
+
     def set_indexing_enabled(self, tool: str, enabled: bool) -> None:
         """Enable/disable indexing for a tool."""
         if tool not in self._config["index_settings"]:
             self._config["index_settings"][tool] = {}
         self._config["index_settings"][tool]["enabled"] = enabled
         self.save_config()
-    
+
     def toggle_scope(self, path: Optional[str] = None) -> IndexScope:
         """Toggle between project and global scope."""
         current = self.get_scope(path)
-        
+
         if current == IndexScope.PROJECT:
             new_scope = IndexScope.GLOBAL
         elif current == IndexScope.GLOBAL:
@@ -142,25 +145,25 @@ class IndexConfig:
                 new_scope = IndexScope.GLOBAL
             else:
                 new_scope = IndexScope.PROJECT
-        
+
         self.set_scope(new_scope, path)
         return new_scope
-    
+
     def _find_project_root(self, path: str) -> Optional[Path]:
         """Find project root (git root or similar)."""
         current = Path(path).resolve()
-        
+
         # Walk up looking for markers
         markers = [".git", ".hg", "pyproject.toml", "package.json", "Cargo.toml"]
-        
+
         while current != current.parent:
             for marker in markers:
                 if (current / marker).exists():
                     return current
             current = current.parent
-            
+
         return None
-    
+
     def get_status(self) -> Dict[str, Any]:
         """Get current configuration status."""
         return {
@@ -172,5 +175,5 @@ class IndexConfig:
                     "per_project": settings.get("per_project", True),
                 }
                 for tool, settings in self._config["index_settings"].items()
-            }
-        }
+            },
+        }

hanzo_mcp/tools/config/mode_tool.py

@@ -2,24 +2,24 @@
 
 from typing import Optional, override
 
+from mcp.server import FastMCP
 from mcp.server.fastmcp import Context as MCPContext
 
 from hanzo_mcp.tools.common.base import BaseTool
 from hanzo_mcp.tools.common.mode import ModeRegistry, register_default_modes
-from mcp.server import FastMCP
 
 
 class ModeTool(BaseTool):
     """Tool for managing development modes."""
-    
+
     name = "mode"
-    
+
     def __init__(self):
         """Initialize the mode tool."""
         super().__init__()
         # Register default modes on initialization
         register_default_modes()
-    
+
     @property
     @override
     def description(self) -> str:
@@ -32,7 +32,7 @@ mode --action list
 mode --action activate guido
 mode --action show linus
 mode --action current"""
-    
+
     @override
     async def run(
         self,
@@ -41,12 +41,12 @@ mode --action current"""
         name: Optional[str] = None,
     ) -> str:
         """Manage development modes.
-        
+
         Args:
             ctx: MCP context
             action: Action to perform (list, activate, show, current)
             name: Mode name (for activate/show actions)
-            
+
         Returns:
             Action result
         """
@@ -54,60 +54,182 @@ mode --action current"""
             modes = ModeRegistry.list()
             if not modes:
                 return "No modes registered"
-            
+
             output = ["Available development modes (100 programmer personalities):"]
             active = ModeRegistry.get_active()
-            
+
             # Group modes by category
             categories = {
-                "Language Creators": ["guido", "matz", "brendan", "dennis", "bjarne", "james", "anders", "larry", "rasmus", "rich"],
-                "Systems & Infrastructure": ["linus", "rob", "ken", "bill", "richard", "brian", "donald", "graydon", "ryan", "mitchell"],
-                "Web & Frontend": ["tim", "douglas", "john", "evan", "jordan", "jeremy", "david", "taylor", "adrian", "matt"],
-                "Database & Data": ["michael_s", "michael_w", "salvatore", "dwight", "edgar", "jim_gray", "jeff_dean", "sanjay", "mike", "matei"],
-                "AI & Machine Learning": ["yann", "geoffrey", "yoshua", "andrew", "demis", "ilya", "andrej", "chris", "francois", "jeremy_howard"],
-                "Security & Cryptography": ["bruce", "phil", "whitfield", "ralph", "daniel_b", "moxie", "theo", "dan_kaminsky", "katie", "matt_blaze"],
-                "Gaming & Graphics": ["john_carmack", "sid", "shigeru", "gabe", "markus", "jonathan", "casey", "tim_sweeney", "hideo", "will"],
-                "Open Source Leaders": ["miguel", "nat", "patrick", "ian", "mark_shuttleworth", "lennart", "bram", "daniel_r", "judd", "fabrice"],
-                "Modern Innovators": ["vitalik", "satoshi", "chris_lattner", "joe", "jose", "sebastian", "palmer", "dylan", "guillermo", "tom"],
-                "Special Configurations": ["fullstack", "minimal", "data_scientist", "devops", "security", "academic", "startup", "enterprise", "creative", "hanzo"],
+                "Language Creators": [
+                    "guido",
+                    "matz",
+                    "brendan",
+                    "dennis",
+                    "bjarne",
+                    "james",
+                    "anders",
+                    "larry",
+                    "rasmus",
+                    "rich",
+                ],
+                "Systems & Infrastructure": [
+                    "linus",
+                    "rob",
+                    "ken",
+                    "bill",
+                    "richard",
+                    "brian",
+                    "donald",
+                    "graydon",
+                    "ryan",
+                    "mitchell",
+                ],
+                "Web & Frontend": [
+                    "tim",
+                    "douglas",
+                    "john",
+                    "evan",
+                    "jordan",
+                    "jeremy",
+                    "david",
+                    "taylor",
+                    "adrian",
+                    "matt",
+                ],
+                "Database & Data": [
+                    "michael_s",
+                    "michael_w",
+                    "salvatore",
+                    "dwight",
+                    "edgar",
+                    "jim_gray",
+                    "jeff_dean",
+                    "sanjay",
+                    "mike",
+                    "matei",
+                ],
+                "AI & Machine Learning": [
+                    "yann",
+                    "geoffrey",
+                    "yoshua",
+                    "andrew",
+                    "demis",
+                    "ilya",
+                    "andrej",
+                    "chris",
+                    "francois",
+                    "jeremy_howard",
+                ],
+                "Security & Cryptography": [
+                    "bruce",
+                    "phil",
+                    "whitfield",
+                    "ralph",
+                    "daniel_b",
+                    "moxie",
+                    "theo",
+                    "dan_kaminsky",
+                    "katie",
+                    "matt_blaze",
+                ],
+                "Gaming & Graphics": [
+                    "john_carmack",
+                    "sid",
+                    "shigeru",
+                    "gabe",
+                    "markus",
+                    "jonathan",
+                    "casey",
+                    "tim_sweeney",
+                    "hideo",
+                    "will",
+                ],
+                "Open Source Leaders": [
+                    "miguel",
+                    "nat",
+                    "patrick",
+                    "ian",
+                    "mark_shuttleworth",
+                    "lennart",
+                    "bram",
+                    "daniel_r",
+                    "judd",
+                    "fabrice",
+                ],
+                "Modern Innovators": [
+                    "vitalik",
+                    "satoshi",
+                    "chris_lattner",
+                    "joe",
+                    "jose",
+                    "sebastian",
+                    "palmer",
+                    "dylan",
+                    "guillermo",
+                    "tom",
+                ],
+                "Special Configurations": [
+                    "fullstack",
+                    "minimal",
+                    "data_scientist",
+                    "devops",
+                    "security",
+                    "academic",
+                    "startup",
+                    "enterprise",
+                    "creative",
+                    "hanzo",
+                ],
             }
-            
+
             for category, mode_names in categories.items():
                 output.append(f"\n{category}:")
                 for mode_name in mode_names:
                     mode = next((m for m in modes if m.name == mode_name), None)
                     if mode:
-                        marker = " (active)" if active and active.name == mode.name else ""
-                        output.append(f"  {mode.name}{marker}: {mode.programmer} - {mode.description}")
-            
+                        marker = (
+                            " (active)" if active and active.name == mode.name else ""
+                        )
+                        output.append(
+                            f"  {mode.name}{marker}: {mode.programmer} - {mode.description}"
+                        )
+
             output.append("\nUse 'mode --action activate <name>' to activate a mode")
-            
+
             return "\n".join(output)
-        
+
         elif action == "activate":
             if not name:
                 return "Error: Mode name required for activate action"
-            
+
             try:
                 ModeRegistry.set_active(name)
                 mode = ModeRegistry.get(name)
-                
+
                 output = [f"Activated mode: {mode.name}"]
                 output.append(f"Programmer: {mode.programmer}")
                 output.append(f"Description: {mode.description}")
                 if mode.philosophy:
                     output.append(f"Philosophy: {mode.philosophy}")
                 output.append(f"\nEnabled tools ({len(mode.tools)}):")
-                
+
                 # Group tools by category
                 core_tools = []
                 package_tools = []
                 ai_tools = []
                 search_tools = []
                 other_tools = []
-                
+
                 for tool in sorted(mode.tools):
-                    if tool in ["read", "write", "edit", "multi_edit", "bash", "tree", "grep"]:
+                    if tool in [
+                        "read",
+                        "write",
+                        "edit",
+                        "multi_edit",
+                        "bash",
+                        "tree",
+                        "grep",
+                    ]:
                         core_tools.append(tool)
                     elif tool in ["npx", "uvx", "pip", "cargo", "gem"]:
                         package_tools.append(tool)
@@ -117,7 +239,7 @@ mode --action current"""
                         search_tools.append(tool)
                     else:
                         other_tools.append(tool)
-                
+
                 if core_tools:
                     output.append(f"  Core: {', '.join(core_tools)}")
                 if package_tools:
@@ -128,82 +250,80 @@ mode --action current"""
                     output.append(f"  Search: {', '.join(search_tools)}")
                 if other_tools:
                     output.append(f"  Specialized: {', '.join(other_tools)}")
-                
+
                 if mode.environment:
                     output.append("\nEnvironment variables:")
                     for key, value in mode.environment.items():
                         output.append(f"  {key}={value}")
-                
-                output.append("\nNote: Restart MCP session for changes to take full effect")
-                
+
+                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: Mode name required for show action"
-            
+
             mode = ModeRegistry.get(name)
             if not mode:
                 return f"Mode '{name}' not found"
-            
+
             output = [f"Mode: {mode.name}"]
             output.append(f"Programmer: {mode.programmer}")
             output.append(f"Description: {mode.description}")
             if mode.philosophy:
                 output.append(f"Philosophy: {mode.philosophy}")
             output.append(f"\nTools ({len(mode.tools)}):")
-            
+
             for tool in sorted(mode.tools):
                 output.append(f"  - {tool}")
-            
+
             if mode.environment:
                 output.append("\nEnvironment:")
                 for key, value in mode.environment.items():
                     output.append(f"  {key}={value}")
-            
+
             return "\n".join(output)
-        
+
         elif action == "current":
             active = ModeRegistry.get_active()
             if not active:
                 return "No mode currently active\nUse 'mode --action activate <name>' to activate one"
-            
+
             output = [f"Current mode: {active.name}"]
             output.append(f"Programmer: {active.programmer}")
             output.append(f"Description: {active.description}")
             if active.philosophy:
                 output.append(f"Philosophy: {active.philosophy}")
             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 mode_handler(
-            ctx: MCPContext,
-            action: str = "list",
-            name: Optional[str] = None
+            ctx: MCPContext, action: str = "list", name: Optional[str] = None
         ) -> str:
             """Handle mode 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")
+            ctx, action=params.get("action", "list"), name=params.get("name")
         )
 
 
 # Create tool instance
-mode_tool = ModeTool()
+mode_tool = ModeTool()

hanzo_mcp/tools/database/__init__.py

@@ -4,26 +4,28 @@ This package provides tools for working with embedded SQLite databases
 and graph databases in projects.
 """
 
+from mcp.server import FastMCP
+
 from hanzo_mcp.tools.common.base import BaseTool
 from hanzo_mcp.tools.common.permissions import PermissionManager
-from mcp.server import FastMCP
+
+from .graph_add import GraphAddTool
 
 # Import database tools
 from .sql_query import SqlQueryTool
-from .sql_search import SqlSearchTool
 from .sql_stats import SqlStatsTool
-from .graph_add import GraphAddTool
-from .graph_remove import GraphRemoveTool
+from .sql_search import SqlSearchTool
 from .graph_query import GraphQueryTool
-from .graph_search import GraphSearchTool
 from .graph_stats import GraphStatsTool
+from .graph_remove import GraphRemoveTool
+from .graph_search import GraphSearchTool
 from .database_manager import DatabaseManager
 
 __all__ = [
     "register_database_tools",
     "DatabaseManager",
     "SqlQueryTool",
-    "SqlSearchTool", 
+    "SqlSearchTool",
     "SqlStatsTool",
     "GraphAddTool",
     "GraphRemoveTool",
@@ -39,19 +41,19 @@ def register_database_tools(
     db_manager: DatabaseManager | None = None,
 ) -> list[BaseTool]:
     """Register database tools with the MCP server.
-    
+
     Args:
         mcp_server: The FastMCP server instance
         permission_manager: Permission manager for access control
         db_manager: Optional database manager instance
-        
+
     Returns:
         List of registered tools
     """
     # Create database manager if not provided
     if db_manager is None:
         db_manager = DatabaseManager(permission_manager)
-    
+
     # Create tool instances
     tools = [
         SqlQueryTool(permission_manager, db_manager),
@@ -63,9 +65,10 @@ def register_database_tools(
         GraphSearchTool(permission_manager, db_manager),
         GraphStatsTool(permission_manager, db_manager),
     ]
-    
+
     # Register with MCP server
     from hanzo_mcp.tools.common.base import ToolRegistry
+
     ToolRegistry.register_tools(mcp_server, tools)
-    
-    return tools
+
+    return tools