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

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:

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_edit.py

@@ -252,7 +252,7 @@ Or visit: https://neovim.io/"""
                             end if
                         end tell"""
 
-                        subprocess.run(["osascript", "-e", applescript])
+                        subprocess.run(["osascript", "-e", applescript], timeout=10)
                         return f"Opened {file_path} in Neovim (new terminal window)"
 
                 elif shutil.which("gnome-terminal"):
@@ -272,7 +272,7 @@ Or visit: https://neovim.io/"""
 
             else:
                 # Run and wait for completion
-                result = subprocess.run(cmd)
+                result = subprocess.run(cmd, timeout=120)
 
                 if result.returncode == 0:
                     return f"Successfully edited {file_path} in Neovim"

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]