hanzo 0.3.5__py3-none-any.whl → 0.3.7__py3-none-any.whl

hanzo/commands/tools.py

@@ -1,13 +1,10 @@
 """Tools management commands."""
 
-import asyncio
-from typing import List, Optional
-
 import click
 from rich.table import Table
 from rich.syntax import Syntax
 
-from ..utils.output import console, handle_errors
+from ..utils.output import console
 
 
 @click.group(name="tools")
@@ -28,23 +25,22 @@ async def list_tools(ctx, category: str, installed: bool):
         console.print("[red]Error:[/red] hanzo-tools not installed")
         console.print("Install with: pip install hanzo[tools]")
         return
-    
+
     registry = get_tool_registry()
-    
+
     with console.status("Loading tools..."):
         try:
             tools = await registry.list_tools(
-                category=category,
-                installed_only=installed
+                category=category, installed_only=installed
             )
         except Exception as e:
             console.print(f"[red]Failed to load tools: {e}[/red]")
             return
-    
+
     if not tools:
         console.print("[yellow]No tools found[/yellow]")
         return
-    
+
     # Group by category
     categories = {}
     for tool in tools:
@@ -52,7 +48,7 @@ async def list_tools(ctx, category: str, installed: bool):
         if cat not in categories:
             categories[cat] = []
         categories[cat].append(tool)
-    
+
     # Display tools
     for cat, cat_tools in sorted(categories.items()):
         table = Table(title=f"{cat.title()} Tools")
@@ -60,15 +56,15 @@ async def list_tools(ctx, category: str, installed: bool):
         table.add_column("Version", style="green")
         table.add_column("Description", style="white")
         table.add_column("Status", style="yellow")
-        
+
         for tool in sorted(cat_tools, key=lambda t: t["name"]):
             table.add_row(
                 tool["name"],
                 tool.get("version", "latest"),
                 tool.get("description", ""),
-                "installed" if tool.get("installed") else "available"
+                "installed" if tool.get("installed") else "available",
             )
-        
+
         console.print(table)
         if len(categories) > 1:
             console.print()
@@ -85,25 +81,24 @@ async def install(ctx, tool_name: str, version: str):
     except ImportError:
         console.print("[red]Error:[/red] hanzo-tools not installed")
         return
-    
+
     registry = get_tool_registry()
-    
+
     with console.status(f"Installing {tool_name}..."):
         try:
-            result = await registry.install_tool(
-                name=tool_name,
-                version=version
+            result = await registry.install_tool(name=tool_name, version=version)
+
+            console.print(
+                f"[green]✓[/green] Installed {tool_name} v{result['version']}"
             )
-            
-            console.print(f"[green]✓[/green] Installed {tool_name} v{result['version']}")
-            
+
             if deps := result.get("dependencies_installed"):
                 console.print(f"  Dependencies: {', '.join(deps)}")
-            
+
             if config := result.get("post_install_message"):
                 console.print(f"\n[yellow]Configuration:[/yellow]")
                 console.print(config)
-                
+
         except Exception as e:
             console.print(f"[red]Failed to install {tool_name}: {e}[/red]")
 
@@ -118,9 +113,9 @@ async def uninstall(ctx, tool_name: str):
     except ImportError:
         console.print("[red]Error:[/red] hanzo-tools not installed")
         return
-    
+
     registry = get_tool_registry()
-    
+
     if click.confirm(f"Uninstall {tool_name}?"):
         with console.status(f"Uninstalling {tool_name}..."):
             try:
@@ -141,20 +136,17 @@ async def update(ctx, tool_name: str, version: str):
     except ImportError:
         console.print("[red]Error:[/red] hanzo-tools not installed")
         return
-    
+
     registry = get_tool_registry()
-    
+
     with console.status(f"Updating {tool_name}..."):
         try:
-            result = await registry.update_tool(
-                name=tool_name,
-                version=version
-            )
-            
+            result = await registry.update_tool(name=tool_name, version=version)
+
             console.print(f"[green]✓[/green] Updated {tool_name}")
             console.print(f"  Previous: v{result['previous_version']}")
             console.print(f"  Current: v{result['current_version']}")
-            
+
         except Exception as e:
             console.print(f"[red]Failed to update {tool_name}: {e}[/red]")
 
@@ -169,35 +161,35 @@ async def info(ctx, tool_name: str):
     except ImportError:
         console.print("[red]Error:[/red] hanzo-tools not installed")
         return
-    
+
     registry = get_tool_registry()
-    
+
     with console.status(f"Loading {tool_name} info..."):
         try:
             info = await registry.get_tool_info(tool_name)
         except Exception as e:
             console.print(f"[red]Failed to get info: {e}[/red]")
             return
-    
+
     console.print(f"[cyan]{info['name']}[/cyan]")
     console.print(f"  Version: {info['version']}")
     console.print(f"  Category: {info['category']}")
     console.print(f"  Author: {info.get('author', 'Unknown')}")
     console.print(f"  License: {info.get('license', 'Unknown')}")
-    
+
     if desc := info.get("description"):
         console.print(f"\n{desc}")
-    
+
     if features := info.get("features"):
         console.print("\n[cyan]Features:[/cyan]")
         for feature in features:
             console.print(f"  • {feature}")
-    
+
     if deps := info.get("dependencies"):
         console.print("\n[cyan]Dependencies:[/cyan]")
         for dep in deps:
             console.print(f"  • {dep}")
-    
+
     if usage := info.get("usage_example"):
         console.print("\n[cyan]Usage Example:[/cyan]")
         syntax = Syntax(usage, "python", theme="monokai", line_numbers=False)
@@ -216,7 +208,7 @@ async def run(ctx, tool_name: str, args: tuple, json: bool):
     except ImportError:
         console.print("[red]Error:[/red] hanzo-tools not installed")
         return
-    
+
     # Parse arguments
     tool_args = {}
     for arg in args:
@@ -227,16 +219,12 @@ async def run(ctx, tool_name: str, args: tuple, json: bool):
             console.print(f"[red]Invalid argument format: {arg}[/red]")
             console.print("Use: key=value")
             return
-    
+
     with console.status(f"Running {tool_name}..."):
         try:
-            result = await run_tool(
-                name=tool_name,
-                args=tool_args
-            )
-            
+            result = await run_tool(name=tool_name, args=tool_args)
+
             if json:
-                import json as json_lib
                 console.print_json(data=result)
             else:
                 if isinstance(result, str):
@@ -246,7 +234,7 @@ async def run(ctx, tool_name: str, args: tuple, json: bool):
                         console.print(f"{key}: {value}")
                 else:
                     console.print(result)
-                    
+
         except Exception as e:
             console.print(f"[red]Tool execution failed: {e}[/red]")
 
@@ -261,40 +249,40 @@ async def upgrade(ctx, check: bool):
     except ImportError:
         console.print("[red]Error:[/red] hanzo-tools not installed")
         return
-    
+
     registry = get_tool_registry()
-    
+
     with console.status("Checking for updates..."):
         try:
             updates = await registry.check_updates()
         except Exception as e:
             console.print(f"[red]Failed to check updates: {e}[/red]")
             return
-    
+
     if not updates:
         console.print("[green]✓[/green] All tools are up to date")
         return
-    
+
     # Show available updates
     table = Table(title="Available Updates")
     table.add_column("Tool", style="cyan")
     table.add_column("Current", style="yellow")
     table.add_column("Latest", style="green")
     table.add_column("Changes", style="white")
-    
+
     for update in updates:
         table.add_row(
             update["name"],
             update["current_version"],
             update["latest_version"],
-            update.get("changelog_summary", "")
+            update.get("changelog_summary", ""),
         )
-    
+
     console.print(table)
-    
+
     if check:
         return
-    
+
     # Perform updates
     if click.confirm(f"Update {len(updates)} tools?"):
         for update in updates:
@@ -317,19 +305,16 @@ async def create(ctx, name: str, template: str):
     except ImportError:
         console.print("[red]Error:[/red] hanzo-tools not installed")
         return
-    
+
     with console.status(f"Creating tool '{name}'..."):
         try:
-            path = await create_tool_template(
-                name=name,
-                template=template or "basic"
-            )
-            
+            path = await create_tool_template(name=name, template=template or "basic")
+
             console.print(f"[green]✓[/green] Created tool template at: {path}")
             console.print("\nNext steps:")
             console.print("1. Edit the tool implementation")
             console.print("2. Test with: hanzo tools run {name}")
             console.print("3. Package with: hanzo tools package {name}")
-            
+
         except Exception as e:
-            console.print(f"[red]Failed to create tool: {e}[/red]")
+            console.print(f"[red]Failed to create tool: {e}[/red]")

hanzo/interactive/__init__.py

@@ -1,3 +1,3 @@
 """Interactive modules for Hanzo CLI."""
 
-__all__ = ["repl", "dashboard"]
+__all__ = ["repl", "dashboard"]

hanzo/interactive/dashboard.py

@@ -1,62 +1,51 @@
 """Dashboard interface for Hanzo CLI."""
 
-from typing import Optional
-
-from rich.console import Console
-from rich.layout import Layout
-from rich.panel import Panel
-from rich.table import Table
 from rich.live import Live
 from rich.text import Text
+from rich.panel import Panel
+from rich.table import Table
+from rich.layout import Layout
+from rich.console import Console
 
 
 def run_dashboard(refresh_rate: float = 1.0):
     """Run the interactive dashboard."""
     console = Console()
-    
+
     layout = Layout()
     layout.split_column(
         Layout(name="header", size=3),
         Layout(name="body"),
-        Layout(name="footer", size=3)
+        Layout(name="footer", size=3),
     )
-    
+
     layout["header"].update(
         Panel(
             Text("Hanzo AI Dashboard", style="bold cyan", justify="center"),
-            border_style="cyan"
+            border_style="cyan",
         )
     )
-    
-    layout["body"].split_row(
-        Layout(name="left"),
-        Layout(name="right")
-    )
-    
-    layout["left"].split_column(
-        Layout(name="cluster", size=10),
-        Layout(name="agents")
-    )
-    
-    layout["right"].split_column(
-        Layout(name="jobs", size=15),
-        Layout(name="logs")
-    )
-    
+
+    layout["body"].split_row(Layout(name="left"), Layout(name="right"))
+
+    layout["left"].split_column(Layout(name="cluster", size=10), Layout(name="agents"))
+
+    layout["right"].split_column(Layout(name="jobs", size=15), Layout(name="logs"))
+
     def get_cluster_panel() -> Panel:
         """Get cluster status panel."""
         table = Table(show_header=False, box=None)
         table.add_column("Key", style="cyan")
         table.add_column("Value", style="white")
-        
+
         # Mock data - would be real in production
         table.add_row("Status", "[green]Running[/green]")
         table.add_row("Nodes", "3")
         table.add_row("Models", "llama-3.2-3b, gpt-4")
         table.add_row("Port", "8000")
-        
+
         return Panel(table, title="Cluster", border_style="green")
-    
+
     def get_agents_panel() -> Panel:
         """Get agents panel."""
         table = Table()
@@ -64,28 +53,28 @@ def run_dashboard(refresh_rate: float = 1.0):
         table.add_column("Name", style="green")
         table.add_column("Status", style="yellow")
         table.add_column("Jobs", style="magenta")
-        
+
         # Mock data
         table.add_row("a1b2", "researcher", "idle", "42")
         table.add_row("c3d4", "coder", "busy", "17")
         table.add_row("e5f6", "analyst", "idle", "23")
-        
+
         return Panel(table, title="Agents", border_style="blue")
-    
+
     def get_jobs_panel() -> Panel:
         """Get jobs panel."""
         table = Table()
         table.add_column("ID", style="cyan", width=8)
         table.add_column("Type", style="green")
         table.add_column("Status", style="yellow")
-        
+
         # Mock data
         table.add_row("j001", "chat", "complete")
         table.add_row("j002", "analysis", "running")
         table.add_row("j003", "search", "queued")
-        
+
         return Panel(table, title="Recent Jobs", border_style="yellow")
-    
+
     def get_logs_panel() -> Panel:
         """Get logs panel."""
         logs = """[dim]2024-01-20 10:15:23[/dim] Agent started: researcher
@@ -93,33 +82,34 @@ def run_dashboard(refresh_rate: float = 1.0):
 [dim]2024-01-20 10:15:25[/dim] Model loaded: llama-3.2-3b
 [dim]2024-01-20 10:15:26[/dim] Network peer connected: node-2
 [dim]2024-01-20 10:15:27[/dim] Job j001 completed (2.3s)"""
-        
+
         return Panel(logs, title="Logs", border_style="dim")
-    
+
     layout["footer"].update(
         Panel(
             "[bold]Q[/bold] Quit  [bold]R[/bold] Refresh  [bold]C[/bold] Clear",
-            border_style="dim"
+            border_style="dim",
         )
     )
-    
+
     # Update panels
     layout["cluster"].update(get_cluster_panel())
     layout["agents"].update(get_agents_panel())
     layout["jobs"].update(get_jobs_panel())
     layout["logs"].update(get_logs_panel())
-    
+
     try:
-        with Live(layout, refresh_per_second=1/refresh_rate, screen=True):
+        with Live(layout, refresh_per_second=1 / refresh_rate, screen=True):
             while True:
                 import time
+
                 time.sleep(refresh_rate)
-                
+
                 # Update dynamic panels
                 layout["cluster"].update(get_cluster_panel())
                 layout["agents"].update(get_agents_panel())
                 layout["jobs"].update(get_jobs_panel())
                 layout["logs"].update(get_logs_panel())
-                
+
     except KeyboardInterrupt:
-        console.print("\n[yellow]Dashboard closed[/yellow]")
+        console.print("\n[yellow]Dashboard closed[/yellow]")

hanzo/interactive/repl.py

@@ -1,20 +1,19 @@
 """Interactive REPL for Hanzo CLI."""
 
-import asyncio
+from typing import Optional
 from pathlib import Path
-from typing import Dict, Any, Optional
 
+from rich.console import Console
+from rich.markdown import Markdown
 from prompt_toolkit import PromptSession
 from prompt_toolkit.history import FileHistory
-from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
 from prompt_toolkit.completion import WordCompleter
-from rich.console import Console
-from rich.markdown import Markdown
+from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
 
 
 class HanzoREPL:
     """Interactive REPL for Hanzo CLI."""
-    
+
     def __init__(self, console: Optional[Console] = None):
         self.console = console or Console()
         self.session = PromptSession(
@@ -29,47 +28,46 @@ class HanzoREPL:
             "status": self.show_status,
         }
         self.running = False
-    
+
     async def run(self):
         """Run the REPL."""
         self.running = True
         # Don't print welcome message here since it's already printed in cli.py
-        
+
         # Set up command completer
         completer = WordCompleter(
             list(self.commands.keys()) + ["chat", "agent", "cluster", "mcp", "network"],
-            ignore_case=True
+            ignore_case=True,
         )
-        
+
         while self.running:
             try:
                 # Get input
                 command = await self.session.prompt_async(
-                    "hanzo> ",
-                    completer=completer
+                    "hanzo> ", completer=completer
                 )
-                
+
                 if not command.strip():
                     continue
-                
+
                 # Parse command
                 parts = command.strip().split(maxsplit=1)
                 cmd = parts[0].lower()
                 args = parts[1] if len(parts) > 1 else ""
-                
+
                 # Execute command
                 if cmd in self.commands:
                     await self.commands[cmd](args)
                 else:
                     await self.execute_command(cmd, args)
-                    
+
             except KeyboardInterrupt:
                 continue
             except EOFError:
                 break
             except Exception as e:
                 self.console.print(f"[red]Error: {e}[/red]")
-    
+
     async def show_help(self, args: str = ""):
         """Show help message."""
         help_text = """
@@ -103,16 +101,16 @@ hanzo> mcp run read_file --arg path=README.md
 - Use Ctrl+R for reverse search
 """
         self.console.print(Markdown(help_text))
-    
+
     def exit_repl(self, args: str = ""):
         """Exit the REPL."""
         self.running = False
         self.console.print("\n[yellow]Goodbye![/yellow]")
-    
+
     def clear_screen(self, args: str = ""):
         """Clear the screen."""
         self.console.clear()
-    
+
     async def show_status(self, args: str = ""):
         """Show system status."""
         status = {
@@ -120,35 +118,38 @@ hanzo> mcp run read_file --arg path=README.md
             "agents": await self.count_agents(),
             "auth": self.check_auth_status(),
         }
-        
+
         self.console.print("[cyan]System Status:[/cyan]")
         self.console.print(f"  Cluster: {status['cluster']}")
         self.console.print(f"  Agents: {status['agents']}")
         self.console.print(f"  Auth: {status['auth']}")
-    
+
     async def execute_command(self, cmd: str, args: str):
         """Execute a CLI command."""
         # Import here to avoid circular imports
-        from .. import cli
-        import click
         import sys
-        
+
+        import click
+
+        from .. import cli
+
         # Build command line
         argv = [cmd]
         if args:
             import shlex
+
             argv.extend(shlex.split(args))
-        
+
         # Create a new context
         try:
             # Save original argv
             orig_argv = sys.argv
             sys.argv = ["hanzo"] + argv
-            
+
             # Execute command
             ctx = click.Context(cli.cli)
             cli.cli.invoke(ctx)
-            
+
         except SystemExit:
             # Catch exit from commands
             pass
@@ -157,28 +158,30 @@ hanzo> mcp run read_file --arg path=README.md
         finally:
             # Restore argv
             sys.argv = orig_argv
-    
+
     async def check_cluster_status(self) -> str:
         """Check if cluster is running."""
         try:
             import httpx
+
             async with httpx.AsyncClient() as client:
                 response = await client.get("http://localhost:8000/health", timeout=1.0)
                 return "running" if response.status_code == 200 else "not responding"
         except:
             return "not running"
-    
+
     async def count_agents(self) -> int:
         """Count running agents."""
         # This would check actual agent status
         return 0
-    
+
     def check_auth_status(self) -> str:
         """Check authentication status."""
         import os
+
         if os.environ.get("HANZO_API_KEY"):
             return "authenticated (API key)"
         elif (Path.home() / ".hanzo" / "auth.json").exists():
             return "authenticated (saved)"
         else:
-            return "not authenticated"
+            return "not authenticated"

hanzo/mcp_server.py

@@ -1,6 +1,7 @@
 """MCP server entry point for hanzo/mcp command."""
 
 import sys
+
 import click
 
 
@@ -8,11 +9,15 @@ def main():
     """Start the Hanzo MCP server."""
     try:
         from hanzo_mcp.server import main as mcp_main
+
         mcp_main()
     except ImportError:
-        click.echo("Error: hanzo-mcp is not installed. Please run: pip install hanzo[mcp] or pip install hanzo[all]", err=True)
+        click.echo(
+            "Error: hanzo-mcp is not installed. Please run: pip install hanzo[mcp] or pip install hanzo[all]",
+            err=True,
+        )
         sys.exit(1)
 
 
 if __name__ == "__main__":
-    main()
+    main()