hanzo 0.2.2__py3-none-any.whl → 0.2.5__py3-none-any.whl

hanzo/commands/tools.py

@@ -0,0 +1,335 @@
+"""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
+
+
+@click.group(name="tools")
+def tools_group():
+    """Manage Hanzo tools and plugins."""
+    pass
+
+
+@tools_group.command(name="list")
+@click.option("--category", "-c", help="Filter by category")
+@click.option("--installed", is_flag=True, help="Show only installed tools")
+@click.pass_context
+async def list_tools(ctx, category: str, installed: bool):
+    """List available tools."""
+    try:
+        from hanzo_tools import get_tool_registry
+    except ImportError:
+        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
+            )
+        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:
+        cat = tool.get("category", "uncategorized")
+        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")
+        table.add_column("Name", style="cyan")
+        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"
+            )
+        
+        console.print(table)
+        if len(categories) > 1:
+            console.print()
+
+
+@tools_group.command()
+@click.argument("tool_name")
+@click.option("--version", "-v", help="Specific version to install")
+@click.pass_context
+async def install(ctx, tool_name: str, version: str):
+    """Install a tool."""
+    try:
+        from hanzo_tools import get_tool_registry
+    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
+            )
+            
+            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]")
+
+
+@tools_group.command()
+@click.argument("tool_name")
+@click.pass_context
+async def uninstall(ctx, tool_name: str):
+    """Uninstall a tool."""
+    try:
+        from hanzo_tools import get_tool_registry
+    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:
+                await registry.uninstall_tool(tool_name)
+                console.print(f"[green]✓[/green] Uninstalled {tool_name}")
+            except Exception as e:
+                console.print(f"[red]Failed to uninstall {tool_name}: {e}[/red]")
+
+
+@tools_group.command()
+@click.argument("tool_name")
+@click.option("--version", "-v", help="Target version")
+@click.pass_context
+async def update(ctx, tool_name: str, version: str):
+    """Update a tool."""
+    try:
+        from hanzo_tools import get_tool_registry
+    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
+            )
+            
+            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]")
+
+
+@tools_group.command()
+@click.argument("tool_name")
+@click.pass_context
+async def info(ctx, tool_name: str):
+    """Show tool information."""
+    try:
+        from hanzo_tools import get_tool_registry
+    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)
+        console.print(syntax)
+
+
+@tools_group.command()
+@click.argument("tool_name")
+@click.argument("args", nargs=-1)
+@click.option("--json", "-j", is_flag=True, help="Output as JSON")
+@click.pass_context
+async def run(ctx, tool_name: str, args: tuple, json: bool):
+    """Run a tool directly."""
+    try:
+        from hanzo_tools import run_tool
+    except ImportError:
+        console.print("[red]Error:[/red] hanzo-tools not installed")
+        return
+    
+    # Parse arguments
+    tool_args = {}
+    for arg in args:
+        if "=" in arg:
+            key, value = arg.split("=", 1)
+            tool_args[key] = value
+        else:
+            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
+            )
+            
+            if json:
+                import json as json_lib
+                console.print_json(data=result)
+            else:
+                if isinstance(result, str):
+                    console.print(result)
+                elif isinstance(result, dict):
+                    for key, value in result.items():
+                        console.print(f"{key}: {value}")
+                else:
+                    console.print(result)
+                    
+        except Exception as e:
+            console.print(f"[red]Tool execution failed: {e}[/red]")
+
+
+@tools_group.command()
+@click.option("--check", is_flag=True, help="Check for updates only")
+@click.pass_context
+async def upgrade(ctx, check: bool):
+    """Upgrade all tools."""
+    try:
+        from hanzo_tools import get_tool_registry
+    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", "")
+        )
+    
+    console.print(table)
+    
+    if check:
+        return
+    
+    # Perform updates
+    if click.confirm(f"Update {len(updates)} tools?"):
+        for update in updates:
+            with console.status(f"Updating {update['name']}..."):
+                try:
+                    await registry.update_tool(update["name"])
+                    console.print(f"[green]✓[/green] Updated {update['name']}")
+                except Exception as e:
+                    console.print(f"[red]Failed to update {update['name']}: {e}[/red]")
+
+
+@tools_group.command()
+@click.argument("name")
+@click.option("--template", "-t", help="Tool template to use")
+@click.pass_context
+async def create(ctx, name: str, template: str):
+    """Create a new custom tool."""
+    try:
+        from hanzo_tools import create_tool_template
+    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"
+            )
+            
+            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]")

hanzo/interactive/__init__.py

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

hanzo/interactive/dashboard.py

@@ -0,0 +1,125 @@
+"""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
+
+
+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["header"].update(
+        Panel(
+            Text("Hanzo AI Dashboard", style="bold cyan", justify="center"),
+            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")
+    )
+    
+    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()
+        table.add_column("ID", style="cyan")
+        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
+[dim]2024-01-20 10:15:24[/dim] Job j002 assigned to coder
+[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"
+        )
+    )
+    
+    # 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):
+            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]")

hanzo/interactive/repl.py

@@ -0,0 +1,184 @@
+"""Interactive REPL for Hanzo CLI."""
+
+import asyncio
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+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
+
+
+class HanzoREPL:
+    """Interactive REPL for Hanzo CLI."""
+    
+    def __init__(self, console: Optional[Console] = None):
+        self.console = console or Console()
+        self.session = PromptSession(
+            history=FileHistory(".hanzo_repl_history"),
+            auto_suggest=AutoSuggestFromHistory(),
+        )
+        self.commands = {
+            "help": self.show_help,
+            "exit": self.exit_repl,
+            "quit": self.exit_repl,
+            "clear": self.clear_screen,
+            "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
+        )
+        
+        while self.running:
+            try:
+                # Get input
+                command = await self.session.prompt_async(
+                    "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 = """
+# Hanzo Interactive Mode
+
+## Built-in Commands:
+- `help` - Show this help message
+- `exit/quit` - Exit interactive mode
+- `clear` - Clear the screen
+- `status` - Show system status
+
+## CLI Commands:
+All Hanzo CLI commands are available:
+- `chat <message>` - Chat with AI
+- `agent start` - Start an agent
+- `cluster status` - Check cluster status
+- `mcp tools` - List MCP tools
+- `network agents` - List network agents
+
+## Examples:
+```
+hanzo> chat How do I create a Python web server?
+hanzo> agent list
+hanzo> cluster start --models llama-3.2-3b
+hanzo> mcp run read_file --arg path=README.md
+```
+
+## Tips:
+- Use Tab for command completion
+- Use ↑/↓ for command history
+- 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 = {
+            "cluster": await self.check_cluster_status(),
+            "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
+        
+        # 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
+        except Exception as e:
+            self.console.print(f"[red]Command error: {e}[/red]")
+        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"

hanzo/router/__init__.py

@@ -1,19 +1,25 @@
-"""Router module - re-exports from hanzo-router package."""
+"""Router module - re-exports from router package."""
 
 try:
-    # Import all exports from hanzo-router (which internally uses 'router' package name)
-    from router import *
+    # Import directly from the installed router package
+    import router
     from router import Router, completion, acompletion, embedding, aembedding
     
-    # Ensure these are explicitly available
-    __all__ = ["Router", "completion", "acompletion", "embedding", "aembedding"]
+    # Re-export the entire router module
+    __all__ = ["router", "Router", "completion", "acompletion", "embedding", "aembedding"]
+    
+    # Make router available as a submodule
+    import sys
+    sys.modules['hanzo.router'] = router
+    
 except ImportError as e:
-    # If hanzo-router is not installed, provide helpful error
+    # If router is not installed, provide helpful error
     import sys
     print(f"Error importing router: {e}", file=sys.stderr)
-    print("Please install hanzo-router: pip install hanzo[router] or pip install hanzo[all]", file=sys.stderr)
+    print("Please install router from the main repository: pip install -e /Users/z/work/hanzo/router", file=sys.stderr)
     
     # Define placeholders to avoid complete failure
+    router = None
     Router = None
     completion = None
     acompletion = None

hanzo/utils/__init__.py

@@ -0,0 +1,3 @@
+"""Utility modules for Hanzo CLI."""
+
+__all__ = ["config", "output"]