hanzo 0.2.3__tar.gz → 0.2.5__tar.gz

{hanzo-0.2.3 → hanzo-0.2.5}/.gitignore

@@ -1,7 +1,7 @@
 .prism.log
 .vscode
 _dev
-
+*.egg-info
 __pycache__
 .mypy_cache
 

{hanzo-0.2.3 → hanzo-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hanzo
-Version: 0.2.3
+Version: 0.2.5
 Summary: Hanzo AI - Complete AI Infrastructure Platform with CLI, Router, MCP, and Agent Runtime
 Project-URL: Homepage, https://hanzo.ai
 Project-URL: Repository, https://github.com/hanzoai/python-sdk
@@ -23,8 +23,12 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.8
 Requires-Dist: click>=8.1.0
-Requires-Dist: hanzo-cli>=0.1.0
+Requires-Dist: httpx>=0.23.0
+Requires-Dist: prompt-toolkit>=3.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pyyaml>=6.0
 Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.9.0
 Provides-Extra: agents
 Requires-Dist: hanzo-agents>=0.1.0; extra == 'agents'
 Requires-Dist: hanzo-network>=0.1.0; extra == 'agents'
@@ -33,7 +37,6 @@ Requires-Dist: hanzoai>=1.0.0; extra == 'ai'
 Provides-Extra: all
 Requires-Dist: hanzo-aci>=0.2.8; extra == 'all'
 Requires-Dist: hanzo-agents>=0.1.0; extra == 'all'
-Requires-Dist: hanzo-mcp-client>=0.1.0; extra == 'all'
 Requires-Dist: hanzo-mcp>=0.7.0; extra == 'all'
 Requires-Dist: hanzo-memory>=1.0.0; extra == 'all'
 Requires-Dist: hanzo-network>=0.1.0; extra == 'all'

{hanzo-0.2.3 → hanzo-0.2.5}/pyproject.toml

@@ -1,14 +1,18 @@
 [project]
 name = "hanzo"
-version = "0.2.3"
+version = "0.2.5"
 description = "Hanzo AI - Complete AI Infrastructure Platform with CLI, Router, MCP, and Agent Runtime"
 authors = [
     {name = "Hanzo AI", email = "dev@hanzo.ai"},
 ]
 dependencies = [
-    "hanzo-cli>=0.1.0",
     "click>=8.1.0",
     "rich>=13.0.0",
+    "typer>=0.9.0",
+    "prompt-toolkit>=3.0.0",
+    "httpx>=0.23.0",
+    "pydantic>=2.0.0",
+    "pyyaml>=6.0",
 ]
 readme = "README.md"
 requires-python = ">= 3.8"
@@ -45,7 +49,6 @@ all = [
     "hanzo-repl>=0.1.0",
     "hanzo-memory>=1.0.0",
     # "hanzo-router>=1.74.3",  # TODO: Publish hanzo-router to PyPI
-    "hanzo-mcp-client>=0.1.0",
     "hanzo-aci>=0.2.8",
 ]
 ai = [

hanzo-0.2.5/src/hanzo/__init__.py

@@ -0,0 +1,6 @@
+"""Hanzo - Complete AI Infrastructure Platform with CLI, Router, MCP, and Agent Runtime."""
+
+__version__ = "0.2.5"
+__all__ = ["main", "cli"]
+
+from .cli import main, cli

hanzo-0.2.5/src/hanzo/__main__.py

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

hanzo-0.2.5/src/hanzo/cli.py

@@ -0,0 +1,244 @@
+"""Main CLI entry point for Hanzo."""
+
+import asyncio
+import sys
+from typing import Optional
+
+import click
+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."""
+    try:
+        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)
+
+
+if __name__ == "__main__":
+    main()

hanzo-0.2.5/src/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-0.2.5/src/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")