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

hanzo_mcp/tools/database/graph_query.py

@@ -102,9 +102,7 @@ class GraphQueryParams(TypedDict, total=False):
 class GraphQueryTool(BaseTool):
     """Tool for querying the graph database."""
 
-    def __init__(
-        self, permission_manager: PermissionManager, db_manager: DatabaseManager
-    ):
+    def __init__(self, permission_manager: PermissionManager, db_manager: DatabaseManager):
         """Initialize the graph query tool.
 
         Args:
@@ -192,10 +190,7 @@ Examples:
             return f"Error: Invalid query '{query}'. Must be one of: {', '.join(valid_queries)}"
 
         # Validate required parameters
-        if (
-            query in ["neighbors", "subgraph", "connected", "ancestors", "descendants"]
-            and not node_id
-        ):
+        if query in ["neighbors", "subgraph", "connected", "ancestors", "descendants"] and not node_id:
             return f"Error: node_id is required for '{query}' query"
 
         if query == "path" and (not node_id or not target_id):
@@ -225,27 +220,17 @@ Examples:
 
         try:
             if query == "neighbors":
-                return self._query_neighbors(
-                    graph_conn, node_id, relationship, node_type, direction
-                )
+                return self._query_neighbors(graph_conn, node_id, relationship, node_type, direction)
             elif query == "path":
                 return self._query_path(graph_conn, node_id, target_id, relationship)
             elif query == "subgraph":
-                return self._query_subgraph(
-                    graph_conn, node_id, depth, relationship, node_type, direction
-                )
+                return self._query_subgraph(graph_conn, node_id, depth, relationship, node_type, direction)
             elif query == "connected":
-                return self._query_connected(
-                    graph_conn, node_id, relationship, node_type, direction
-                )
+                return self._query_connected(graph_conn, node_id, relationship, node_type, direction)
             elif query == "ancestors":
-                return self._query_ancestors(
-                    graph_conn, node_id, depth, relationship, node_type
-                )
+                return self._query_ancestors(graph_conn, node_id, depth, relationship, node_type)
             elif query == "descendants":
-                return self._query_descendants(
-                    graph_conn, node_id, depth, relationship, node_type
-                )
+                return self._query_descendants(graph_conn, node_id, depth, relationship, node_type)
 
         except Exception as e:
             await tool_ctx.error(f"Failed to execute query: {str(e)}")
@@ -331,13 +316,9 @@ Examples:
         output = [f"Neighbors of '{node_id}' ({node_info[0]}):\n"]
         for n in neighbors:
             arrow = "<--" if n["direction"] == "incoming" else "-->"
-            output.append(
-                f"  {node_id} {arrow}[{n['relationship']}]--> {n['node_id']} ({n['node_type']})"
-            )
+            output.append(f"  {node_id} {arrow}[{n['relationship']}]--> {n['node_id']} ({n['node_type']})")
             if n["properties"]:
-                output.append(
-                    f"    Properties: {json.dumps(n['properties'], indent=6)[:100]}"
-                )
+                output.append(f"    Properties: {json.dumps(n['properties'], indent=6)[:100]}")
 
         output.append(f"\nTotal neighbors: {len(neighbors)}")
         return "\n".join(output)
@@ -590,9 +571,7 @@ Examples:
         node_type: Optional[str],
     ) -> str:
         """Find nodes that point TO this node (incoming edges only)."""
-        return self._query_subgraph(
-            conn, node_id, depth, relationship, node_type, "incoming"
-        )
+        return self._query_subgraph(conn, node_id, depth, relationship, node_type, "incoming")
 
     def _query_descendants(
         self,
@@ -603,9 +582,7 @@ Examples:
         node_type: Optional[str],
     ) -> str:
         """Find nodes that this node points TO (outgoing edges only)."""
-        return self._query_subgraph(
-            conn, node_id, depth, relationship, node_type, "outgoing"
-        )
+        return self._query_subgraph(conn, node_id, depth, relationship, node_type, "outgoing")
 
     def register(self, mcp_server) -> None:
         """Register this tool with the MCP server."""

hanzo_mcp/tools/database/graph_remove.py

@@ -74,9 +74,7 @@ class GraphRemoveParams(TypedDict, total=False):
 class GraphRemoveTool(BaseTool):
     """Tool for removing nodes and edges from graph database."""
 
-    def __init__(
-        self, permission_manager: PermissionManager, db_manager: DatabaseManager
-    ):
+    def __init__(self, permission_manager: PermissionManager, db_manager: DatabaseManager):
         """Initialize the graph remove tool.
 
         Args:
@@ -220,9 +218,7 @@ Examples:
                 # Remove edge(s)
                 if relationship:
                     # Remove specific edge
-                    await tool_ctx.info(
-                        f"Removing edge: {source} --[{relationship}]--> {target}"
-                    )
+                    await tool_ctx.info(f"Removing edge: {source} --[{relationship}]--> {target}")
 
                     cursor = graph_conn.cursor()
                     cursor.execute(
@@ -242,9 +238,7 @@ Examples:
                     return f"Successfully removed edge: {source} --[{relationship}]--> {target}"
                 else:
                     # Remove all edges between nodes
-                    await tool_ctx.info(
-                        f"Removing all edges between {source} and {target}"
-                    )
+                    await tool_ctx.info(f"Removing all edges between {source} and {target}")
 
                     cursor = graph_conn.cursor()
                     cursor.execute(

hanzo_mcp/tools/database/graph_search.py

@@ -76,9 +76,7 @@ class GraphSearchParams(TypedDict, total=False):
 class GraphSearchTool(BaseTool):
     """Tool for searching nodes and edges in graph database."""
 
-    def __init__(
-        self, permission_manager: PermissionManager, db_manager: DatabaseManager
-    ):
+    def __init__(self, permission_manager: PermissionManager, db_manager: DatabaseManager):
         """Initialize the graph search tool.
 
         Args:
@@ -315,13 +313,8 @@ Examples:
                 output.append(f"Nodes ({len(nodes)}):")
                 for node in nodes[:20]:  # Show first 20
                     output.append(f"  {node['id']} ({node['node_type']})")
-                    if (
-                        node["match_field"] == "properties"
-                        and "matching_properties" in node
-                    ):
-                        output.append(
-                            f"    Matched in: {list(node['matching_properties'].keys())}"
-                        )
+                    if node["match_field"] == "properties" and "matching_properties" in node:
+                        output.append(f"    Matched in: {list(node['matching_properties'].keys())}")
                     if node["properties"] and node["match_field"] != "properties":
                         props_str = json.dumps(node["properties"], indent=6)[:100]
                         if len(props_str) == 100:
@@ -335,16 +328,9 @@ Examples:
             if edges:
                 output.append(f"Edges ({len(edges)}):")
                 for edge in edges[:20]:  # Show first 20
-                    output.append(
-                        f"  {edge['source']} --[{edge['relationship']}]--> {edge['target']}"
-                    )
-                    if (
-                        edge["match_field"] == "properties"
-                        and "matching_properties" in edge
-                    ):
-                        output.append(
-                            f"    Matched in: {list(edge['matching_properties'].keys())}"
-                        )
+                    output.append(f"  {edge['source']} --[{edge['relationship']}]--> {edge['target']}")
+                    if edge["match_field"] == "properties" and "matching_properties" in edge:
+                        output.append(f"    Matched in: {list(edge['matching_properties'].keys())}")
                     if edge["weight"] != 1.0:
                         output.append(f"    Weight: {edge['weight']}")
                     if edge["properties"]:

hanzo_mcp/tools/database/graph_stats.py

@@ -58,9 +58,7 @@ class GraphStatsParams(TypedDict, total=False):
 class GraphStatsTool(BaseTool):
     """Tool for getting graph database statistics."""
 
-    def __init__(
-        self, permission_manager: PermissionManager, db_manager: DatabaseManager
-    ):
+    def __init__(self, permission_manager: PermissionManager, db_manager: DatabaseManager):
         """Initialize the graph stats tool.
 
         Args:
@@ -139,9 +137,7 @@ Examples:
         except Exception as e:
             return f"Error accessing project database: {str(e)}"
 
-        await tool_ctx.info(
-            f"Getting graph statistics for project: {project_db.project_path}"
-        )
+        await tool_ctx.info(f"Getting graph statistics for project: {project_db.project_path}")
 
         # Get graph connection
         graph_conn = project_db.get_graph_connection()
@@ -156,9 +152,7 @@ Examples:
 
             # Basic counts
             if node_type_filter:
-                cursor.execute(
-                    "SELECT COUNT(*) FROM nodes WHERE type = ?", (node_type_filter,)
-                )
+                cursor.execute("SELECT COUNT(*) FROM nodes WHERE type = ?", (node_type_filter,))
                 node_count = cursor.fetchone()[0]
                 output.append(f"Nodes (type='{node_type_filter}'): {node_count:,}")
             else:
@@ -172,9 +166,7 @@ Examples:
                     (relationship_filter,),
                 )
                 edge_count = cursor.fetchone()[0]
-                output.append(
-                    f"Edges (relationship='{relationship_filter}'): {edge_count:,}"
-                )
+                output.append(f"Edges (relationship='{relationship_filter}'): {edge_count:,}")
             else:
                 cursor.execute("SELECT COUNT(*) FROM edges")
                 edge_count = cursor.fetchone()[0]
@@ -188,9 +180,7 @@ Examples:
 
             # Node type distribution
             output.append("=== Node Types ===")
-            cursor.execute(
-                "SELECT type, COUNT(*) as count FROM nodes GROUP BY type ORDER BY count DESC"
-            )
+            cursor.execute("SELECT type, COUNT(*) as count FROM nodes GROUP BY type ORDER BY count DESC")
             node_types = cursor.fetchall()
 
             for n_type, count in node_types[:10]:
@@ -285,31 +275,21 @@ Examples:
                 output.append("\n=== Detailed Analysis ===")
 
                 # Node properties usage
-                cursor.execute(
-                    "SELECT COUNT(*) FROM nodes WHERE properties IS NOT NULL"
-                )
+                cursor.execute("SELECT COUNT(*) FROM nodes WHERE properties IS NOT NULL")
                 nodes_with_props = cursor.fetchone()[0]
                 if nodes_with_props > 0:
                     props_pct = (nodes_with_props / node_count) * 100
-                    output.append(
-                        f"Nodes with properties: {nodes_with_props} ({props_pct:.1f}%)"
-                    )
+                    output.append(f"Nodes with properties: {nodes_with_props} ({props_pct:.1f}%)")
 
                 # Edge properties usage
-                cursor.execute(
-                    "SELECT COUNT(*) FROM edges WHERE properties IS NOT NULL"
-                )
+                cursor.execute("SELECT COUNT(*) FROM edges WHERE properties IS NOT NULL")
                 edges_with_props = cursor.fetchone()[0]
                 if edges_with_props > 0 and edge_count > 0:
                     props_pct = (edges_with_props / edge_count) * 100
-                    output.append(
-                        f"Edges with properties: {edges_with_props} ({props_pct:.1f}%)"
-                    )
+                    output.append(f"Edges with properties: {edges_with_props} ({props_pct:.1f}%)")
 
                 # Weight distribution
-                cursor.execute(
-                    "SELECT MIN(weight), MAX(weight), AVG(weight) FROM edges"
-                )
+                cursor.execute("SELECT MIN(weight), MAX(weight), AVG(weight) FROM edges")
                 weight_stats = cursor.fetchone()
                 if weight_stats[0] is not None:
                     output.append(f"\nEdge weights:")
@@ -338,9 +318,7 @@ Examples:
                     if patterns:
                         output.append("Most common connections:")
                         for src_type, rel, tgt_type, count in patterns:
-                            output.append(
-                                f"  {src_type} --[{rel}]--> {tgt_type}: {count} times"
-                            )
+                            output.append(f"  {src_type} --[{rel}]--> {tgt_type}: {count} times")
 
                 # Component analysis (simplified)
                 output.append("\n=== Graph Structure ===")

hanzo_mcp/tools/database/sql.py

@@ -75,9 +75,7 @@ class SQLParams(TypedDict, total=False):
 class SQLTool(BaseTool):
     """Unified SQL database tool."""
 
-    def __init__(
-        self, permission_manager: PermissionManager, db_manager: DatabaseManager
-    ):
+    def __init__(self, permission_manager: PermissionManager, db_manager: DatabaseManager):
         """Initialize the SQL tool."""
         super().__init__(permission_manager)
         self.db_manager = db_manager
@@ -296,9 +294,7 @@ sql --action stats --table users
                     output.append("-" * 60)
 
                     for col in columns:
-                        output.append(
-                            f"{col[1]} | {col[2]} | {col[3]} | {col[4]} | {col[5]}"
-                        )
+                        output.append(f"{col[1]} | {col[2]} | {col[3]} | {col[4]} | {col[5]}")
 
                     # Get indexes
                     cursor = conn.execute(f"PRAGMA index_list({table})")
@@ -336,9 +332,7 @@ sql --action stats --table users
                         # Get columns
                         cursor = conn.execute(f"PRAGMA table_info({table_name})")
                         columns = cursor.fetchall()
-                        output.append(
-                            f"Columns: {', '.join([col[1] for col in columns])}"
-                        )
+                        output.append(f"Columns: {', '.join([col[1] for col in columns])}")
 
                 return "\n".join(output)
 
@@ -402,9 +396,7 @@ sql --action stats --table users
                             """
                             )
                             stats = cursor.fetchone()
-                            output.append(
-                                f"  {col_name}: distinct={stats[0]}, nulls={stats[1]}"
-                            )
+                            output.append(f"  {col_name}: distinct={stats[0]}, nulls={stats[1]}")
 
                 else:
                     # Overall database stats

hanzo_mcp/tools/database/sql_query.py

@@ -48,9 +48,7 @@ class SqlQueryParams(TypedDict, total=False):
 class SqlQueryTool(BaseTool):
     """Tool for executing SQL queries on project databases."""
 
-    def __init__(
-        self, permission_manager: PermissionManager, db_manager: DatabaseManager
-    ):
+    def __init__(self, permission_manager: PermissionManager, db_manager: DatabaseManager):
         """Initialize the SQL query tool.
 
         Args:
@@ -140,11 +138,11 @@ Note: Use sql_search for text search operations."""
             query_upper = query.upper()
             for keyword in write_keywords:
                 if keyword in query_upper:
-                    return f"Error: Query contains {keyword} operation. Set --read-only false to allow write operations."
+                    return (
+                        f"Error: Query contains {keyword} operation. Set --read-only false to allow write operations."
+                    )
 
-        await tool_ctx.info(
-            f"Executing SQL query on project: {project_db.project_path}"
-        )
+        await tool_ctx.info(f"Executing SQL query on project: {project_db.project_path}")
 
         # Execute query
         conn = None
@@ -209,9 +207,7 @@ Note: Use sql_search for text search operations."""
         output_rows = []
         for row in rows[:1000]:  # Limit to 1000 rows
             row_str = " | ".join(
-                self._truncate(str(val) if val is not None else "NULL", width).ljust(
-                    width
-                )
+                self._truncate(str(val) if val is not None else "NULL", width).ljust(width)
                 for val, width in zip(row, col_widths)
             )
             output_rows.append(row_str)

hanzo_mcp/tools/database/sql_search.py

@@ -66,9 +66,7 @@ class SqlSearchParams(TypedDict, total=False):
 class SqlSearchTool(BaseTool):
     """Tool for searching text in SQLite database."""
 
-    def __init__(
-        self, permission_manager: PermissionManager, db_manager: DatabaseManager
-    ):
+    def __init__(self, permission_manager: PermissionManager, db_manager: DatabaseManager):
         """Initialize the SQL search tool.
 
         Args:
@@ -253,9 +251,7 @@ Use sql_query for complex queries with joins, conditions, etc."""
 
         return text_columns
 
-    def _format_results(
-        self, table: str, results: list, pattern: str, search_columns: list[str]
-    ) -> str:
+    def _format_results(self, table: str, results: list, pattern: str, search_columns: list[str]) -> str:
         """Format search results based on table type."""
         output = []
 

hanzo_mcp/tools/database/sql_stats.py

@@ -39,9 +39,7 @@ class SqlStatsParams(TypedDict, total=False):
 class SqlStatsTool(BaseTool):
     """Tool for getting SQLite database statistics."""
 
-    def __init__(
-        self, permission_manager: PermissionManager, db_manager: DatabaseManager
-    ):
+    def __init__(self, permission_manager: PermissionManager, db_manager: DatabaseManager):
         """Initialize the SQL stats tool.
 
         Args:
@@ -115,9 +113,7 @@ Examples:
         except Exception as e:
             return f"Error accessing project database: {str(e)}"
 
-        await tool_ctx.info(
-            f"Getting statistics for project: {project_db.project_path}"
-        )
+        await tool_ctx.info(f"Getting statistics for project: {project_db.project_path}")
 
         # Collect statistics
         conn = None
@@ -136,9 +132,7 @@ Examples:
             output.append("")
 
             # Get table statistics
-            cursor.execute(
-                "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name"
-            )
+            cursor.execute("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name")
             tables = cursor.fetchall()
 
             output.append("=== Tables ===")
@@ -182,9 +176,7 @@ Examples:
 
                     # Show sample data for specific tables
                     if table_name == "files" and row_count > 0:
-                        cursor.execute(
-                            f"SELECT COUNT(DISTINCT SUBSTR(path, -3)) as ext_count FROM {table_name}"
-                        )
+                        cursor.execute(f"SELECT COUNT(DISTINCT SUBSTR(path, -3)) as ext_count FROM {table_name}")
                         ext_count = cursor.fetchone()[0]
                         output.append(f"  File types: ~{ext_count}")
 
@@ -206,9 +198,7 @@ Examples:
             output.append(f"\nTotal Rows: {total_rows:,}")
 
             # Get index statistics
-            cursor.execute(
-                "SELECT name FROM sqlite_master WHERE type='index' AND sql IS NOT NULL ORDER BY name"
-            )
+            cursor.execute("SELECT name FROM sqlite_master WHERE type='index' AND sql IS NOT NULL ORDER BY name")
             indexes = cursor.fetchall()
             if indexes:
                 output.append(f"\n=== Indexes ===")

hanzo_mcp/tools/editor/neovim_command.py

@@ -158,9 +158,7 @@ Note: Requires Neovim to be installed.
             return "Error: Must provide either 'command', 'commands', or 'macro'"
 
         if sum(bool(x) for x in [command, commands, macro]) > 1:
-            return (
-                "Error: Can only use one of 'command', 'commands', or 'macro' at a time"
-            )
+            return "Error: Can only use one of 'command', 'commands', or 'macro' at a time"
 
         # Check if Neovim is available
         nvim_cmd = shutil.which("nvim")

hanzo_mcp/tools/editor/neovim_session.py

@@ -168,9 +168,7 @@ Note: Requires Neovim to be installed.
                 project_path,
             )
         elif action == "restore":
-            return await self._restore_session(
-                tool_ctx, session_name, project_session_dir
-            )
+            return await self._restore_session(tool_ctx, session_name, project_session_dir)
         elif action == "list":
             return self._list_sessions(project_session_dir, project_path)
         elif action == "delete":
@@ -214,9 +212,7 @@ Note: Requires Neovim to be installed.
             # Run Neovim to save session
             # First, check if Neovim is already running
             # For now, we'll create a new instance
-            result = subprocess.run(
-                ["nvim", "-c", vim_script.strip()], capture_output=True, text=True
-            )
+            result = subprocess.run(["nvim", "-c", vim_script.strip()], capture_output=True, text=True)
 
             if result.returncode != 0 and result.stderr:
                 return f"Error saving session: {result.stderr}"
@@ -246,15 +242,15 @@ Or manually in Neovim:
         except Exception as e:
             return f"Error saving session: {str(e)}"
 
-    async def _restore_session(
-        self, tool_ctx, session_name: Optional[str], project_dir: Path
-    ) -> str:
+    async def _restore_session(self, tool_ctx, session_name: Optional[str], project_dir: Path) -> str:
         """Restore Neovim session."""
         if not session_name:
             # List available sessions
             sessions = list(project_dir.glob("*.vim"))
             if not sessions:
-                return "Error: No sessions found for this project. Use 'neovim_session --action list' to see all sessions."
+                return (
+                    "Error: No sessions found for this project. Use 'neovim_session --action list' to see all sessions."
+                )
 
             # Use most recent
             sessions.sort(key=lambda x: x.stat().st_mtime, reverse=True)
@@ -330,9 +326,7 @@ Or manually in Neovim:
             if len(other_sessions) > 10:
                 output.append(f"  ... and {len(other_sessions) - 10} more")
 
-        output.append(
-            "\nUse 'neovim_session --action restore --session-name <name>' to restore a session."
-        )
+        output.append("\nUse 'neovim_session --action restore --session-name <name>' to restore a session.")
 
         return "\n".join(output)
 

hanzo_mcp/tools/filesystem/__init__.py

@@ -93,9 +93,7 @@ def get_read_only_filesystem_tools(
     return tools
 
 
-def get_filesystem_tools(
-    permission_manager: PermissionManager, project_manager=None
-) -> list[BaseTool]:
+def get_filesystem_tools(permission_manager: PermissionManager, project_manager=None) -> list[BaseTool]:
     """Create instances of all filesystem tools.
 
     Args:
@@ -226,6 +224,7 @@ def register_filesystem_tools(
     try:
         ast_tool = next((t for t in tools if getattr(t, "name", "") == "ast"), None)
         if ast_tool is not None:
+
             class _SymbolsAlias(ASTTool):  # type: ignore[misc]
                 @property
                 def name(self) -> str:  # type: ignore[override]

hanzo_mcp/tools/filesystem/ast_multi_edit.py

@@ -129,9 +129,7 @@ class ASTMultiEdit(BaseTool):
 
         return parser.parse(bytes(content, "utf-8"))
 
-    def _find_references(
-        self, symbol: str, file_path: str, project_root: Optional[str] = None
-    ) -> List[ASTMatch]:
+    def _find_references(self, symbol: str, file_path: str, project_root: Optional[str] = None) -> List[ASTMatch]:
         """Find all references to a symbol across the project."""
         matches = []
 
@@ -149,9 +147,7 @@ class ASTMultiEdit(BaseTool):
 
         return matches
 
-    def _get_reference_patterns(
-        self, symbol: str, file_path: str
-    ) -> List[Dict[str, Any]]:
+    def _get_reference_patterns(self, symbol: str, file_path: str) -> List[Dict[str, Any]]:
         """Get language-specific patterns for finding references."""
         ext = Path(file_path).suffix.lower()
         lang = self.languages.get(ext, "generic")
@@ -262,9 +258,7 @@ class ASTMultiEdit(BaseTool):
                     matches.extend(self._query_ast(tree, pattern, file_path, content))
                 else:
                     # Fallback to text search
-                    matches.extend(
-                        self._text_search(content, pattern["query"], file_path)
-                    )
+                    matches.extend(self._text_search(content, pattern["query"], file_path))
 
             except Exception:
                 continue
@@ -313,9 +307,7 @@ class ASTMultiEdit(BaseTool):
 
         return matches
 
-    def _get_parent_context(
-        self, node: tree_sitter.Node, content: str
-    ) -> Optional[str]:
+    def _get_parent_context(self, node: tree_sitter.Node, content: str) -> Optional[str]:
         """Get parent context for better understanding."""
         parent = node.parent
         if parent:
@@ -335,9 +327,7 @@ class ASTMultiEdit(BaseTool):
 
         return None
 
-    def _text_search(
-        self, content: str, pattern: str, file_path: str
-    ) -> List[ASTMatch]:
+    def _text_search(self, content: str, pattern: str, file_path: str) -> List[ASTMatch]:
         """Fallback text search."""
         matches = []
         lines = content.split("\n")
@@ -412,18 +402,14 @@ class ASTMultiEdit(BaseTool):
 
         return str(path.parent)
 
-    def _group_matches_by_file(
-        self, matches: List[ASTMatch]
-    ) -> Dict[str, List[ASTMatch]]:
+    def _group_matches_by_file(self, matches: List[ASTMatch]) -> Dict[str, List[ASTMatch]]:
         """Group matches by file for efficient editing."""
         grouped = defaultdict(list)
         for match in matches:
             grouped[match.file_path].append(match)
         return grouped
 
-    def _create_unique_context(
-        self, content: str, match: ASTMatch, context_lines: int
-    ) -> str:
+    def _create_unique_context(self, content: str, match: ASTMatch, context_lines: int) -> str:
         """Create unique context for edit identification."""
         lines = content.split("\n")
 
@@ -499,27 +485,20 @@ class ASTMultiEdit(BaseTool):
                         pattern = {"query": edit_op.old_string, "type": "text"}
                         matches = self._query_ast(tree, pattern, file_path, content)
                     else:
-                        matches = self._text_search(
-                            content, edit_op.old_string, file_path
-                        )
+                        matches = self._text_search(content, edit_op.old_string, file_path)
 
                 # Filter by node types if specified
                 if edit_op.node_types:
                     matches = [m for m in matches if m.node_type in edit_op.node_types]
 
                 # Check expected count
-                if (
-                    edit_op.expect_count is not None
-                    and len(matches) != edit_op.expect_count
-                ):
+                if edit_op.expect_count is not None and len(matches) != edit_op.expect_count:
                     results["errors"].append(
                         {
                             "edit": edit_op.old_string,
                             "expected": edit_op.expect_count,
                             "found": len(matches),
-                            "locations": [
-                                f"{m.file_path}:{m.line_start}" for m in matches[:5]
-                            ],
+                            "locations": [f"{m.file_path}:{m.line_start}" for m in matches[:5]],
                         }
                     )
                     continue
@@ -547,9 +526,7 @@ class ASTMultiEdit(BaseTool):
                 success = await self._apply_file_changes(file_path, changes)
                 if success:
                     results["edits_applied"] += len(changes)
-                    results["changes"].append(
-                        {"file": file_path, "edits": len(changes)}
-                    )
+                    results["changes"].append({"file": file_path, "edits": len(changes)})
             except Exception as e:
                 results["errors"].append({"file": file_path, "error": str(e)})
 
@@ -564,9 +541,7 @@ class ASTMultiEdit(BaseTool):
             grouped[match.file_path].append((edit_op, match))
         return grouped
 
-    async def _apply_file_changes(
-        self, file_path: str, changes: List[Tuple[EditOperation, ASTMatch]]
-    ) -> bool:
+    async def _apply_file_changes(self, file_path: str, changes: List[Tuple[EditOperation, ASTMatch]]) -> bool:
         """Apply changes to a single file."""
         with open(file_path, "r", encoding="utf-8") as f:
             content = f.read()
@@ -600,9 +575,7 @@ class ASTMultiEdit(BaseTool):
 
         return True
 
-    def _generate_preview(
-        self, matches: List[Tuple[EditOperation, ASTMatch]], page_size: int
-    ) -> List[Dict[str, Any]]:
+    def _generate_preview(self, matches: List[Tuple[EditOperation, ASTMatch]], page_size: int) -> List[Dict[str, Any]]:
         """Generate preview of changes."""
         preview = []
 
@@ -625,9 +598,7 @@ class ASTMultiEdit(BaseTool):
 
         return preview
 
-    def _fallback_to_basic_edit(
-        self, file_path: str, edits: List[Dict[str, Any]]
-    ) -> MCPResourceDocument:
+    def _fallback_to_basic_edit(self, file_path: str, edits: List[Dict[str, Any]]) -> MCPResourceDocument:
         """Fallback to basic multi-edit when treesitter not available."""
         # Delegate to existing multi_edit tool
         from hanzo_mcp.tools.filesystem.multi_edit import MultiEdit