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

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:

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")