hanzo-mcp 0.8.11__py3-none-any.whl → 0.8.13__py3-none-any.whl

hanzo_mcp/tools/common/mode.py

@@ -94,11 +94,7 @@ def register_default_modes():
 def get_mode_from_env() -> Optional[str]:
     """Get mode name from environment variables."""
     # Check for HANZO_MODE, PERSONALITY, or MODE env vars
-    return (
-        os.environ.get("HANZO_MODE")
-        or os.environ.get("PERSONALITY")
-        or os.environ.get("MODE")
-    )
+    return os.environ.get("HANZO_MODE") or os.environ.get("PERSONALITY") or os.environ.get("MODE")
 
 
 def activate_mode_from_env():

hanzo_mcp/tools/common/paginated_base.py

@@ -68,11 +68,7 @@ class PaginatedBaseTool(BaseTool):
         if cursor:
             # For continuation, check if we have cached results
             cursor_data = CursorManager.parse_cursor(cursor)
-            if (
-                cursor_data
-                and "tool" in cursor_data
-                and cursor_data["tool"] != self.name
-            ):
+            if cursor_data and "tool" in cursor_data and cursor_data["tool"] != self.name:
                 return {"error": "Cursor is for a different tool", "code": -32602}
 
         # Execute the tool
@@ -90,15 +86,11 @@ class PaginatedBaseTool(BaseTool):
             if isinstance(paginated_result, dict) and "nextCursor" in paginated_result:
                 # Enhance the cursor with tool information
                 if "nextCursor" in paginated_result:
-                    cursor_data = CursorManager.parse_cursor(
-                        paginated_result["nextCursor"]
-                    )
+                    cursor_data = CursorManager.parse_cursor(paginated_result["nextCursor"])
                     if cursor_data:
                         cursor_data["tool"] = self.name
                         cursor_data["params"] = params  # Store params for continuation
-                        paginated_result["nextCursor"] = CursorManager.create_cursor(
-                            cursor_data
-                        )
+                        paginated_result["nextCursor"] = CursorManager.create_cursor(cursor_data)
 
             return paginated_result
         else:

hanzo_mcp/tools/common/paginated_response.py

@@ -35,31 +35,21 @@ class AutoPaginatedResponse:
         """
         # Handle different content types
         if isinstance(content, str):
-            return AutoPaginatedResponse._handle_string_response(
-                content, cursor, max_tokens
-            )
+            return AutoPaginatedResponse._handle_string_response(content, cursor, max_tokens)
         elif isinstance(content, list):
-            return AutoPaginatedResponse._handle_list_response(
-                content, cursor, max_tokens
-            )
+            return AutoPaginatedResponse._handle_list_response(content, cursor, max_tokens)
         elif isinstance(content, dict):
             # If dict already has pagination info, return as-is
             if "nextCursor" in content or "cursor" in content:
                 return content
             # Otherwise treat as single item
-            return AutoPaginatedResponse._handle_dict_response(
-                content, cursor, max_tokens
-            )
+            return AutoPaginatedResponse._handle_dict_response(content, cursor, max_tokens)
         else:
             # Convert to string for other types
-            return AutoPaginatedResponse._handle_string_response(
-                str(content), cursor, max_tokens
-            )
+            return AutoPaginatedResponse._handle_string_response(str(content), cursor, max_tokens)
 
     @staticmethod
-    def _handle_string_response(
-        content: str, cursor: Optional[str], max_tokens: int
-    ) -> Dict[str, Any]:
+    def _handle_string_response(content: str, cursor: Optional[str], max_tokens: int) -> Dict[str, Any]:
         """Handle pagination for string responses."""
         # Parse cursor to get offset
         offset = 0
@@ -124,9 +114,7 @@ class AutoPaginatedResponse:
         return response
 
     @staticmethod
-    def _handle_list_response(
-        items: List[Any], cursor: Optional[str], max_tokens: int
-    ) -> Dict[str, Any]:
+    def _handle_list_response(items: List[Any], cursor: Optional[str], max_tokens: int) -> Dict[str, Any]:
         """Handle pagination for list responses."""
         # Parse cursor to get offset
         offset = 0
@@ -164,9 +152,7 @@ class AutoPaginatedResponse:
                         truncated = item[:5000] + "... [truncated]"
                         result_items.append(truncated)
                     else:
-                        result_items.append(
-                            {"error": "Item too large", "index": item_index}
-                        )
+                        result_items.append({"error": "Item too large", "index": item_index})
                     item_index += 1
                 break
 
@@ -199,9 +185,7 @@ class AutoPaginatedResponse:
         return response
 
     @staticmethod
-    def _handle_dict_response(
-        content: Dict[str, Any], cursor: Optional[str], max_tokens: int
-    ) -> Dict[str, Any]:
+    def _handle_dict_response(content: Dict[str, Any], cursor: Optional[str], max_tokens: int) -> Dict[str, Any]:
         """Handle pagination for dict responses."""
         # For dicts, check if it's too large as-is
         content_str = json.dumps(content, indent=2)
@@ -280,17 +264,13 @@ def paginate_if_needed(
         Original response if small enough, otherwise paginated dict
     """
     # Quick check - if response is already paginated, return as-is
-    if isinstance(response, dict) and (
-        "nextCursor" in response or "pagination_info" in response
-    ):
+    if isinstance(response, dict) and ("nextCursor" in response or "pagination_info" in response):
         return response
 
     # For small responses, don't paginate unless forced
     if not force_pagination:
         try:
-            response_str = (
-                json.dumps(response) if not isinstance(response, str) else response
-            )
+            response_str = json.dumps(response) if not isinstance(response, str) else response
             if len(response_str) < 10000:  # Quick heuristic
                 return response
         except Exception:

hanzo_mcp/tools/common/pagination.py

@@ -154,9 +154,7 @@ class StreamPaginator(Generic[T]):
         """
         self.page_size = page_size
 
-    def paginate_stream(
-        self, stream_generator, cursor: Optional[str] = None
-    ) -> PaginatedResponse[T]:
+    def paginate_stream(self, stream_generator, cursor: Optional[str] = None) -> PaginatedResponse[T]:
         """Paginate results from a stream/generator.
 
         Args:
@@ -185,18 +183,14 @@ class StreamPaginator(Generic[T]):
             items.append(item)
             if len(items) >= self.page_size:
                 # We have a full page, create cursor for next page
-                next_cursor = CursorManager.create_cursor(
-                    {"skip": skip_count + len(items)}
-                )
+                next_cursor = CursorManager.create_cursor({"skip": skip_count + len(items)})
                 return PaginatedResponse(items=items, next_cursor=next_cursor)
 
         # No more items
         return PaginatedResponse(items=items, next_cursor=None)
 
 
-def paginate_list(
-    items: List[T], cursor: Optional[str] = None, page_size: int = 100
-) -> PaginatedResponse[T]:
+def paginate_list(items: List[T], cursor: Optional[str] = None, page_size: int = 100) -> PaginatedResponse[T]:
     """Convenience function to paginate a list.
 
     Args:

hanzo_mcp/tools/common/permissions.py

@@ -225,13 +225,9 @@ class PermissibleOperation:
         """
         self.permission_manager: PermissionManager = permission_manager
         self.operation: str = operation
-        self.get_path_fn: Callable[[list[Any], dict[str, Any]], str] | None = (
-            get_path_fn
-        )
+        self.get_path_fn: Callable[[list[Any], dict[str, Any]], str] | None = get_path_fn
 
-    def __call__(
-        self, func: Callable[..., Awaitable[T]]
-    ) -> Callable[..., Awaitable[T]]:
+    def __call__(self, func: Callable[..., Awaitable[T]]) -> Callable[..., Awaitable[T]]:
         """Decorate the function.
 
         Args:
@@ -255,9 +251,7 @@ class PermissibleOperation:
 
             # Check permission
             if not self.permission_manager.is_path_allowed(path):
-                raise PermissionError(
-                    f"Operation '{self.operation}' not allowed for path: {path}"
-                )
+                raise PermissionError(f"Operation '{self.operation}' not allowed for path: {path}")
 
             # Call the function
             return await func(*args, **kwargs)

hanzo_mcp/tools/common/personality.py

@@ -88,10 +88,7 @@ personalities = [
         programmer="Guido van Rossum",
         description="Python's BDFL - readability counts",
         philosophy="There should be one-- and preferably only one --obvious way to do it.",
-        tools=ESSENTIAL_TOOLS
-        + ["uvx", "jupyter", "multi_edit", "symbols", "rules"]
-        + AI_TOOLS
-        + SEARCH_TOOLS,
+        tools=ESSENTIAL_TOOLS + ["uvx", "jupyter", "multi_edit", "symbols", "rules"] + AI_TOOLS + SEARCH_TOOLS,
         environment={"PYTHONPATH": ".", "PYTEST_ARGS": "-xvs"},
     ),
     ToolPersonality(
@@ -107,10 +104,7 @@ personalities = [
         programmer="Brendan Eich",
         description="JavaScript creator - dynamic and flexible",
         philosophy="Always bet on JS.",
-        tools=ESSENTIAL_TOOLS
-        + ["npx", "watch", "symbols", "todo", "rules"]
-        + BUILD_TOOLS
-        + SEARCH_TOOLS,
+        tools=ESSENTIAL_TOOLS + ["npx", "watch", "symbols", "todo", "rules"] + BUILD_TOOLS + SEARCH_TOOLS,
         environment={"NODE_ENV": "development", "NPM_CONFIG_LOGLEVEL": "warn"},
     ),
     ToolPersonality(
@@ -126,10 +120,7 @@ personalities = [
         programmer="Bjarne Stroustrup",
         description="C++ creator - zero-overhead abstractions",
         philosophy="C++ is designed to allow you to express ideas.",
-        tools=ESSENTIAL_TOOLS
-        + ["symbols", "multi_edit", "content_replace"]
-        + UNIX_TOOLS
-        + BUILD_TOOLS,
+        tools=ESSENTIAL_TOOLS + ["symbols", "multi_edit", "content_replace"] + UNIX_TOOLS + BUILD_TOOLS,
         environment={"CXX": "g++", "CXXFLAGS": "-std=c++20 -Wall"},
     ),
     ToolPersonality(
@@ -145,10 +136,7 @@ personalities = [
         programmer="Anders Hejlsberg",
         description="TypeScript/C# creator - type safety matters",
         philosophy="TypeScript is JavaScript that scales.",
-        tools=ESSENTIAL_TOOLS
-        + ["npx", "symbols", "watch", "rules"]
-        + BUILD_TOOLS
-        + SEARCH_TOOLS,
+        tools=ESSENTIAL_TOOLS + ["npx", "symbols", "watch", "rules"] + BUILD_TOOLS + SEARCH_TOOLS,
         environment={"TYPESCRIPT_VERSION": "5.0"},
     ),
     ToolPersonality(
@@ -181,9 +169,7 @@ personalities = [
         programmer="Linus Torvalds",
         description="Linux & Git creator - pragmatic excellence",
         philosophy="Talk is cheap. Show me the code.",
-        tools=ESSENTIAL_TOOLS
-        + ["git_search", "diff", "content_replace", "critic"]
-        + UNIX_TOOLS,
+        tools=ESSENTIAL_TOOLS + ["git_search", "diff", "content_replace", "critic"] + UNIX_TOOLS,
         environment={"KERNEL_VERSION": "6.0", "GIT_AUTHOR_NAME": "Linus Torvalds"},
     ),
     ToolPersonality(
@@ -191,10 +177,7 @@ personalities = [
         programmer="Rob Pike",
         description="Go creator - simplicity and concurrency",
         philosophy="A little copying is better than a little dependency.",
-        tools=ESSENTIAL_TOOLS
-        + ["symbols", "batch", "process"]
-        + UNIX_TOOLS
-        + BUILD_TOOLS,
+        tools=ESSENTIAL_TOOLS + ["symbols", "batch", "process"] + UNIX_TOOLS + BUILD_TOOLS,
         environment={"GOPATH": "~/go", "GO111MODULE": "on"},
     ),
     ToolPersonality(
@@ -242,9 +225,7 @@ personalities = [
         programmer="Graydon Hoare",
         description="Rust creator - memory safety without GC",
         philosophy="Memory safety without garbage collection, concurrency without data races.",
-        tools=ESSENTIAL_TOOLS
-        + ["symbols", "multi_edit", "critic", "todo"]
-        + BUILD_TOOLS,
+        tools=ESSENTIAL_TOOLS + ["symbols", "multi_edit", "critic", "todo"] + BUILD_TOOLS,
         environment={"RUST_BACKTRACE": "1", "CARGO_HOME": "~/.cargo"},
     ),
     ToolPersonality(
@@ -871,10 +852,7 @@ personalities = [
         programmer="Data Scientist",
         description="Analyze all the things",
         philosophy="In God we trust. All others must bring data.",
-        tools=ESSENTIAL_TOOLS
-        + ["jupyter", "sql_query", "stats"]
-        + VECTOR_TOOLS
-        + AI_TOOLS,
+        tools=ESSENTIAL_TOOLS + ["jupyter", "sql_query", "stats"] + VECTOR_TOOLS + AI_TOOLS,
         environment={"JUPYTER_THEME": "dark"},
     ),
     ToolPersonality(
@@ -906,10 +884,7 @@ personalities = [
         programmer="Startup Founder",
         description="Move fast and fix things",
         philosophy="Done is better than perfect.",
-        tools=ESSENTIAL_TOOLS
-        + ["todo", "agent", "consensus"]
-        + BUILD_TOOLS
-        + DATABASE_TOOLS,
+        tools=ESSENTIAL_TOOLS + ["todo", "agent", "consensus"] + BUILD_TOOLS + DATABASE_TOOLS,
         environment={"STARTUP_MODE": "hustle"},
     ),
     ToolPersonality(

hanzo_mcp/tools/common/plugin_loader.py

@@ -88,12 +88,7 @@ class PluginLoader:
 
         # Find tool classes
         for _name, obj in inspect.getmembers(module):
-            if (
-                inspect.isclass(obj)
-                and issubclass(obj, BaseTool)
-                and obj != BaseTool
-                and hasattr(obj, "name")
-            ):
+            if inspect.isclass(obj) and issubclass(obj, BaseTool) and obj != BaseTool and hasattr(obj, "name"):
                 # Load metadata if available
                 metadata = None
                 metadata_file = file_path.with_suffix(".json")
@@ -134,15 +129,8 @@ class PluginLoader:
             else:
                 # Search for tool classes
                 for _name, obj in inspect.getmembers(module):
-                    if (
-                        inspect.isclass(obj)
-                        and issubclass(obj, BaseTool)
-                        and obj != BaseTool
-                        and hasattr(obj, "name")
-                    ):
-                        plugin = ToolPlugin(
-                            name=obj.name, tool_class=obj, source_path=package_dir
-                        )
+                    if inspect.isclass(obj) and issubclass(obj, BaseTool) and obj != BaseTool and hasattr(obj, "name"):
+                        plugin = ToolPlugin(name=obj.name, tool_class=obj, source_path=package_dir)
                         self.plugins[obj.name] = plugin
         finally:
             # Remove from path

hanzo_mcp/tools/common/stats.py

@@ -97,9 +97,7 @@ Example:
         memory_used_gb = memory.used / (1024**3)
         memory_total_gb = memory.total / (1024**3)
         memory_percent = memory.percent
-        output.append(
-            f"Memory: {memory_used_gb:.1f}/{memory_total_gb:.1f} GB ({memory_percent}%)"
-        )
+        output.append(f"Memory: {memory_used_gb:.1f}/{memory_total_gb:.1f} GB ({memory_percent}%)")
         if memory_percent > 90:
             warnings.append(f"⚠️  HIGH MEMORY USAGE: {memory_percent}%")
 
@@ -109,14 +107,10 @@ Example:
         disk_total_gb = disk.total / (1024**3)
         disk_percent = disk.percent
         disk_free_gb = disk.free / (1024**3)
-        output.append(
-            f"Disk: {disk_used_gb:.1f}/{disk_total_gb:.1f} GB ({disk_percent}%)"
-        )
+        output.append(f"Disk: {disk_used_gb:.1f}/{disk_total_gb:.1f} GB ({disk_percent}%)")
         output.append(f"Free Space: {disk_free_gb:.1f} GB")
         if disk_percent > 90:
-            warnings.append(
-                f"⚠️  LOW DISK SPACE: Only {disk_free_gb:.1f} GB free ({100 - disk_percent:.1f}% remaining)"
-            )
+            warnings.append(f"⚠️  LOW DISK SPACE: Only {disk_free_gb:.1f} GB free ({100 - disk_percent:.1f}% remaining)")
 
         output.append("")
 
@@ -173,9 +167,7 @@ Example:
                     size = db_file.stat().st_size
                     total_db_size += size
 
-                output.append(
-                    f"Total Database Size: {total_db_size / (1024**2):.1f} MB"
-                )
+                output.append(f"Total Database Size: {total_db_size / (1024**2):.1f} MB")
                 output.append(f"Active Projects: {len(self.db_manager.projects)}")
 
                 # List largest databases
@@ -201,9 +193,7 @@ Example:
         output.append("=== MCP Servers ===")
         mcp_servers = McpAddTool.get_servers()
         if mcp_servers:
-            running_mcp = sum(
-                1 for s in mcp_servers.values() if s.get("status") == "running"
-            )
+            running_mcp = sum(1 for s in mcp_servers.values() if s.get("status") == "running")
             total_mcp_tools = sum(len(s.get("tools", [])) for s in mcp_servers.values())
 
             output.append(f"Total Servers: {len(mcp_servers)}")
@@ -225,9 +215,7 @@ Example:
             output.append(f"Log Files: {log_count} ({log_size / (1024**2):.1f} MB)")
 
             if log_size > 100 * 1024**2:  # > 100MB
-                warnings.append(
-                    f"⚠️  Large log directory: {log_size / (1024**2):.1f} MB"
-                )
+                warnings.append(f"⚠️  Large log directory: {log_size / (1024**2):.1f} MB")
 
         # Config directory
         config_dir = Path.home() / ".hanzo" / "mcp"

hanzo_mcp/tools/common/thinking_tool.py

@@ -115,9 +115,7 @@ Feature Implementation Planning
 
         # Validate required thought parameter
         if not thought:
-            await tool_ctx.error(
-                "Parameter 'thought' is required but was None or empty"
-            )
+            await tool_ctx.error("Parameter 'thought' is required but was None or empty")
             return "Error: Parameter 'thought' is required but was None or empty"
 
         if thought.strip() == "":

hanzo_mcp/tools/common/tool_disable.py

@@ -125,9 +125,7 @@ Use 'tool_enable' to re-enable disabled tools.
         ]
 
         if not persist:
-            output.append(
-                "\nNote: This change is temporary and will be lost on restart."
-            )
+            output.append("\nNote: This change is temporary and will be lost on restart.")
 
         # Warn about commonly used tools
         common_tools = {"grep", "read", "write", "bash", "edit"}
@@ -137,9 +135,7 @@ Use 'tool_enable' to re-enable disabled tools.
             )
 
         # Count disabled tools
-        disabled_count = sum(
-            1 for enabled in ToolEnableTool._tool_states.values() if not enabled
-        )
+        disabled_count = sum(1 for enabled in ToolEnableTool._tool_states.values() if not enabled)
         output.append(f"\nTotal disabled tools: {disabled_count}")
 
         return "\n".join(output)

hanzo_mcp/tools/common/tool_list.py

@@ -205,9 +205,7 @@ Use 'tool_enable' and 'tool_disable' to change tool status.
 
         # Iterate through categories
         categories = (
-            [category_filter]
-            if category_filter and category_filter in self.TOOL_INFO
-            else self.TOOL_INFO.keys()
+            [category_filter] if category_filter and category_filter in self.TOOL_INFO else self.TOOL_INFO.keys()
         )
 
         for category in categories:
@@ -242,9 +240,7 @@ Use 'tool_enable' and 'tool_disable' to change tool status.
                 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("")
 

hanzo_mcp/tools/common/validation.py

@@ -32,9 +32,7 @@ class ValidationResult:
         return not self.is_valid
 
 
-def validate_path_parameter(
-    path: str | None, parameter_name: str = "path"
-) -> ValidationResult:
+def validate_path_parameter(path: str | None, parameter_name: str = "path") -> ValidationResult:
     """Validate a path parameter.
 
     Args:

hanzo_mcp/tools/config/config_tool.py

@@ -131,9 +131,7 @@ 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"
@@ -173,7 +171,9 @@ config --action toggle index.scope --path ./project"""
             project_path = Path(project_dir)
             project_path.mkdir(parents=True, exist_ok=True)
             cfg = project_path / ".hanzo-mcp.json"
-            cfg.write_text(__import__("json").dumps(settings.__dict__ if hasattr(settings, "__dict__") else {}, indent=2))
+            cfg.write_text(
+                __import__("json").dumps(settings.__dict__ if hasattr(settings, "__dict__") else {}, indent=2)
+            )
             return cfg
         # Fallback to global handler
         return save_settings(settings, global_config=True)
@@ -196,9 +196,7 @@ config --action toggle index.scope --path ./project"""
         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"
@@ -281,18 +279,14 @@ config --action toggle index.scope --path ./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 execution tool enable/disable: tools.<name>.enabled or enabled_tools.<name>

hanzo_mcp/tools/config/index_config.py

@@ -99,9 +99,7 @@ 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

hanzo_mcp/tools/config/mode_tool.py

@@ -187,12 +187,8 @@ mode --action current"""
                 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")
 
@@ -256,9 +252,7 @@ mode --action current"""
                     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)
 
@@ -312,17 +306,13 @@ mode --action current"""
         tool_self = self
 
         @server.tool(name=self.name, description=self.description)
-        async def mode_handler(
-            ctx: MCPContext, action: str = "list", name: Optional[str] = None
-        ) -> str:
+        async def mode_handler(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")
-        )
+        return await self.run(ctx, action=params.get("action", "list"), name=params.get("name"))
 
 
 # Create tool instance

hanzo_mcp/tools/database/database_manager.py

@@ -127,9 +127,7 @@ class ProjectDatabase:
         # Indexes for graph traversal
         conn.execute("CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source)")
         conn.execute("CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target)")
-        conn.execute(
-            "CREATE INDEX IF NOT EXISTS idx_edges_relationship ON edges(relationship)"
-        )
+        conn.execute("CREATE INDEX IF NOT EXISTS idx_edges_relationship ON edges(relationship)")
         conn.execute("CREATE INDEX IF NOT EXISTS idx_nodes_type ON nodes(type)")
 
     def _load_graph_from_disk(self):
@@ -138,15 +136,11 @@ class ProjectDatabase:
         try:
             # Copy nodes
             nodes = disk_conn.execute("SELECT * FROM nodes").fetchall()
-            self.graph_conn.executemany(
-                "INSERT OR REPLACE INTO nodes VALUES (?, ?, ?, ?)", nodes
-            )
+            self.graph_conn.executemany("INSERT OR REPLACE INTO nodes VALUES (?, ?, ?, ?)", nodes)
 
             # Copy edges
             edges = disk_conn.execute("SELECT * FROM edges").fetchall()
-            self.graph_conn.executemany(
-                "INSERT OR REPLACE INTO edges VALUES (?, ?, ?, ?, ?, ?)", edges
-            )
+            self.graph_conn.executemany("INSERT OR REPLACE INTO edges VALUES (?, ?, ?, ?, ?, ?)", edges)
 
             self.graph_conn.commit()
         finally:

hanzo_mcp/tools/database/graph.py

@@ -120,9 +120,7 @@ class GraphParams(TypedDict, total=False):
 class GraphTool(BaseTool):
     """Unified graph database tool."""
 
-    def __init__(
-        self, permission_manager: PermissionManager, db_manager: DatabaseManager
-    ):
+    def __init__(self, permission_manager: PermissionManager, db_manager: DatabaseManager):
         """Initialize the graph tool."""
         super().__init__(permission_manager)
         self.db_manager = db_manager

hanzo_mcp/tools/database/graph_add.py

@@ -93,9 +93,7 @@ class GraphAddParams(TypedDict, total=False):
 class GraphAddTool(BaseTool):
     """Tool for adding nodes and edges to graph database."""
 
-    def __init__(
-        self, permission_manager: PermissionManager, db_manager: DatabaseManager
-    ):
+    def __init__(self, permission_manager: PermissionManager, db_manager: DatabaseManager):
         """Initialize the graph add tool.
 
         Args:
@@ -225,15 +223,11 @@ Examples:
                 if not relationship:
                     return "Error: relationship is required when adding an edge"
 
-                await tool_ctx.info(
-                    f"Adding edge: {source} --[{relationship}]--> {target}"
-                )
+                await tool_ctx.info(f"Adding edge: {source} --[{relationship}]--> {target}")
 
                 # Check if nodes exist
                 cursor = graph_conn.cursor()
-                cursor.execute(
-                    "SELECT id FROM nodes WHERE id IN (?, ?)", (source, target)
-                )
+                cursor.execute("SELECT id FROM nodes WHERE id IN (?, ?)", (source, target))
                 existing = [row[0] for row in cursor.fetchall()]
 
                 if source not in existing: