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

hanzo_mcp/tools/common/batch_tool.py

@@ -5,19 +5,18 @@ parallel or serial depending on their characteristics.
 """
 
 import asyncio
-from typing import Annotated, Any, TypedDict, Unpack, final, override
+from typing import Any, Unpack, Annotated, TypedDict, final, override
 
-from mcp.server.fastmcp import Context as MCPContext
-from mcp.server import FastMCP
 from pydantic import Field
+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.context import create_tool_context
-from hanzo_mcp.tools.common.truncate import truncate_response, estimate_tokens
+from hanzo_mcp.tools.common.truncate import truncate_response
 from hanzo_mcp.tools.common.fastmcp_pagination import (
-    create_paginated_response,
     CursorData,
-    TokenAwarePaginator
+    create_paginated_response,
 )
 
 
@@ -197,9 +196,9 @@ Not available: think,write,edit,multi_edit,notebook_edit
 
         # Execute all tool invocations in parallel
         tasks: list[asyncio.Future[dict[str, Any]]] = []
-        invocation_map: dict[
-            asyncio.Future[dict[str, Any]], dict[str, Any]
-        ] = {}  # Map task Future to invocation
+        invocation_map: dict[asyncio.Future[dict[str, Any]], dict[str, Any]] = (
+            {}
+        )  # Map task Future to invocation
 
         for i, invocation in enumerate(invocations):
             # Extract tool name and input from invocation
@@ -290,7 +289,7 @@ Not available: think,write,edit,multi_edit,notebook_edit
         # Extract cursor if provided
         cursor = params.get("cursor")
         cursor_offset = 0
-        
+
         # If cursor provided, we need to resume from where we left off
         if cursor:
             cursor_data = CursorData.from_cursor(cursor)
@@ -298,63 +297,71 @@ Not available: think,write,edit,multi_edit,notebook_edit
                 # Skip already returned results
                 cursor_offset = cursor_data.offset
                 results = results[cursor_offset:]
-        
+
         # Format results
         formatted_results = []
         for i, result in enumerate(results):
             invocation = result["invocation"]
             tool_name = invocation.get("tool_name", "unknown")
-            formatted_results.append({
-                "tool": tool_name,
-                "result": result["result"],
-                "index": i + cursor_offset
-            })
-        
+            formatted_results.append(
+                {
+                    "tool": tool_name,
+                    "result": result["result"],
+                    "index": i + cursor_offset,
+                }
+            )
+
         # Create paginated response with token awareness
         paginated_response = create_paginated_response(
-            formatted_results,
-            cursor=cursor,
-            use_token_limit=True
+            formatted_results, cursor=cursor, use_token_limit=True
         )
-        
+
         # Convert paginated response to string format for MCP
         if isinstance(paginated_response, dict) and "items" in paginated_response:
             # Format the items as a readable string
             result_parts = []
-            
+
             # Add header
             result_parts.append(f"=== Batch operation: {description} ===")
             result_parts.append(f"Total invocations: {len(invocations)}")
-            result_parts.append(f"Showing results: {len(paginated_response['items'])} of {len(results)}")
-            if paginated_response.get('hasMore'):
-                result_parts.append(f"More results available - use cursor: {paginated_response.get('nextCursor')}")
+            result_parts.append(
+                f"Showing results: {len(paginated_response['items'])} of {len(results)}"
+            )
+            if paginated_response.get("hasMore"):
+                result_parts.append(
+                    f"More results available - use cursor: {paginated_response.get('nextCursor')}"
+                )
             result_parts.append("")
-            
+
             # Format each result
-            for item in paginated_response['items']:
+            for item in paginated_response["items"]:
                 result_parts.append(f"### Result {item['index'] + 1}: {item['tool']}")
-                result_content = item['result']
-                
+                result_content = item["result"]
+
                 # Add the result content - use multi-line code blocks for code outputs
                 if isinstance(result_content, str) and "\n" in result_content:
                     result_parts.append(f"```\n{result_content}\n```")
                 else:
                     result_parts.append(str(result_content))
                 result_parts.append("")
-            
+
             # Join all parts
             formatted_output = "\n".join(result_parts)
-            
+
             # If there's a next cursor, we need to preserve it in the response
             # For now, append it as a note at the end
-            if paginated_response.get('hasMore') and paginated_response.get('nextCursor'):
-                formatted_output += f"\n\n[To continue, use cursor: {paginated_response['nextCursor']}]"
-            
+            if paginated_response.get("hasMore") and paginated_response.get(
+                "nextCursor"
+            ):
+                formatted_output += (
+                    f"\n\n[To continue, use cursor: {paginated_response['nextCursor']}]"
+                )
+
             await tool_ctx.info(
                 f"Batch operation '{description}' completed with {len(paginated_response['items'])} results"
                 f"{' (more available)' if paginated_response.get('hasMore') else ''}"
             )
-            
+
             return formatted_output
         else:
             # Fallback if pagination didn't work as expected
@@ -376,16 +383,16 @@ Not available: think,write,edit,multi_edit,notebook_edit
 
             # Add the result header
             formatted_parts.append(f"### Result {i + 1}: {tool_name}")
-            
+
             # Truncate individual results if they're too large
             result_content = result["result"]
             if len(result_content) > 50000:  # If individual result > 50k chars
                 result_content = truncate_response(
                     result_content,
                     max_tokens=5000,  # Limit individual results to ~5k tokens
-                    truncation_message=f"\n\n[Result from {tool_name} truncated. Use the tool directly with pagination/filtering for full output.]"
+                    truncation_message=f"\n\n[Result from {tool_name} truncated. Use the tool directly with pagination/filtering for full output.]",
                 )
-            
+
             # Add the result content - use multi-line code blocks for code outputs
             if "\n" in result_content:
                 formatted_parts.append(f"```\n{result_content}\n```")
@@ -413,7 +420,7 @@ Not available: think,write,edit,multi_edit,notebook_edit
             description: Description,
             invocations: Invocations,
             cursor: Cursor,
-            ctx: MCPContext
+            ctx: MCPContext,
         ) -> str:
             return await tool_self.call(
                 ctx, description=description, invocations=invocations, cursor=cursor

hanzo_mcp/tools/common/config_tool.py

@@ -1,30 +1,27 @@
 """Configuration management tool for dynamic settings updates."""
 
-from typing import Dict, List, Optional, TypedDict, Unpack, Any, final
 import json
-from pathlib import Path
+from typing import Any, Dict, Unpack, Optional, TypedDict, final
 
 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.config.settings import (
-    HanzoMCPSettings, 
-    MCPServerConfig, 
-    ProjectConfig, 
-    load_settings, 
+    ProjectConfig,
+    MCPServerConfig,
+    load_settings,
     save_settings,
     detect_project_from_path,
-    ensure_project_hanzo_dir
 )
+from hanzo_mcp.tools.common.base import BaseTool
+from hanzo_mcp.tools.common.permissions import PermissionManager
 
 
 class ConfigToolParams(TypedDict, total=False):
     """Parameters for configuration management operations."""
-    
+
     action: str  # get, set, add_server, remove_server, add_project, etc.
     scope: Optional[str]  # global, project, current
-    setting_path: Optional[str]  # dot-notation path like "agent.enabled" 
+    setting_path: Optional[str]  # dot-notation path like "agent.enabled"
     value: Optional[Any]  # new value to set
     server_name: Optional[str]  # for MCP server operations
     server_config: Optional[Dict[str, Any]]  # for adding servers
@@ -35,20 +32,20 @@ class ConfigToolParams(TypedDict, total=False):
 @final
 class ConfigTool(BaseTool):
     """Tool for managing Hanzo AI configuration dynamically."""
-    
+
     def __init__(self, permission_manager: PermissionManager):
         """Initialize the configuration tool.
-        
+
         Args:
             permission_manager: Permission manager for access control
         """
         self.permission_manager = permission_manager
-    
+
     @property
     def name(self) -> str:
         """Get the tool name."""
         return "config"
-    
+
     @property
     def description(self) -> str:
         """Get the tool description."""
@@ -64,18 +61,18 @@ Perfect for AI-driven configuration where users can say things like:
 - "Show me the current project configuration"
 
 Automatically detects projects based on LLM.md files and manages .hanzo/ directories."""
-    
+
     async def call(
         self,
         ctx: MCPContext,
         **params: Unpack[ConfigToolParams],
     ) -> str:
         """Manage configuration settings.
-        
+
         Args:
             ctx: MCP context
             **params: Tool parameters
-            
+
         Returns:
             Configuration operation result
         """
@@ -87,14 +84,20 @@ Automatically detects projects based on LLM.md files and manages .hanzo/ directo
         server_config = params.get("server_config")
         project_name = params.get("project_name")
         project_path = params.get("project_path")
-        
+
         try:
             if action == "get":
-                return await self._get_config(scope, setting_path, project_name, project_path)
+                return await self._get_config(
+                    scope, setting_path, project_name, project_path
+                )
             elif action == "set":
-                return await self._set_config(scope, setting_path, value, project_name, project_path)
+                return await self._set_config(
+                    scope, setting_path, value, project_name, project_path
+                )
             elif action == "add_server":
-                return await self._add_mcp_server(server_name, server_config, scope, project_name)
+                return await self._add_mcp_server(
+                    server_name, server_config, scope, project_name
+                )
             elif action == "remove_server":
                 return await self._remove_mcp_server(server_name, scope, project_name)
             elif action == "enable_server":
@@ -115,11 +118,17 @@ Automatically detects projects based on LLM.md files and manages .hanzo/ directo
                 return await self._detect_project(project_path)
             else:
                 return f"Error: Unknown action '{action}'. Available actions: get, set, add_server, remove_server, enable_server, disable_server, trust_server, add_project, set_current_project, list_servers, list_projects, detect_project"
-                
+
         except Exception as e:
             return f"Error managing configuration: {str(e)}"
-    
-    async def _get_config(self, scope: str, setting_path: Optional[str], project_name: Optional[str], project_path: Optional[str]) -> str:
+
+    async def _get_config(
+        self,
+        scope: str,
+        setting_path: Optional[str],
+        project_name: Optional[str],
+        project_path: Optional[str],
+    ) -> str:
         """Get configuration value(s)."""
         # Load appropriate settings
         if scope == "project" or project_name or project_path:
@@ -133,14 +142,14 @@ Automatically detects projects based on LLM.md files and manages .hanzo/ directo
                 settings = load_settings()
         else:
             settings = load_settings()
-        
+
         if not setting_path:
             # Return full config summary
             if scope == "project" and settings.current_project:
                 project = settings.get_current_project()
                 if project:
                     return f"Current Project Configuration ({project.name}):\\n{json.dumps(project.__dict__, indent=2)}"
-            
+
             # Return global config summary
             summary = {
                 "server": settings.server.__dict__,
@@ -149,24 +158,34 @@ Automatically detects projects based on LLM.md files and manages .hanzo/ directo
                 "agent": settings.agent.__dict__,
                 "vector_store": settings.vector_store.__dict__,
                 "hub_enabled": settings.hub_enabled,
-                "mcp_servers": {name: server.__dict__ for name, server in settings.mcp_servers.items()},
+                "mcp_servers": {
+                    name: server.__dict__
+                    for name, server in settings.mcp_servers.items()
+                },
                 "current_project": settings.current_project,
                 "projects": list(settings.projects.keys()),
             }
             return f"Configuration Summary:\\n{json.dumps(summary, indent=2)}"
-        
+
         # Get specific setting
         value = self._get_nested_value(settings.__dict__, setting_path)
         if value is not None:
             return f"{setting_path}: {json.dumps(value, indent=2)}"
         else:
             return f"Setting '{setting_path}' not found"
-    
-    async def _set_config(self, scope: str, setting_path: Optional[str], value: Any, project_name: Optional[str], project_path: Optional[str]) -> str:
+
+    async def _set_config(
+        self,
+        scope: str,
+        setting_path: Optional[str],
+        value: Any,
+        project_name: Optional[str],
+        project_path: Optional[str],
+    ) -> str:
         """Set configuration value."""
         if not setting_path:
             return "Error: setting_path is required for set action"
-        
+
         # Load settings
         project_dir = None
         if scope == "project" or project_name or project_path:
@@ -176,9 +195,9 @@ Automatically detects projects based on LLM.md files and manages .hanzo/ directo
                     project_dir = project_info["root_path"]
                 else:
                     return f"No project detected at path: {project_path}"
-        
+
         settings = load_settings(project_dir)
-        
+
         # Set the value
         if self._set_nested_value(settings.__dict__, setting_path, value):
             # Save settings
@@ -189,14 +208,20 @@ Automatically detects projects based on LLM.md files and manages .hanzo/ directo
             return f"Successfully set {setting_path} = {json.dumps(value)}"
         else:
             return f"Error: Could not set '{setting_path}'"
-    
-    async def _add_mcp_server(self, server_name: Optional[str], server_config: Optional[Dict[str, Any]], scope: str, project_name: Optional[str]) -> str:
+
+    async def _add_mcp_server(
+        self,
+        server_name: Optional[str],
+        server_config: Optional[Dict[str, Any]],
+        scope: str,
+        project_name: Optional[str],
+    ) -> str:
         """Add a new MCP server."""
         if not server_name or not server_config:
             return "Error: server_name and server_config are required"
-        
+
         settings = load_settings()
-        
+
         # Create server config
         mcp_server = MCPServerConfig(
             name=server_name,
@@ -207,95 +232,105 @@ Automatically detects projects based on LLM.md files and manages .hanzo/ directo
             description=server_config.get("description", ""),
             capabilities=server_config.get("capabilities", []),
         )
-        
+
         if settings.add_mcp_server(mcp_server):
             save_settings(settings)
             return f"Successfully added MCP server '{server_name}'"
         else:
             return f"Error: MCP server '{server_name}' already exists"
-    
-    async def _remove_mcp_server(self, server_name: Optional[str], scope: str, project_name: Optional[str]) -> str:
+
+    async def _remove_mcp_server(
+        self, server_name: Optional[str], scope: str, project_name: Optional[str]
+    ) -> str:
         """Remove an MCP server."""
         if not server_name:
             return "Error: server_name is required"
-        
+
         settings = load_settings()
-        
+
         if settings.remove_mcp_server(server_name):
             save_settings(settings)
             return f"Successfully removed MCP server '{server_name}'"
         else:
             return f"Error: MCP server '{server_name}' not found"
-    
-    async def _enable_mcp_server(self, server_name: Optional[str], scope: str, project_name: Optional[str]) -> str:
+
+    async def _enable_mcp_server(
+        self, server_name: Optional[str], scope: str, project_name: Optional[str]
+    ) -> str:
         """Enable an MCP server."""
         if not server_name:
             return "Error: server_name is required"
-        
+
         settings = load_settings()
-        
+
         if settings.enable_mcp_server(server_name):
             save_settings(settings)
             return f"Successfully enabled MCP server '{server_name}'"
         else:
             return f"Error: MCP server '{server_name}' not found"
-    
-    async def _disable_mcp_server(self, server_name: Optional[str], scope: str, project_name: Optional[str]) -> str:
+
+    async def _disable_mcp_server(
+        self, server_name: Optional[str], scope: str, project_name: Optional[str]
+    ) -> str:
         """Disable an MCP server."""
         if not server_name:
             return "Error: server_name is required"
-        
+
         settings = load_settings()
-        
+
         if settings.disable_mcp_server(server_name):
             save_settings(settings)
             return f"Successfully disabled MCP server '{server_name}'"
         else:
             return f"Error: MCP server '{server_name}' not found"
-    
+
     async def _trust_mcp_server(self, server_name: Optional[str]) -> str:
         """Trust an MCP server."""
         if not server_name:
             return "Error: server_name is required"
-        
+
         settings = load_settings()
-        
+
         if settings.trust_mcp_server(server_name):
             save_settings(settings)
             return f"Successfully trusted MCP server '{server_name}'"
         else:
             return f"Error: MCP server '{server_name}' not found"
-    
-    async def _add_project(self, project_name: Optional[str], project_path: Optional[str]) -> str:
+
+    async def _add_project(
+        self, project_name: Optional[str], project_path: Optional[str]
+    ) -> str:
         """Add a project configuration."""
         if not project_path:
             return "Error: project_path is required"
-        
+
         # Detect or create project
         project_info = detect_project_from_path(project_path)
         if not project_info:
             return f"No LLM.md found in project path: {project_path}"
-        
+
         if not project_name:
             project_name = project_info["name"]
-        
+
         settings = load_settings()
-        
+
         project_config = ProjectConfig(
             name=project_name,
             root_path=project_info["root_path"],
         )
-        
+
         if settings.add_project(project_config):
             save_settings(settings)
             return f"Successfully added project '{project_name}' at {project_info['root_path']}"
         else:
             return f"Error: Project '{project_name}' already exists"
-    
-    async def _set_current_project(self, project_name: Optional[str], project_path: Optional[str]) -> str:
+
+    async def _set_current_project(
+        self, project_name: Optional[str], project_path: Optional[str]
+    ) -> str:
         """Set the current active project."""
         settings = load_settings()
-        
+
         if project_path:
             project_info = detect_project_from_path(project_path)
             if project_info:
@@ -304,62 +339,63 @@ Automatically detects projects based on LLM.md files and manages .hanzo/ directo
                 if project_name not in settings.projects:
                     await self._add_project(project_name, project_path)
                     settings = load_settings()  # Reload after adding
-        
+
         if not project_name:
             return "Error: project_name or project_path is required"
-        
+
         if settings.set_current_project(project_name):
             save_settings(settings)
             return f"Successfully set current project to '{project_name}'"
         else:
             return f"Error: Project '{project_name}' not found"
-    
+
     async def _list_mcp_servers(self, scope: str, project_name: Optional[str]) -> str:
         """List MCP servers."""
         settings = load_settings()
-        
+
         if not settings.mcp_servers:
             return "No MCP servers configured"
-        
+
         servers_info = []
         for name, server in settings.mcp_servers.items():
             status = "enabled" if server.enabled else "disabled"
             trust = "trusted" if server.trusted else "untrusted"
             servers_info.append(f"- {name}: {server.command} ({status}, {trust})")
-        
+
         return f"MCP Servers:\\n" + "\\n".join(servers_info)
-    
+
     async def _list_projects(self) -> str:
         """List projects."""
         settings = load_settings()
-        
+
         if not settings.projects:
             return "No projects configured"
-        
+
         projects_info = []
         for name, project in settings.projects.items():
             current = " (current)" if name == settings.current_project else ""
             projects_info.append(f"- {name}: {project.root_path}{current}")
-        
+
         return f"Projects:\\n" + "\\n".join(projects_info)
-    
+
     async def _detect_project(self, project_path: Optional[str]) -> str:
         """Detect project from path."""
         if not project_path:
             import os
+
             project_path = os.getcwd()
-        
+
         project_info = detect_project_from_path(project_path)
         if project_info:
             return f"Project detected:\\n{json.dumps(project_info, indent=2)}"
         else:
             return f"No project detected at path: {project_path}"
-    
+
     def _get_nested_value(self, obj: Dict[str, Any], path: str) -> Any:
         """Get nested value using dot notation."""
         keys = path.split(".")
         current = obj
-        
+
         for key in keys:
             if isinstance(current, dict) and key in current:
                 current = current[key]
@@ -367,14 +403,14 @@ Automatically detects projects based on LLM.md files and manages .hanzo/ directo
                 current = getattr(current, key)
             else:
                 return None
-        
+
         return current
-    
+
     def _set_nested_value(self, obj: Dict[str, Any], path: str, value: Any) -> bool:
         """Set nested value using dot notation."""
         keys = path.split(".")
         current = obj
-        
+
         # Navigate to parent
         for key in keys[:-1]:
             if isinstance(current, dict) and key in current:
@@ -383,7 +419,7 @@ Automatically detects projects based on LLM.md files and manages .hanzo/ directo
                 current = getattr(current, key)
             else:
                 return False
-        
+
         # Set final value
         final_key = keys[-1]
         if isinstance(current, dict):
@@ -392,5 +428,5 @@ Automatically detects projects based on LLM.md files and manages .hanzo/ directo
         elif hasattr(current, final_key):
             setattr(current, final_key, value)
             return True
-        
-        return False
+
+        return False

hanzo_mcp/tools/common/context.py

@@ -4,12 +4,8 @@ This module provides an enhanced Context class that wraps the MCP Context
 and adds additional functionality specific to Hanzo tools.
 """
 
-import json
-import os
-import time
+from typing import ClassVar, final
 from collections.abc import Iterable
-from pathlib import Path
-from typing import Any, ClassVar, final
 
 from mcp.server.fastmcp import Context as MCPContext
 from mcp.server.lowlevel.helper_types import ReadResourceContents

hanzo_mcp/tools/common/context_fix.py

@@ -9,18 +9,20 @@ DEPRECATED: Use hanzo_mcp.tools.common.decorators directly.
 # Re-export for backward compatibility
 from hanzo_mcp.tools.common.decorators import (
     MockContext,
-    with_context_normalization,
     _is_valid_context as is_valid_context,
+    with_context_normalization,
 )
 
+
 # Backward compatibility function
 def normalize_context(ctx):
     """Normalize context - backward compatibility wrapper.
-    
+
     DEPRECATED: Use decorators.with_context_normalization instead.
     """
     if is_valid_context(ctx):
         return ctx
     return MockContext()
 
-__all__ = ['MockContext', 'normalize_context', 'with_context_normalization']
+
+__all__ = ["MockContext", "normalize_context", "with_context_normalization"]