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

hanzo_mcp/tools/common/tool_enable.py

@@ -1,16 +1,15 @@
 """Enable tools dynamically."""
 
 import json
-from typing import Annotated, TypedDict, Unpack, final, override
+from typing import Unpack, Annotated, TypedDict, final, override
 from pathlib import Path
 
-from mcp.server.fastmcp import Context as MCPContext
 from pydantic import Field
+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
 
-
 ToolName = Annotated[
     str,
     Field(
@@ -38,7 +37,7 @@ class ToolEnableParams(TypedDict, total=False):
 @final
 class ToolEnableTool(BaseTool):
     """Tool for enabling other tools dynamically."""
-    
+
     # Class variable to track enabled/disabled tools
     _tool_states = {}
     _config_file = Path.home() / ".hanzo" / "mcp" / "tool_states.json"
@@ -55,7 +54,7 @@ class ToolEnableTool(BaseTool):
         """Load tool states from config file."""
         if cls._config_file.exists():
             try:
-                with open(cls._config_file, 'r') as f:
+                with open(cls._config_file, "r") as f:
                     cls._tool_states = json.load(f)
             except Exception:
                 cls._tool_states = {}
@@ -67,16 +66,16 @@ class ToolEnableTool(BaseTool):
     def _save_states(cls):
         """Save tool states to config file."""
         cls._config_file.parent.mkdir(parents=True, exist_ok=True)
-        with open(cls._config_file, 'w') as f:
+        with open(cls._config_file, "w") as f:
             json.dump(cls._tool_states, f, indent=2)
 
     @classmethod
     def is_tool_enabled(cls, tool_name: str) -> bool:
         """Check if a tool is enabled.
-        
+
         Args:
             tool_name: Name of the tool
-            
+
         Returns:
             True if enabled (default), False if explicitly disabled
         """
@@ -84,7 +83,7 @@ class ToolEnableTool(BaseTool):
         if not cls._initialized:
             cls._load_states()
             cls._initialized = True
-        
+
         # Default to enabled if not in states
         return cls._tool_states.get(tool_name, True)
 
@@ -146,13 +145,13 @@ Use 'tool_list' to see all available tools and their status.
 
         # Check current state
         was_enabled = self.is_tool_enabled(tool_name)
-        
+
         if was_enabled:
             return f"Tool '{tool_name}' is already enabled."
 
         # Enable the tool
         self._tool_states[tool_name] = True
-        
+
         # Persist if requested
         if persist:
             self._save_states()
@@ -165,16 +164,16 @@ Use 'tool_list' to see all available tools and their status.
             "",
             "The tool is now available for use.",
         ]
-        
+
         if not persist:
             output.append("Note: This change is temporary and will be lost on restart.")
-        
+
         # Count enabled/disabled tools
         disabled_count = sum(1 for enabled in self._tool_states.values() if not enabled)
         if disabled_count > 0:
             output.append(f"\nCurrently disabled tools: {disabled_count}")
             output.append("Use 'tool_list --disabled' to see them.")
-        
+
         return "\n".join(output)
 
     def register(self, mcp_server) -> None:

hanzo_mcp/tools/common/tool_list.py

@@ -1,15 +1,14 @@
 """List all available tools and their status."""
 
-from typing import Annotated, TypedDict, Unpack, final, override, Optional
+from typing import Unpack, Optional, Annotated, TypedDict, final, override
 
-from mcp.server.fastmcp import Context as MCPContext
 from pydantic import Field
+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
 from hanzo_mcp.tools.common.tool_enable import ToolEnableTool
 
-
 ShowDisabled = Annotated[
     bool,
     Field(
@@ -46,7 +45,7 @@ class ToolListParams(TypedDict, total=False):
 @final
 class ToolListTool(BaseTool):
     """Tool for listing all available tools and their status."""
-    
+
     # Tool information organized by category
     TOOL_INFO = {
         "filesystem": [
@@ -80,7 +79,10 @@ class ToolListTool(BaseTool):
             ("llm", "LLM interface (query/consensus/list/models/enable/disable)"),
             ("agent", "AI agents (run/start/call/stop/list with A2A support)"),
             ("swarm", "Parallel agent execution across multiple files"),
-            ("hierarchical_swarm", "Hierarchical agent teams with Claude Code integration"),
+            (
+                "hierarchical_swarm",
+                "Hierarchical agent teams with Claude Code integration",
+            ),
             ("mcp", "MCP servers (list/add/remove/enable/disable/restart)"),
         ],
         "config": [
@@ -171,7 +173,7 @@ Use 'tool_enable' and 'tool_disable' to change tool status.
             List of tools and their status
         """
         tool_ctx = create_tool_context(ctx)
-        await tool_ctx.set_tool_info(self.name)
+        tool_ctx.set_tool_info(self.name)
 
         # Extract parameters
         show_disabled = params.get("show_disabled", False)
@@ -180,9 +182,9 @@ Use 'tool_enable' and 'tool_disable' to change tool status.
 
         # Get all tool states
         all_states = ToolEnableTool.get_all_states()
-        
+
         output = []
-        
+
         # Header
         if show_disabled:
             output.append("=== Disabled Tools ===")
@@ -190,56 +192,62 @@ Use 'tool_enable' and 'tool_disable' to change tool status.
             output.append("=== Enabled Tools ===")
         else:
             output.append("=== All Available Tools ===")
-        
+
         if category_filter:
             output.append(f"Category: {category_filter}")
-        
+
         output.append("")
-        
+
         # Count statistics
         total_tools = 0
         disabled_count = 0
         shown_count = 0
-        
+
         # Iterate through categories
-        categories = [category_filter] if category_filter and category_filter in self.TOOL_INFO else self.TOOL_INFO.keys()
-        
+        categories = (
+            [category_filter]
+            if category_filter and category_filter in self.TOOL_INFO
+            else self.TOOL_INFO.keys()
+        )
+
         for category in categories:
             if category not in self.TOOL_INFO:
                 continue
-                
+
             category_tools = self.TOOL_INFO[category]
             category_shown = []
-            
+
             for tool_name, description in category_tools:
                 total_tools += 1
                 is_enabled = ToolEnableTool.is_tool_enabled(tool_name)
-                
+
                 if not is_enabled:
                     disabled_count += 1
-                
+
                 # Apply filters
                 if show_disabled and is_enabled:
                     continue
                 if show_enabled and not is_enabled:
                     continue
-                
+
                 status = "✅" if is_enabled else "❌"
                 category_shown.append((tool_name, description, status))
                 shown_count += 1
-            
+
             # Show category if it has tools
             if category_shown:
                 output.append(f"=== {category.title()} Tools ===")
-                
+
                 # Find max tool name length for alignment
                 max_name_len = max(len(name) for name, _, _ in category_shown)
-                
+
                 for tool_name, description, status in category_shown:
-                    output.append(f"{status} {tool_name.ljust(max_name_len)} - {description}")
-                
+                    output.append(
+                        f"{status} {tool_name.ljust(max_name_len)} - {description}"
+                    )
+
                 output.append("")
-        
+
         # Summary
         if not show_disabled and not show_enabled:
             output.append("=== Summary ===")
@@ -248,14 +256,14 @@ Use 'tool_enable' and 'tool_disable' to change tool status.
             output.append(f"Disabled: {disabled_count}")
         else:
             output.append(f"Showing {shown_count} tool(s)")
-        
+
         if disabled_count > 0 and not show_disabled:
             output.append("\nUse 'tool_list --show-disabled' to see disabled tools.")
             output.append("Use 'tool_enable --tool <name>' to enable a tool.")
-        
+
         if show_disabled:
             output.append("\nUse 'tool_enable --tool <name>' to enable these tools.")
-        
+
         return "\n".join(output)
 
     def register(self, mcp_server) -> None:

hanzo_mcp/tools/common/truncate.py

@@ -8,11 +8,11 @@ import tiktoken
 
 def estimate_tokens(text: str, model: str = "gpt-4") -> int:
     """Estimate the number of tokens in a text string.
-    
+
     Args:
         text: The text to estimate tokens for
         model: The model to use for token estimation (default: gpt-4)
-        
+
     Returns:
         Estimated number of tokens
     """
@@ -22,80 +22,80 @@ def estimate_tokens(text: str, model: str = "gpt-4") -> int:
     except KeyError:
         # Fall back to cl100k_base which is used by newer models
         encoding = tiktoken.get_encoding("cl100k_base")
-    
+
     return len(encoding.encode(text))
 
 
 def truncate_response(
-    response: str, 
+    response: str,
     max_tokens: int = 20000,
-    truncation_message: str = "\n\n[Response truncated due to length. Please use pagination, filtering, or limit parameters to see more.]"
+    truncation_message: str = "\n\n[Response truncated due to length. Please use pagination, filtering, or limit parameters to see more.]",
 ) -> str:
     """Truncate a response to fit within token limits.
-    
+
     Args:
         response: The response text to truncate
         max_tokens: Maximum number of tokens allowed (default: 20000)
         truncation_message: Message to append when truncating
-        
+
     Returns:
         Truncated response if needed, original response otherwise
     """
     # Quick check - if response is short, no need to count tokens
     if len(response) < max_tokens * 2:  # Rough estimate: 1 token ≈ 2-4 chars
         return response
-    
+
     # Estimate tokens
     token_count = estimate_tokens(response)
-    
+
     # If within limit, return as-is
     if token_count <= max_tokens:
         return response
-    
+
     # Need to truncate
     # Binary search to find the right truncation point
     left, right = 0, len(response)
     truncation_msg_tokens = estimate_tokens(truncation_message)
     target_tokens = max_tokens - truncation_msg_tokens
-    
+
     while left < right - 1:
         mid = (left + right) // 2
         mid_tokens = estimate_tokens(response[:mid])
-        
+
         if mid_tokens <= target_tokens:
             left = mid
         else:
             right = mid
-    
+
     # Find a good break point (newline or space)
     truncate_at = left
     for i in range(min(100, left), -1, -1):
-        if response[left - i] in '\n ':
+        if response[left - i] in "\n ":
             truncate_at = left - i
             break
-    
+
     return response[:truncate_at] + truncation_message
 
 
 def truncate_lines(
     response: str,
     max_lines: int = 1000,
-    truncation_message: str = "\n\n[Response truncated to {max_lines} lines. Please use pagination or filtering to see more.]"
+    truncation_message: str = "\n\n[Response truncated to {max_lines} lines. Please use pagination or filtering to see more.]",
 ) -> str:
     """Truncate a response by number of lines.
-    
+
     Args:
         response: The response text to truncate
         max_lines: Maximum number of lines allowed (default: 1000)
         truncation_message: Message template to append when truncating
-        
+
     Returns:
         Truncated response if needed, original response otherwise
     """
-    lines = response.split('\n')
-    
+    lines = response.split("\n")
+
     if len(lines) <= max_lines:
         return response
-    
-    truncated = '\n'.join(lines[:max_lines])
-    return truncated + truncation_message.format(max_lines=max_lines)
+
+    truncated = "\n".join(lines[:max_lines])
+    return truncated + truncation_message.format(max_lines=max_lines)

hanzo_mcp/tools/config/__init__.py

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

hanzo_mcp/tools/config/config_tool.py

@@ -3,17 +3,14 @@
 Git-style config tool for managing settings.
 """
 
-from typing import Annotated, TypedDict, Unpack, final, override, Optional, Dict, Any
-from pathlib import Path
-import json
+from typing import Unpack, Optional, Annotated, TypedDict, final, override
 
-from mcp.server.fastmcp import Context as MCPContext
 from pydantic import Field
+from mcp.server.fastmcp import Context as MCPContext
 
 from hanzo_mcp.tools.common.base import BaseTool
 from hanzo_mcp.tools.common.permissions import PermissionManager
-from hanzo_mcp.tools.config.index_config import IndexConfig, IndexScope
-
+from hanzo_mcp.tools.config.index_config import IndexScope, IndexConfig
 
 # Parameter types
 Action = Annotated[
@@ -59,6 +56,7 @@ ConfigPath = Annotated[
 
 class ConfigParams(TypedDict, total=False):
     """Parameters for config tool."""
+
     action: str
     key: Optional[str]
     value: Optional[str]
@@ -69,7 +67,7 @@ class ConfigParams(TypedDict, total=False):
 @final
 class ConfigTool(BaseTool):
     """Git-style configuration management tool."""
-    
+
     def __init__(self, permission_manager: PermissionManager):
         """Initialize config tool."""
         super().__init__(permission_manager)
@@ -101,14 +99,14 @@ config --action toggle index.scope --path ./project"""
     ) -> str:
         """Execute config operation."""
         tool_ctx = self.create_tool_context(ctx)
-        
+
         # Extract parameters
         action = params.get("action", "get")
         key = params.get("key")
         value = params.get("value")
         scope = params.get("scope", "local")
         path = params.get("path")
-        
+
         # Route to handler
         if action == "get":
             return await self._handle_get(key, scope, path, tool_ctx)
@@ -121,41 +119,52 @@ config --action toggle index.scope --path ./project"""
         else:
             return f"Error: Unknown action '{action}'. Valid actions: get, set, list, toggle"
 
-    async def _handle_get(self, key: Optional[str], scope: str, path: Optional[str], tool_ctx) -> str:
+    async def _handle_get(
+        self, key: Optional[str], scope: str, path: Optional[str], tool_ctx
+    ) -> str:
         """Get configuration value."""
         if not key:
             return "Error: key required for get action"
-            
+
         # Handle index scope
         if key == "index.scope":
             current_scope = self.index_config.get_scope(path)
             return f"index.scope={current_scope.value}"
-            
+
         # Handle tool-specific settings
         if "." in key:
             tool, setting = key.split(".", 1)
             if setting == "enabled":
                 enabled = self.index_config.is_indexing_enabled(tool)
                 return f"{key}={enabled}"
-                
+
         return f"Unknown key: {key}"
 
-    async def _handle_set(self, key: Optional[str], value: Optional[str], scope: str, path: Optional[str], tool_ctx) -> str:
+    async def _handle_set(
+        self,
+        key: Optional[str],
+        value: Optional[str],
+        scope: str,
+        path: Optional[str],
+        tool_ctx,
+    ) -> str:
         """Set configuration value."""
         if not key:
             return "Error: key required for set action"
         if not value:
             return "Error: value required for set action"
-            
+
         # Handle index scope
         if key == "index.scope":
             try:
                 new_scope = IndexScope(value)
-                self.index_config.set_scope(new_scope, path if scope == "local" else None)
+                self.index_config.set_scope(
+                    new_scope, path if scope == "local" else None
+                )
                 return f"Set {key}={value} ({'project' if path else 'global'})"
             except ValueError:
                 return f"Error: Invalid scope value '{value}'. Valid: project, global, auto"
-                
+
         # Handle tool-specific settings
         if "." in key:
             tool, setting = key.split(".", 1)
@@ -163,40 +172,44 @@ config --action toggle index.scope --path ./project"""
                 enabled = value.lower() in ["true", "yes", "1", "on"]
                 self.index_config.set_indexing_enabled(tool, enabled)
                 return f"Set {key}={enabled}"
-                
+
         return f"Unknown key: {key}"
 
     async def _handle_list(self, scope: str, path: Optional[str], tool_ctx) -> str:
         """List all configuration."""
         status = self.index_config.get_status()
-        
+
         output = ["=== Configuration ==="]
         output.append(f"\nDefault scope: {status['default_scope']}")
-        
+
         if path:
             current_scope = self.index_config.get_scope(path)
             output.append(f"Current path scope: {current_scope.value}")
-            
+
         output.append(f"\nProjects with custom config: {status['project_count']}")
-        
+
         output.append("\nTool settings:")
         for tool, settings in status["tools"].items():
             output.append(f"  {tool}:")
             output.append(f"    enabled: {settings['enabled']}")
             output.append(f"    per_project: {settings['per_project']}")
-            
+
         return "\n".join(output)
 
-    async def _handle_toggle(self, key: Optional[str], scope: str, path: Optional[str], tool_ctx) -> str:
+    async def _handle_toggle(
+        self, key: Optional[str], scope: str, path: Optional[str], tool_ctx
+    ) -> str:
         """Toggle configuration value."""
         if not key:
             return "Error: key required for toggle action"
-            
+
         # Handle index scope toggle
         if key == "index.scope":
-            new_scope = self.index_config.toggle_scope(path if scope == "local" else None)
+            new_scope = self.index_config.toggle_scope(
+                path if scope == "local" else None
+            )
             return f"Toggled index.scope to {new_scope.value}"
-            
+
         # Handle tool enable/disable toggle
         if "." in key:
             tool, setting = key.split(".", 1)
@@ -204,9 +217,9 @@ config --action toggle index.scope --path ./project"""
                 current = self.index_config.is_indexing_enabled(tool)
                 self.index_config.set_indexing_enabled(tool, not current)
                 return f"Toggled {key} to {not current}"
-                
+
         return f"Cannot toggle key: {key}"
 
     def register(self, mcp_server) -> None:
         """Register this tool with the MCP server."""
-        pass
+        pass