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

hanzo/commands/cluster.py

@@ -0,0 +1,428 @@
+"""Cluster management commands."""
+
+import asyncio
+from typing import List, Optional
+
+import click
+import httpx
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.table import Table
+
+from ..utils.output import console, handle_errors
+
+
+@click.group(name="cluster")
+def cluster_group():
+    """Manage local AI cluster."""
+    pass
+
+
+@cluster_group.command()
+@click.option("--name", "-n", default="hanzo-local", help="Cluster name")
+@click.option("--port", "-p", default=8000, type=int, help="API port")
+@click.option("--models", "-m", multiple=True, help="Models to load")
+@click.option("--device", type=click.Choice(["cpu", "gpu", "auto"]), default="auto", help="Device to use")
+@click.pass_context
+async def start(ctx, name: str, port: int, models: tuple, device: str):
+    """Start local AI cluster."""
+    await start_cluster(ctx, name, port, list(models) if models else None, device)
+
+
+async def start_cluster(ctx, name: str, port: int, models: Optional[List[str]] = None, device: str = "auto"):
+    """Start a local cluster via hanzo-cluster."""
+    try:
+        from hanzo_cluster import HanzoCluster
+    except ImportError:
+        console.print("[red]Error:[/red] hanzo-cluster not installed")
+        console.print("Install with: pip install hanzo[cluster]")
+        return
+    
+    cluster = HanzoCluster(name=name, port=port, device=device)
+    
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        task = progress.add_task("Starting cluster...", total=None)
+        
+        try:
+            await cluster.start(models=models)
+            progress.update(task, completed=True)
+        except Exception as e:
+            progress.stop()
+            console.print(f"[red]Failed to start cluster: {e}[/red]")
+            return
+    
+    console.print(f"[green]✓[/green] Cluster started at http://localhost:{port}")
+    console.print("Press Ctrl+C to stop\n")
+    
+    # Show cluster info
+    info = await cluster.info()
+    console.print("[cyan]Cluster Information:[/cyan]")
+    console.print(f"  Name: {info.get('name', name)}")
+    console.print(f"  Port: {info.get('port', port)}")
+    console.print(f"  Device: {info.get('device', device)}")
+    console.print(f"  Nodes: {info.get('nodes', 1)}")
+    if models := info.get('models', models):
+        console.print(f"  Models: {', '.join(models)}")
+    
+    console.print("\n[dim]Logs:[/dim]")
+    
+    try:
+        # Stream logs
+        async for log in cluster.stream_logs():
+            console.print(log, end="")
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Stopping cluster...[/yellow]")
+        await cluster.stop()
+        console.print("[green]✓[/green] Cluster stopped")
+
+
+@cluster_group.command()
+@click.option("--name", "-n", default="hanzo-local", help="Cluster name")
+@click.pass_context
+async def stop(ctx, name: str):
+    """Stop local AI cluster."""
+    try:
+        from hanzo_cluster import HanzoCluster
+    except ImportError:
+        console.print("[red]Error:[/red] hanzo-cluster not installed")
+        return
+    
+    cluster = HanzoCluster(name=name)
+    
+    console.print("[yellow]Stopping cluster...[/yellow]")
+    try:
+        await cluster.stop()
+        console.print("[green]✓[/green] Cluster stopped")
+    except Exception as e:
+        console.print(f"[red]Failed to stop cluster: {e}[/red]")
+
+
+@cluster_group.command()
+@click.option("--name", "-n", default="hanzo-local", help="Cluster name")
+@click.pass_context
+async def status(ctx, name: str):
+    """Show cluster status."""
+    try:
+        from hanzo_cluster import HanzoCluster
+    except ImportError:
+        console.print("[red]Error:[/red] hanzo-cluster not installed")
+        return
+    
+    cluster = HanzoCluster(name=name)
+    
+    try:
+        status = await cluster.status()
+        
+        if status.get('running'):
+            console.print("[green]✓[/green] Cluster is running")
+            
+            # Show cluster info
+            console.print("\n[cyan]Cluster Information:[/cyan]")
+            console.print(f"  Name: {status.get('name', name)}")
+            console.print(f"  Nodes: {status.get('nodes', 0)}")
+            console.print(f"  Status: {status.get('state', 'unknown')}")
+            
+            # Show models
+            if models := status.get('models', []):
+                console.print("\n[cyan]Available Models:[/cyan]")
+                for model in models:
+                    console.print(f"  • {model}")
+            
+            # Show nodes
+            if nodes := status.get('node_details', []):
+                console.print("\n[cyan]Nodes:[/cyan]")
+                for node in nodes:
+                    console.print(f"  • {node.get('name', 'unknown')} ({node.get('state', 'unknown')})")
+                    if device := node.get('device'):
+                        console.print(f"    Device: {device}")
+        else:
+            console.print("[yellow]![/yellow] Cluster is not running")
+            console.print("Start with: hanzo cluster start")
+            
+    except Exception as e:
+        console.print(f"[red]Error checking status: {e}[/red]")
+
+
+@cluster_group.command()
+@click.option("--name", "-n", default="hanzo-local", help="Cluster name")
+@click.pass_context
+async def models(ctx, name: str):
+    """List available models."""
+    try:
+        from hanzo_cluster import HanzoCluster
+    except ImportError:
+        console.print("[red]Error:[/red] hanzo-cluster not installed")
+        return
+    
+    cluster = HanzoCluster(name=name)
+    
+    try:
+        models = await cluster.list_models()
+        
+        if models:
+            table = Table(title="Available Models")
+            table.add_column("Model ID", style="cyan")
+            table.add_column("Type", style="green")
+            table.add_column("Status", style="yellow")
+            table.add_column("Node", style="blue")
+            
+            for model in models:
+                table.add_row(
+                    model.get("id", "unknown"),
+                    model.get("type", "model"),
+                    model.get("status", "unknown"),
+                    model.get("node", "local")
+                )
+            
+            console.print(table)
+        else:
+            console.print("[yellow]No models loaded[/yellow]")
+            console.print("Load models with: hanzo cluster load <model>")
+            
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+
+
+@cluster_group.command()
+@click.argument("model")
+@click.option("--name", "-n", default="hanzo-local", help="Cluster name")
+@click.option("--node", help="Target node (default: auto-select)")
+@click.pass_context
+async def load(ctx, model: str, name: str, node: str = None):
+    """Load a model into the cluster."""
+    try:
+        from hanzo_cluster import HanzoCluster
+    except ImportError:
+        console.print("[red]Error:[/red] hanzo-cluster not installed")
+        return
+    
+    cluster = HanzoCluster(name=name)
+    
+    with console.status(f"Loading model '{model}'..."):
+        try:
+            result = await cluster.load_model(model, node=node)
+            console.print(f"[green]✓[/green] Loaded model: {model}")
+            if node_name := result.get('node'):
+                console.print(f"  Node: {node_name}")
+        except Exception as e:
+            console.print(f"[red]Failed to load model: {e}[/red]")
+
+
+@cluster_group.command()
+@click.argument("model") 
+@click.option("--name", "-n", default="hanzo-local", help="Cluster name")
+@click.pass_context
+async def unload(ctx, model: str, name: str):
+    """Unload a model from the cluster."""
+    try:
+        from hanzo_cluster import HanzoCluster
+    except ImportError:
+        console.print("[red]Error:[/red] hanzo-cluster not installed")
+        return
+    
+    cluster = HanzoCluster(name=name)
+    
+    if click.confirm(f"Unload model '{model}'?"):
+        with console.status(f"Unloading model '{model}'..."):
+            try:
+                await cluster.unload_model(model)
+                console.print(f"[green]✓[/green] Unloaded model: {model}")
+            except Exception as e:
+                console.print(f"[red]Failed to unload model: {e}[/red]")
+
+
+@cluster_group.group(name="node")
+def node_group():
+    """Manage cluster nodes."""
+    pass
+
+
+@node_group.command(name="start")
+@click.option("--name", "-n", default="node-1", help="Node name")
+@click.option("--cluster", "-c", default="hanzo-local", help="Cluster to join")
+@click.option("--device", type=click.Choice(["cpu", "gpu", "auto"]), default="auto", help="Device to use")
+@click.option("--port", "-p", type=int, help="Node port (auto-assigned if not specified)")
+@click.option("--blockchain", is_flag=True, help="Enable blockchain features")
+@click.option("--network", is_flag=True, help="Enable network discovery")
+@click.pass_context
+async def node_start(ctx, name: str, cluster: str, device: str, port: int, blockchain: bool, network: bool):
+    """Start this machine as a node in the cluster."""
+    try:
+        from hanzo_cluster import HanzoNode
+        if blockchain or network:
+            from hanzo_network import HanzoNetwork
+    except ImportError:
+        console.print("[red]Error:[/red] Required packages not installed")
+        console.print("Install with: pip install hanzo[cluster,network]")
+        return
+    
+    node = HanzoNode(name=name, device=device, port=port)
+    
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        task = progress.add_task(f"Starting node '{name}'...", total=None)
+        
+        try:
+            # Start the node
+            await node.start(cluster=cluster)
+            
+            # Enable blockchain/network features if requested
+            if blockchain or network:
+                network_mgr = HanzoNetwork(node=node)
+                if blockchain:
+                    await network_mgr.enable_blockchain()
+                if network:
+                    await network_mgr.enable_discovery()
+            
+            progress.update(task, completed=True)
+        except Exception as e:
+            progress.stop()
+            console.print(f"[red]Failed to start node: {e}[/red]")
+            return
+    
+    console.print(f"[green]✓[/green] Node '{name}' started")
+    console.print(f"  Cluster: {cluster}")
+    console.print(f"  Device: {device}")
+    if port:
+        console.print(f"  Port: {port}")
+    if blockchain:
+        console.print("  [cyan]Blockchain enabled[/cyan]")
+    if network:
+        console.print("  [cyan]Network discovery enabled[/cyan]")
+    
+    console.print("\nPress Ctrl+C to stop\n")
+    console.print("[dim]Logs:[/dim]")
+    
+    try:
+        # Stream logs
+        async for log in node.stream_logs():
+            console.print(log, end="")
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Stopping node...[/yellow]")
+        await node.stop()
+        console.print("[green]✓[/green] Node stopped")
+
+
+@node_group.command(name="stop")
+@click.option("--name", "-n", help="Node name")
+@click.option("--all", is_flag=True, help="Stop all nodes")
+@click.pass_context
+async def node_stop(ctx, name: str, all: bool):
+    """Stop a node."""
+    try:
+        from hanzo_cluster import HanzoNode
+    except ImportError:
+        console.print("[red]Error:[/red] hanzo-cluster not installed")
+        return
+    
+    if all:
+        if click.confirm("Stop all nodes?"):
+            console.print("[yellow]Stopping all nodes...[/yellow]")
+            try:
+                await HanzoNode.stop_all()
+                console.print("[green]✓[/green] All nodes stopped")
+            except Exception as e:
+                console.print(f"[red]Failed to stop nodes: {e}[/red]")
+    elif name:
+        node = HanzoNode(name=name)
+        console.print(f"[yellow]Stopping node '{name}'...[/yellow]")
+        try:
+            await node.stop()
+            console.print(f"[green]✓[/green] Node stopped")
+        except Exception as e:
+            console.print(f"[red]Failed to stop node: {e}[/red]")
+    else:
+        console.print("[red]Error:[/red] Specify --name or --all")
+
+
+@node_group.command(name="list")
+@click.option("--cluster", "-c", help="Filter by cluster")
+@click.pass_context
+async def node_list(ctx, cluster: str):
+    """List all nodes."""
+    try:
+        from hanzo_cluster import HanzoNode
+    except ImportError:
+        console.print("[red]Error:[/red] hanzo-cluster not installed")
+        return
+    
+    try:
+        nodes = await HanzoNode.list_nodes(cluster=cluster)
+        
+        if nodes:
+            table = Table(title="Cluster Nodes")
+            table.add_column("Name", style="cyan")
+            table.add_column("Cluster", style="green")
+            table.add_column("Device", style="yellow")
+            table.add_column("Status", style="blue")
+            table.add_column("Models", style="magenta")
+            
+            for node in nodes:
+                table.add_row(
+                    node.get("name", "unknown"),
+                    node.get("cluster", "unknown"),
+                    node.get("device", "unknown"),
+                    node.get("status", "unknown"),
+                    str(len(node.get("models", [])))
+                )
+            
+            console.print(table)
+        else:
+            console.print("[yellow]No nodes found[/yellow]")
+            console.print("Start a node with: hanzo cluster node start")
+            
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+
+
+@node_group.command(name="info")
+@click.argument("name")
+@click.pass_context
+async def node_info(ctx, name: str):
+    """Show detailed node information."""
+    try:
+        from hanzo_cluster import HanzoNode
+    except ImportError:
+        console.print("[red]Error:[/red] hanzo-cluster not installed")
+        return
+    
+    node = HanzoNode(name=name)
+    
+    try:
+        info = await node.info()
+        
+        console.print(f"[cyan]Node: {name}[/cyan]")
+        console.print(f"  Cluster: {info.get('cluster', 'unknown')}")
+        console.print(f"  Status: {info.get('status', 'unknown')}")
+        console.print(f"  Device: {info.get('device', 'unknown')}")
+        
+        if uptime := info.get('uptime'):
+            console.print(f"  Uptime: {uptime}")
+        
+        if resources := info.get('resources'):
+            console.print("\n[cyan]Resources:[/cyan]")
+            console.print(f"  CPU: {resources.get('cpu_percent', 'N/A')}%")
+            console.print(f"  Memory: {resources.get('memory_used', 'N/A')} / {resources.get('memory_total', 'N/A')}")
+            if gpu := resources.get('gpu'):
+                console.print(f"  GPU: {gpu.get('name', 'N/A')} ({gpu.get('memory_used', 'N/A')} / {gpu.get('memory_total', 'N/A')})")
+        
+        if models := info.get('models'):
+            console.print("\n[cyan]Loaded Models:[/cyan]")
+            for model in models:
+                console.print(f"  • {model}")
+        
+        if network := info.get('network'):
+            console.print("\n[cyan]Network:[/cyan]")
+            console.print(f"  Blockchain: {'enabled' if network.get('blockchain') else 'disabled'}")
+            console.print(f"  Discovery: {'enabled' if network.get('discovery') else 'disabled'}")
+            if peers := network.get('peers'):
+                console.print(f"  Peers: {len(peers)}")
+        
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")

hanzo/commands/config.py

@@ -0,0 +1,240 @@
+"""Configuration management commands."""
+
+import json
+from pathlib import Path
+from typing import Any, Optional
+
+import click
+import yaml
+from rich.syntax import Syntax
+
+from ..utils.output import console, handle_errors
+
+
+@click.group(name="config")
+def config_group():
+    """Manage Hanzo configuration."""
+    pass
+
+
+@config_group.command()
+@click.option("--global", "is_global", is_flag=True, help="Show global config")
+@click.option("--local", "is_local", is_flag=True, help="Show local config")
+@click.option("--system", is_flag=True, help="Show system config")
+@click.pass_context
+def show(ctx, is_global: bool, is_local: bool, system: bool):
+    """Show configuration."""
+    from ..utils.config import load_config, get_config_paths
+    
+    # Determine which configs to show
+    show_all = not (is_global or is_local or system)
+    
+    configs = {}
+    paths = get_config_paths()
+    
+    if show_all or system:
+        if paths["system"].exists():
+            configs["System"] = (paths["system"], load_config(paths["system"]))
+    
+    if show_all or is_global:
+        if paths["global"].exists():
+            configs["Global"] = (paths["global"], load_config(paths["global"]))
+    
+    if show_all or is_local:
+        if paths["local"].exists():
+            configs["Local"] = (paths["local"], load_config(paths["local"]))
+    
+    # Merge and show
+    if configs:
+        for name, (path, config) in configs.items():
+            console.print(f"[cyan]{name} Config:[/cyan] {path}")
+            
+            # Pretty print config
+            if config:
+                syntax = Syntax(
+                    yaml.dump(config, default_flow_style=False),
+                    "yaml",
+                    theme="monokai",
+                    line_numbers=False
+                )
+                console.print(syntax)
+            else:
+                console.print("[dim]Empty[/dim]")
+            console.print()
+    else:
+        console.print("[yellow]No configuration found[/yellow]")
+        console.print("Create one with: hanzo config set <key> <value>")
+
+
+@config_group.command()
+@click.argument("key")
+@click.argument("value")
+@click.option("--global", "is_global", is_flag=True, help="Set in global config")
+@click.option("--local", "is_local", is_flag=True, help="Set in local config")
+@click.pass_context
+def set(ctx, key: str, value: str, is_global: bool, is_local: bool):
+    """Set configuration value."""
+    from ..utils.config import load_config, save_config, get_config_paths
+    
+    # Determine target config
+    paths = get_config_paths()
+    
+    if is_local:
+        config_path = paths["local"]
+        config_name = "local"
+    else:  # Default to global
+        config_path = paths["global"]
+        config_name = "global"
+    
+    # Load existing config
+    config = load_config(config_path) if config_path.exists() else {}
+    
+    # Parse value
+    try:
+        # Try to parse as JSON first
+        parsed_value = json.loads(value)
+    except json.JSONDecodeError:
+        # Check for boolean strings
+        if value.lower() == "true":
+            parsed_value = True
+        elif value.lower() == "false":
+            parsed_value = False
+        else:
+            # Keep as string
+            parsed_value = value
+    
+    # Set value (support nested keys with dot notation)
+    keys = key.split(".")
+    current = config
+    
+    for k in keys[:-1]:
+        if k not in current:
+            current[k] = {}
+        current = current[k]
+    
+    current[keys[-1]] = parsed_value
+    
+    # Save config
+    save_config(config_path, config)
+    
+    console.print(f"[green]✓[/green] Set {key} = {parsed_value} in {config_name} config")
+
+
+@config_group.command()
+@click.argument("key")
+@click.option("--global", "is_global", is_flag=True, help="Get from global config")
+@click.option("--local", "is_local", is_flag=True, help="Get from local config")
+@click.pass_context
+def get(ctx, key: str, is_global: bool, is_local: bool):
+    """Get configuration value."""
+    from ..utils.config import get_config_value
+    
+    scope = "local" if is_local else ("global" if is_global else None)
+    value = get_config_value(key, scope=scope)
+    
+    if value is not None:
+        if isinstance(value, (dict, list)):
+            console.print_json(data=value)
+        else:
+            console.print(value)
+    else:
+        console.print(f"[yellow]Key not found: {key}[/yellow]")
+
+
+@config_group.command()
+@click.argument("key")
+@click.option("--global", "is_global", is_flag=True, help="Unset from global config")
+@click.option("--local", "is_local", is_flag=True, help="Unset from local config")
+@click.pass_context
+def unset(ctx, key: str, is_global: bool, is_local: bool):
+    """Unset configuration value."""
+    from ..utils.config import load_config, save_config, get_config_paths
+    
+    # Determine target config
+    paths = get_config_paths()
+    
+    if is_local:
+        config_path = paths["local"]
+        config_name = "local"
+    else:  # Default to global
+        config_path = paths["global"]
+        config_name = "global"
+    
+    if not config_path.exists():
+        console.print(f"[yellow]No {config_name} config found[/yellow]")
+        return
+    
+    # Load config
+    config = load_config(config_path)
+    
+    # Remove value (support nested keys)
+    keys = key.split(".")
+    current = config
+    
+    try:
+        for k in keys[:-1]:
+            current = current[k]
+        
+        if keys[-1] in current:
+            del current[keys[-1]]
+            save_config(config_path, config)
+            console.print(f"[green]✓[/green] Unset {key} from {config_name} config")
+        else:
+            console.print(f"[yellow]Key not found: {key}[/yellow]")
+    except KeyError:
+        console.print(f"[yellow]Key not found: {key}[/yellow]")
+
+
+@config_group.command()
+@click.option("--system", is_flag=True, help="Edit system config")
+@click.option("--global", "is_global", is_flag=True, help="Edit global config")
+@click.option("--local", "is_local", is_flag=True, help="Edit local config")
+@click.pass_context
+def edit(ctx, system: bool, is_global: bool, is_local: bool):
+    """Edit configuration file in editor."""
+    import os
+    import subprocess
+    from ..utils.config import get_config_paths
+    
+    # Determine which config to edit
+    paths = get_config_paths()
+    
+    if system:
+        config_path = paths["system"]
+    elif is_local:
+        config_path = paths["local"]
+    else:  # Default to global
+        config_path = paths["global"]
+    
+    # Ensure file exists
+    if not config_path.exists():
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        config_path.write_text("# Hanzo configuration\n")
+    
+    # Get editor
+    editor = os.environ.get("EDITOR", "vi")
+    
+    # Open in editor
+    try:
+        subprocess.run([editor, str(config_path)], check=True)
+        console.print(f"[green]✓[/green] Edited {config_path}")
+    except subprocess.CalledProcessError:
+        console.print(f"[red]Failed to open editor[/red]")
+    except FileNotFoundError:
+        console.print(f"[red]Editor not found: {editor}[/red]")
+        console.print("Set EDITOR environment variable to specify editor")
+
+
+@config_group.command()
+@click.pass_context
+def init(ctx):
+    """Initialize configuration."""
+    from ..utils.config import init_config
+    
+    try:
+        paths = init_config()
+        console.print("[green]✓[/green] Initialized configuration")
+        console.print(f"  Global: {paths['global']}")
+        console.print(f"  Local: {paths.get('local', 'Not in project')}")
+    except Exception as e:
+        console.print(f"[red]Failed to initialize config: {e}[/red]")