hanzo 0.3.12__py3-none-any.whl → 0.3.14__py3-none-any.whl

hanzo/cli.py

@@ -1,9 +1,9 @@
 """Main CLI entry point for Hanzo."""
 
+import os
 import sys
-import asyncio
 import signal
-import os
+import asyncio
 import subprocess
 from typing import Optional
 
@@ -26,7 +26,7 @@ from .utils.output import console
 from .interactive.repl import HanzoREPL
 
 # Version
-__version__ = "0.2.10"
+__version__ = "0.3.14"
 
 
 @click.group(invoke_without_command=True)
@@ -149,34 +149,78 @@ def node(ctx, name: str, port: int, network: str, models: tuple, max_jobs: int):
 
 @cli.command()
 @click.option("--workspace", default="~/.hanzo/dev", help="Workspace directory")
-@click.option("--orchestrator", default="gpt-5", help="Orchestrator model (e.g., gpt-5, gpt-4, claude-3-5-sonnet, local:llama3.2)")
-@click.option("--claude-path", help="Path to Claude Code executable") 
+@click.option(
+    "--orchestrator",
+    default="gpt-5",
+    help="Orchestrator: gpt-5, router:gpt-4o, direct:claude, codex, gpt-5-pro-codex, cost-optimized",
+)
+@click.option(
+    "--orchestrator-mode",
+    type=click.Choice(["router", "direct", "codex", "hybrid", "local"]),
+    default=None,
+    help="Force orchestrator mode (router via hanzo-router, direct API, codex, hybrid, local)",
+)
+@click.option(
+    "--router-endpoint",
+    default=None,
+    help="Hanzo router endpoint (default: http://localhost:4000)",
+)
+@click.option("--claude-path", help="Path to Claude Code executable")
 @click.option("--monitor", is_flag=True, help="Start in monitor mode")
 @click.option("--repl", is_flag=True, help="Start REPL interface (default)")
 @click.option("--instances", type=int, default=2, help="Number of worker agents")
 @click.option("--mcp-tools", is_flag=True, default=True, help="Enable all MCP tools")
-@click.option("--network-mode", is_flag=True, default=True, help="Network agents together")
-@click.option("--guardrails", is_flag=True, default=True, help="Enable code quality guardrails")
-@click.option("--use-network/--no-network", default=True, help="Use hanzo-network if available")
-@click.option("--use-hanzo-net", is_flag=True, help="Use hanzo/net for local AI (auto-enabled with local: models)")
-@click.option("--hanzo-net-port", type=int, default=52415, help="Port for hanzo/net (default: 52415)")
-@click.pass_context  
-def dev(ctx, workspace: str, orchestrator: str, claude_path: str, monitor: bool, repl: bool,
-        instances: int, mcp_tools: bool, network_mode: bool, guardrails: bool, use_network: bool,
-        use_hanzo_net: bool, hanzo_net_port: int):
+@click.option(
+    "--network-mode", is_flag=True, default=True, help="Network agents together"
+)
+@click.option(
+    "--guardrails", is_flag=True, default=True, help="Enable code quality guardrails"
+)
+@click.option(
+    "--use-network/--no-network", default=True, help="Use hanzo-network if available"
+)
+@click.option(
+    "--use-hanzo-net",
+    is_flag=True,
+    help="Use hanzo/net for local AI (auto-enabled with local: models)",
+)
+@click.option(
+    "--hanzo-net-port",
+    type=int,
+    default=52415,
+    help="Port for hanzo/net (default: 52415)",
+)
+@click.pass_context
+def dev(
+    ctx,
+    workspace: str,
+    orchestrator: str,
+    orchestrator_mode: str,
+    router_endpoint: str,
+    claude_path: str,
+    monitor: bool,
+    repl: bool,
+    instances: int,
+    mcp_tools: bool,
+    network_mode: bool,
+    guardrails: bool,
+    use_network: bool,
+    use_hanzo_net: bool,
+    hanzo_net_port: int,
+):
     """Start Hanzo Dev - AI Coding OS with configurable orchestrator.
-    
+
     This creates a multi-agent system where:
     - Configurable orchestrator (GPT-5, GPT-4, Claude, or LOCAL) manages the network
     - Local AI via hanzo/net for cost-effective orchestration
-    - Worker agents (Claude + local) handle code implementation  
+    - Worker agents (Claude + local) handle code implementation
     - Critic agents review and improve code (System 2 thinking)
     - Cost-optimized routing (local models for simple tasks)
     - All agents can use MCP tools
     - Agents can call each other recursively
     - Guardrails prevent code degradation
     - Auto-recovery from failures
-    
+
     Examples:
         hanzo dev                                    # GPT-5 orchestrator (default)
         hanzo dev --orchestrator gpt-4               # GPT-4 orchestrator
@@ -187,26 +231,54 @@ def dev(ctx, workspace: str, orchestrator: str, claude_path: str, monitor: bool,
         hanzo dev --monitor                          # Auto-monitor and restart mode
     """
     from .dev import run_dev_orchestrator
-    
+    from .orchestrator_config import OrchestratorMode, get_orchestrator_config
+
+    # Get orchestrator configuration
+    orch_config = get_orchestrator_config(orchestrator)
+
+    # Override mode if specified
+    if orchestrator_mode:
+        orch_config.mode = OrchestratorMode(orchestrator_mode)
+
+    # Override router endpoint if specified
+    if router_endpoint and orch_config.router:
+        orch_config.router.endpoint = router_endpoint
+
     # Auto-enable hanzo net if using local orchestrator
-    if orchestrator.startswith("local:"):
+    if orchestrator.startswith("local:") or orch_config.mode == OrchestratorMode.LOCAL:
         use_hanzo_net = True
-    
-    asyncio.run(run_dev_orchestrator(
-        workspace=workspace,
-        orchestrator_model=orchestrator,
-        claude_path=claude_path,
-        monitor=monitor,
-        repl=repl or not monitor,  # Default to REPL if not monitoring
-        instances=instances,
-        mcp_tools=mcp_tools,
-        network_mode=network_mode,
-        guardrails=guardrails,
-        use_network=use_network,
-        use_hanzo_net=use_hanzo_net,
-        hanzo_net_port=hanzo_net_port,
-        console=ctx.obj.get("console", console)
-    ))
+
+    # Show configuration
+    console.print(f"[bold cyan]Orchestrator Configuration[/bold cyan]")
+    console.print(f"  Mode: {orch_config.mode.value}")
+    console.print(f"  Primary Model: {orch_config.primary_model}")
+    if orch_config.router:
+        console.print(f"  Router Endpoint: {orch_config.router.endpoint}")
+    if orch_config.codex:
+        console.print(f"  Codex Model: {orch_config.codex.model}")
+    console.print(
+        f"  Cost Optimization: {'Enabled' if orch_config.enable_cost_optimization else 'Disabled'}"
+    )
+    console.print()
+
+    asyncio.run(
+        run_dev_orchestrator(
+            workspace=workspace,
+            orchestrator_model=orchestrator,
+            orchestrator_config=orch_config,  # Pass the config
+            claude_path=claude_path,
+            monitor=monitor,
+            repl=repl or not monitor,  # Default to REPL if not monitoring
+            instances=instances,
+            mcp_tools=mcp_tools,
+            network_mode=network_mode,
+            guardrails=guardrails,
+            use_network=use_network,
+            use_hanzo_net=use_hanzo_net,
+            hanzo_net_port=hanzo_net_port,
+            console=ctx.obj.get("console", console),
+        )
+    )
 
 
 async def start_compute_node(
@@ -279,25 +351,24 @@ async def start_compute_node(
 
                 # Set up signal handlers for async version
                 stop_event = asyncio.Event()
-                
+
                 def async_signal_handler(signum, frame):
                     console.print("\n[yellow]Stopping hanzo net...[/yellow]")
                     stop_event.set()
-                
+
                 signal.signal(signal.SIGINT, async_signal_handler)
                 signal.signal(signal.SIGTERM, async_signal_handler)
-                
+
                 # Run net with proper signal handling
                 try:
                     net_task = asyncio.create_task(net_run())
                     stop_task = asyncio.create_task(stop_event.wait())
-                    
+
                     # Wait for either net to complete or stop signal
                     done, pending = await asyncio.wait(
-                        [net_task, stop_task],
-                        return_when=asyncio.FIRST_COMPLETED
+                        [net_task, stop_task], return_when=asyncio.FIRST_COMPLETED
                     )
-                    
+
                     # Cancel pending tasks
                     for task in pending:
                         task.cancel()
@@ -305,7 +376,7 @@ async def start_compute_node(
                             await task
                         except asyncio.CancelledError:
                             pass
-                    
+
                     # Check if we stopped due to signal
                     if stop_task in done:
                         console.print("[green]✓[/green] Node stopped gracefully")
@@ -360,25 +431,25 @@ async def start_compute_node(
                 # Run net command with detected python in a more signal-friendly way
                 # Create new process group for better signal handling
                 process = subprocess.Popen(
-                    cmd_args, 
+                    cmd_args,
                     env=env,
-                    preexec_fn=os.setsid if hasattr(os, 'setsid') else None
+                    preexec_fn=os.setsid if hasattr(os, "setsid") else None,
                 )
-                
+
                 # Set up signal handlers to forward to subprocess group
                 def signal_handler(signum, frame):
                     if process.poll() is None:  # Process is still running
                         console.print("\n[yellow]Stopping hanzo net...[/yellow]")
                         try:
                             # Send signal to entire process group
-                            if hasattr(os, 'killpg'):
+                            if hasattr(os, "killpg"):
                                 os.killpg(os.getpgid(process.pid), signal.SIGTERM)
                             else:
                                 process.terminate()
                             process.wait(timeout=5)  # Wait up to 5 seconds
                         except subprocess.TimeoutExpired:
                             console.print("[yellow]Force stopping...[/yellow]")
-                            if hasattr(os, 'killpg'):
+                            if hasattr(os, "killpg"):
                                 os.killpg(os.getpgid(process.pid), signal.SIGKILL)
                             else:
                                 process.kill()
@@ -386,18 +457,16 @@ async def start_compute_node(
                         except ProcessLookupError:
                             pass  # Process already terminated
                     raise KeyboardInterrupt
-                
+
                 # Register signal handlers
                 signal.signal(signal.SIGINT, signal_handler)
                 signal.signal(signal.SIGTERM, signal_handler)
-                
+
                 # Wait for process to complete
                 returncode = process.wait()
-                
+
                 if returncode != 0 and returncode != -2:  # -2 is Ctrl+C
-                    console.print(
-                        f"[red]Net exited with code {returncode}[/red]"
-                    )
+                    console.print(f"[red]Net exited with code {returncode}[/red]")
 
             finally:
                 os.chdir(original_cwd)