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

hanzo/__init__.py

@@ -1,95 +1,6 @@
-"""Hanzo AI - Complete AI Infrastructure Platform SDK.
+"""Hanzo - Complete AI Infrastructure Platform with CLI, Router, MCP, and Agent Runtime."""
 
-This is the main Hanzo SDK that provides:
-- Router for LLM gateway (replaces litellm)
-- MCP (Model Context Protocol) server and tools
-- Agent runtime and orchestration
-- Memory systems
-- Network capabilities
+__version__ = "0.2.5"
+__all__ = ["main", "cli"]
 
-CLI access is provided via the hanzo-cli package.
-"""
-
-__version__ = "0.2.2"
-
-# Core exports
-__all__ = [
-    # Version
-    "__version__",
-    
-    # Router (primary LLM interface - replaces litellm)
-    "router",
-    "Router",
-    "completion",
-    "acompletion",
-    "embedding",
-    "aembedding",
-    
-    # MCP
-    "mcp",
-    "MCPServer",
-    "Tool",
-    
-    # Agents
-    "Agent",
-    "Network", 
-    "AgentTool",
-    
-    # Memory
-    "Memory",
-    "MemoryKV",
-    "MemoryVector",
-    
-    # Core SDK
-    "Client",
-    "AsyncClient",
-]
-
-# Export router as the primary LLM interface (replaces litellm)
-try:
-    from . import router
-    from .router import Router, completion, acompletion, embedding, aembedding
-    # Make router the default for LLM operations
-    llm = router  # Compatibility alias
-except ImportError:
-    router = None
-    Router = None
-    completion = None
-    acompletion = None
-    embedding = None
-    aembedding = None
-    llm = None
-
-# Export MCP capabilities
-try:
-    import hanzo_mcp as mcp
-    from hanzo_mcp import Tool
-    from hanzo_mcp.server import MCPServer
-except ImportError:
-    mcp = None
-    Tool = None
-    MCPServer = None
-
-# Export agent components
-try:
-    from hanzo_agents import Agent, Network
-    from hanzo_agents.core.tool import Tool as AgentTool
-except ImportError:
-    Agent = None
-    Network = None
-    AgentTool = None
-
-# Export memory systems
-try:
-    from hanzo_memory import Memory, MemoryKV, MemoryVector
-except ImportError:
-    Memory = None
-    MemoryKV = None
-    MemoryVector = None
-
-# Export main SDK client
-try:
-    from hanzoai import Client, AsyncClient
-except ImportError:
-    Client = None
-    AsyncClient = None
+from .cli import main, cli

hanzo/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for python -m hanzo_cli."""
+
+from .cli import main
+
+if __name__ == "__main__":
+    main()

hanzo/cli.py

@@ -1,18 +1,242 @@
-"""Main CLI entry point for Hanzo AI."""
+"""Main CLI entry point for Hanzo."""
 
+import asyncio
 import sys
+from typing import Optional
+
 import click
-from importlib import import_module
+from rich.console import Console
+
+from .commands import agent, auth, chat, cluster, config, mcp, miner, network, repl, tools
+from .interactive.repl import HanzoREPL
+from .utils.output import console
+
+# Version
+__version__ = "0.2.5"
+
+
+@click.group(invoke_without_command=True)
+@click.version_option(version=__version__, prog_name="hanzo")
+@click.option("--verbose", "-v", is_flag=True, help="Verbose output")
+@click.option("--json", is_flag=True, help="JSON output format")
+@click.option("--config", "-c", type=click.Path(), help="Config file path")
+@click.pass_context
+def cli(ctx, verbose: bool, json: bool, config: Optional[str]):
+    """Hanzo AI - Unified CLI for local, private, and free AI.
+    
+    Run without arguments to enter interactive mode.
+    """
+    # Ensure context object exists
+    ctx.ensure_object(dict)
+    ctx.obj["verbose"] = verbose
+    ctx.obj["json"] = json
+    ctx.obj["config"] = config
+    ctx.obj["console"] = console
+    
+    # If no subcommand, enter interactive mode or start compute node
+    if ctx.invoked_subcommand is None:
+        # Check if we should start as a compute node
+        import os
+        if os.environ.get("HANZO_COMPUTE_NODE") == "1":
+            # Start as a compute node
+            from .commands import network
+            asyncio.run(start_compute_node(ctx))
+        else:
+            # Enter interactive REPL mode
+            console.print("[bold cyan]Hanzo AI - Interactive Mode[/bold cyan]")
+            console.print("Type 'help' for commands, 'exit' to quit\n")
+            try:
+                repl = HanzoREPL(console=console)
+                asyncio.run(repl.run())
+            except KeyboardInterrupt:
+                console.print("\n[yellow]Interrupted[/yellow]")
+            except EOFError:
+                console.print("\n[yellow]Goodbye![/yellow]")
+
+
+# Register command groups
+cli.add_command(agent.agent_group)
+cli.add_command(auth.auth_group)
+cli.add_command(cluster.cluster_group)
+cli.add_command(mcp.mcp_group)
+cli.add_command(miner.miner_group)
+cli.add_command(chat.chat_command)
+cli.add_command(repl.repl_group)
+cli.add_command(tools.tools_group)
+cli.add_command(network.network_group)
+cli.add_command(config.config_group)
+
+
+# Quick aliases
+@cli.command()
+@click.argument("prompt", nargs=-1, required=True)
+@click.option("--model", "-m", default="llama-3.2-3b", help="Model to use")
+@click.option("--local/--cloud", default=True, help="Use local or cloud model")
+@click.pass_context
+def ask(ctx, prompt: tuple, model: str, local: bool):
+    """Quick question to AI (alias for 'hanzo chat --once')."""
+    prompt_text = " ".join(prompt)
+    asyncio.run(chat.ask_once(ctx, prompt_text, model, local))
+
+
+@cli.command()
+@click.option("--name", "-n", default="hanzo-local", help="Cluster name")
+@click.option("--port", "-p", default=8000, help="API port")
+@click.pass_context
+def serve(ctx, name: str, port: int):
+    """Start local AI cluster (alias for 'hanzo cluster start')."""
+    asyncio.run(cluster.start_cluster(ctx, name, port))
+
+
+@cli.command()
+@click.option("--name", "-n", help="Node name (auto-generated if not provided)")
+@click.option("--port", "-p", default=52415, help="Node port (default: 52415 for hanzo/net)")
+@click.option("--network", default="local", help="Network to join (mainnet/testnet/local)")
+@click.option("--models", "-m", multiple=True, help="Models to serve (e.g., llama-3.2-3b)")
+@click.option("--max-jobs", type=int, default=10, help="Max concurrent jobs")
+@click.pass_context
+def node(ctx, name: str, port: int, network: str, models: tuple, max_jobs: int):
+    """Start as a compute node for the Hanzo network using hanzo/net."""
+    asyncio.run(start_compute_node(ctx, name, port, network, models, max_jobs))
+
+
+async def start_compute_node(ctx, name: str = None, port: int = 52415, 
+                            network: str = "mainnet", models: tuple = None, 
+                            max_jobs: int = 10):
+    """Start this instance as a compute node using hanzo/net."""
+    console = ctx.obj.get("console", Console())
+    
+    console.print("[bold cyan]Starting Hanzo Net Compute Node[/bold cyan]")
+    console.print(f"Network: {network}")
+    console.print(f"Port: {port}")
+    
+    try:
+        import subprocess
+        import sys
+        import os
+        
+        # Check if hanzo/net is available
+        net_path = "/Users/z/work/hanzo/net"
+        if not os.path.exists(net_path):
+            # Try to find net in the Python environment
+            try:
+                import net
+                # net is installed as a package
+                console.print("[green]✓[/green] Using installed hanzo/net")
+                
+                # Run net directly
+                from net.main import run as net_run
+                
+                # Set up environment for net
+                if models:
+                    os.environ["NET_MODELS"] = ",".join(models)
+                if name:
+                    os.environ["NET_NODE_NAME"] = name
+                
+                console.print(f"\n[green]✓[/green] Node initialized")
+                console.print(f"  Port: {port}")
+                console.print(f"  Models: {', '.join(models) if models else 'auto-detect'}")
+                console.print("\n[bold green]Hanzo Net is running![/bold green]")
+                console.print("WebUI: http://localhost:52415")
+                console.print("API: http://localhost:52415/v1/chat/completions")
+                console.print("\nPress Ctrl+C to stop\n")
+                
+                # Run net
+                await net_run()
+                
+            except ImportError:
+                # net not installed, try to run from source
+                console.print("[yellow]hanzo/net not installed, checking for source...[/yellow]")
+                
+                if os.path.exists(net_path):
+                    console.print(f"[green]✓[/green] Found hanzo/net at {net_path}")
+                    
+                    # Add net to Python path
+                    sys.path.insert(0, os.path.join(net_path, "src"))
+                    
+                    # Import and run net
+                    from net.main import run as net_run
+                    
+                    console.print(f"\n[green]✓[/green] Starting net node")
+                    console.print(f"  Port: {port}")
+                    console.print(f"  Models: {', '.join(models) if models else 'auto-detect'}")
+                    console.print("\n[bold green]Hanzo Net is running![/bold green]")
+                    console.print("WebUI: http://localhost:52415")
+                    console.print("API: http://localhost:52415/v1/chat/completions")
+                    console.print("\nPress Ctrl+C to stop\n")
+                    
+                    # Run net
+                    await net_run()
+                else:
+                    console.print("[red]Error:[/red] hanzo/net not found")
+                    console.print("\nInstall hanzo/net:")
+                    console.print("  git clone https://github.com/hanzoai/net.git")
+                    console.print("  cd net && pip install -e .")
+                    return
+        else:
+            # Run from source directory
+            console.print(f"[green]✓[/green] Using hanzo/net from {net_path}")
+            
+            # Change to net directory and run
+            original_cwd = os.getcwd()
+            try:
+                os.chdir(net_path)
+                
+                # Set up environment
+                env = os.environ.copy()
+                if models:
+                    env["NET_MODELS"] = ",".join(models)
+                if name:
+                    env["NET_NODE_NAME"] = name
+                
+                console.print(f"\n[green]✓[/green] Starting net node")
+                console.print(f"  Port: {port}")
+                console.print(f"  Models: {', '.join(models) if models else 'auto-detect'}")
+                console.print("\n[bold green]Hanzo Net is running![/bold green]")
+                console.print("WebUI: http://localhost:52415")
+                console.print("API: http://localhost:52415/v1/chat/completions")
+                console.print("\nPress Ctrl+C to stop\n")
+                
+                # Add src to path and run net
+                env["PYTHONPATH"] = os.path.join(net_path, "src") + ":" + env.get("PYTHONPATH", "")
+                
+                # Run net command
+                process = subprocess.run(
+                    [sys.executable, "-c", "from net.main import run; run()"],
+                    env=env,
+                    check=False
+                )
+                
+                if process.returncode != 0 and process.returncode != -2:  # -2 is Ctrl+C
+                    console.print(f"[red]Net exited with code {process.returncode}[/red]")
+                    
+            finally:
+                os.chdir(original_cwd)
+        
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Shutting down node...[/yellow]")
+        console.print("[green]✓[/green] Node stopped")
+    except Exception as e:
+        console.print(f"[red]Error starting compute node: {e}[/red]")
+
+
+@cli.command()
+@click.pass_context
+def dashboard(ctx):
+    """Open interactive dashboard."""
+    from .interactive.dashboard import run_dashboard
+    run_dashboard()
 
 
 def main():
-    """Main entry point for hanzo command - delegates to hanzo-cli."""
+    """Main entry point."""
     try:
-        # Import and run hanzo_cli
-        from hanzo_cli.cli import main as cli_main
-        cli_main()
-    except ImportError:
-        click.echo("Error: hanzo-cli is not installed. Please run: pip install hanzo[all]", err=True)
+        cli(auto_envvar_prefix="HANZO")
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Interrupted by user[/yellow]")
+        sys.exit(0)
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
         sys.exit(1)
 
 

hanzo/commands/__init__.py

@@ -0,0 +1,3 @@
+"""Command modules for Hanzo CLI."""
+
+__all__ = ["agent", "auth", "chat", "cluster", "config", "mcp", "miner", "network", "repl", "tools"]

hanzo/commands/agent.py

@@ -0,0 +1,112 @@
+"""Agent management commands."""
+
+import asyncio
+from typing import List, Optional
+
+import click
+from rich.table import Table
+
+from ..utils.output import console, handle_errors
+
+
+@click.group(name="agent")
+def agent_group():
+    """Manage AI agents."""
+    pass
+
+
+@agent_group.command()
+@click.option("--name", "-n", required=True, help="Agent name")
+@click.option("--model", "-m", default="llama-3.2-3b", help="Model to use")
+@click.option("--description", "-d", help="Agent description")
+@click.option("--local/--cloud", default=True, help="Use local or cloud model")
+@click.pass_context
+@handle_errors
+async def create(ctx, name: str, model: str, description: Optional[str], local: bool):
+    """Create a new agent."""
+    try:
+        from hanzoai.agents import create_agent
+    except ImportError:
+        console.print("[red]Error:[/red] hanzo-agents not installed")
+        console.print("Install with: pip install hanzo[agents]")
+        return
+    
+    base_url = "http://localhost:8000" if local else None
+    
+    with console.status(f"Creating agent '{name}'..."):
+        agent = create_agent(
+            name=name,
+            model=model,
+            base_url=base_url
+        )
+    
+    console.print(f"[green]✓[/green] Created agent: {name}")
+    console.print(f"  Model: {model}")
+    console.print(f"  Mode: {'local' if local else 'cloud'}")
+
+
+@agent_group.command()
+@click.pass_context
+def list(ctx):
+    """List available agents."""
+    # TODO: Connect to agent registry
+    table = Table(title="Available Agents")
+    table.add_column("Name", style="cyan", no_wrap=True)
+    table.add_column("Model", style="green")
+    table.add_column("Status", style="yellow")
+    table.add_column("Description")
+    
+    # Mock data for now
+    agents = [
+        ("helper", "llama-3.2-3b", "active", "General purpose assistant"),
+        ("coder", "codellama-7b", "idle", "Code generation specialist"),
+        ("researcher", "llama-3.2-3b", "idle", "Research and analysis"),
+    ]
+    
+    for name, model, status, desc in agents:
+        table.add_row(name, model, status, desc)
+    
+    console.print(table)
+
+
+@agent_group.command()
+@click.argument("agents", nargs=-1, required=True)
+@click.option("--task", "-t", required=True, help="Task to execute")
+@click.option("--parallel", "-p", is_flag=True, help="Run agents in parallel")
+@click.option("--timeout", type=int, help="Timeout in seconds")
+@click.pass_context
+@handle_errors
+async def run(ctx, agents: tuple, task: str, parallel: bool, timeout: Optional[int]):
+    """Run a task with specified agents."""
+    try:
+        from hanzoai.agents import create_network
+    except ImportError:
+        console.print("[red]Error:[/red] hanzo-agents not installed")
+        console.print("Install with: pip install hanzo[agents]")
+        return
+    
+    agent_list = list(agents)
+    
+    with console.status(f"Running task with {len(agent_list)} agents..."):
+        # Create network with agents
+        network = create_network(agents=agent_list)
+        
+        # Run task
+        result = await asyncio.wait_for(
+            network.run(task),
+            timeout=timeout
+        ) if timeout else await network.run(task)
+    
+    console.print("[green]Task completed![/green]")
+    console.print(result)
+
+
+@agent_group.command()
+@click.argument("agent")
+@click.pass_context
+def delete(ctx, agent: str):
+    """Delete an agent."""
+    if click.confirm(f"Delete agent '{agent}'?"):
+        console.print(f"[yellow]Deleted agent: {agent}[/yellow]")
+    else:
+        console.print("Cancelled")