hanzo 0.3.10__tar.gz → 0.3.12__tar.gz

{hanzo-0.3.10 → hanzo-0.3.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hanzo
-Version: 0.3.10
+Version: 0.3.12
 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
@@ -14,16 +14,13 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Requires-Dist: click>=8.1.0
-Requires-Dist: hanzo-net>=0.1.12
 Requires-Dist: httpx>=0.23.0
 Requires-Dist: prompt-toolkit>=3.0.0
 Requires-Dist: pydantic>=2.0.0

{hanzo-0.3.10 → hanzo-0.3.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hanzo"
-version = "0.3.10"
+version = "0.3.12"
 description = "Hanzo AI - Complete AI Infrastructure Platform with CLI, Router, MCP, and Agent Runtime"
 authors = [
     {name = "Hanzo AI", email = "dev@hanzo.ai"},
@@ -13,10 +13,9 @@ dependencies = [
     "httpx>=0.23.0",
     "pydantic>=2.0.0",
     "pyyaml>=6.0",
-    "hanzo-net>=0.1.12",
 ]
 readme = "README.md"
-requires-python = ">= 3.8"
+requires-python = ">= 3.10"
 keywords = ["ai", "cli", "hanzo", "agents", "llm", "mcp", "local-ai", "private-ai"]
 classifiers = [
     "Development Status :: 4 - Beta",
@@ -25,8 +24,6 @@ classifiers = [
     "License :: OSI Approved :: Apache Software License",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",

{hanzo-0.3.10 → hanzo-0.3.12}/src/hanzo/cli.py

@@ -2,6 +2,9 @@
 
 import sys
 import asyncio
+import signal
+import os
+import subprocess
 from typing import Optional
 
 import click
@@ -115,7 +118,11 @@ def serve(ctx, name: str, port: int):
 @click.pass_context
 def net(ctx, name: str, port: int, network: str, models: tuple, max_jobs: int):
     """Start the Hanzo Network distributed AI compute node."""
-    asyncio.run(start_compute_node(ctx, name, port, network, models, max_jobs))
+    try:
+        asyncio.run(start_compute_node(ctx, name, port, network, models, max_jobs))
+    except KeyboardInterrupt:
+        # Already handled in start_compute_node
+        pass
 
 
 @cli.command()
@@ -133,7 +140,73 @@ def net(ctx, name: str, port: int, network: str, models: tuple, max_jobs: int):
 @click.pass_context
 def node(ctx, name: str, port: int, network: str, models: tuple, max_jobs: int):
     """Alias for 'hanzo net' - Start as a compute node for the Hanzo network."""
-    asyncio.run(start_compute_node(ctx, name, port, network, models, max_jobs))
+    try:
+        asyncio.run(start_compute_node(ctx, name, port, network, models, max_jobs))
+    except KeyboardInterrupt:
+        # Already handled in start_compute_node
+        pass
+
+
+@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("--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):
+    """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  
+    - 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
+        hanzo dev --orchestrator claude-3-5-sonnet   # Claude orchestrator
+        hanzo dev --orchestrator local:llama3.2      # Local Llama 3.2 via hanzo/net
+        hanzo dev --use-hanzo-net                    # Enable local AI workers
+        hanzo dev --instances 4                      # More worker agents
+        hanzo dev --monitor                          # Auto-monitor and restart mode
+    """
+    from .dev import run_dev_orchestrator
+    
+    # Auto-enable hanzo net if using local orchestrator
+    if orchestrator.startswith("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)
+    ))
 
 
 async def start_compute_node(
@@ -204,8 +277,40 @@ async def start_compute_node(
                 console.print("API: http://localhost:52415/v1/chat/completions")
                 console.print("\nPress Ctrl+C to stop\n")
 
-                # Run net
-                await net_run()
+                # 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
+                    )
+                    
+                    # Cancel pending tasks
+                    for task in pending:
+                        task.cancel()
+                        try:
+                            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")
+                except asyncio.CancelledError:
+                    console.print("[yellow]Cancelled[/yellow]")
             finally:
                 sys.argv = original_argv
         else:
@@ -252,12 +357,46 @@ async def start_compute_node(
                 if models:
                     cmd_args.extend(["--default-model", models[0]])
 
-                # Run net command with detected python
-                process = subprocess.run(cmd_args, env=env, check=False)
-
-                if process.returncode != 0 and process.returncode != -2:  # -2 is Ctrl+C
+                # 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, 
+                    env=env,
+                    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'):
+                                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'):
+                                os.killpg(os.getpgid(process.pid), signal.SIGKILL)
+                            else:
+                                process.kill()
+                            process.wait()
+                        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 {process.returncode}[/red]"
+                        f"[red]Net exited with code {returncode}[/red]"
                     )
 
             finally: