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

hanzo/commands/network.py

@@ -0,0 +1,333 @@
+"""Network commands for agent networks."""
+
+import asyncio
+from typing import List, Optional, Dict, Any
+
+import click
+from rich.table import Table
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from ..utils.output import console, handle_errors
+
+
+@click.group(name="network")
+def network_group():
+    """Manage agent networks."""
+    pass
+
+
+@network_group.command()
+@click.argument("prompt")
+@click.option("--agents", "-a", type=int, default=3, help="Number of agents")
+@click.option("--model", "-m", help="Model to use")
+@click.option("--mode", type=click.Choice(["local", "distributed", "hybrid"]), default="hybrid", help="Execution mode")
+@click.option("--consensus", is_flag=True, help="Require consensus")
+@click.option("--timeout", "-t", type=int, default=300, help="Timeout in seconds")
+@click.pass_context
+async def dispatch(ctx, prompt: str, agents: int, model: str, mode: str, consensus: bool, timeout: int):
+    """Dispatch work to agent network."""
+    try:
+        from hanzo_network import NetworkDispatcher
+    except ImportError:
+        console.print("[red]Error:[/red] hanzo-network not installed")
+        console.print("Install with: pip install hanzo[network]")
+        return
+    
+    dispatcher = NetworkDispatcher(mode=mode)
+    
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        task = progress.add_task("Dispatching to network...", total=None)
+        
+        try:
+            # Create job
+            job = await dispatcher.create_job(
+                prompt=prompt,
+                num_agents=agents,
+                model=model,
+                consensus=consensus,
+                timeout=timeout
+            )
+            
+            progress.update(task, description=f"Job {job['id']} - Finding agents...")
+            
+            # Execute job
+            result = await dispatcher.execute_job(job)
+            
+            progress.update(task, completed=True)
+            
+        except Exception as e:
+            progress.stop()
+            console.print(f"[red]Dispatch failed: {e}[/red]")
+            return
+    
+    # Show results
+    console.print(f"\n[green]✓[/green] Job completed")
+    console.print(f"  ID: {result['job_id']}")
+    console.print(f"  Agents: {result['num_agents']}")
+    console.print(f"  Duration: {result['duration']}s")
+    
+    if consensus:
+        console.print(f"  Consensus: {result.get('consensus_reached', False)}")
+    
+    console.print("\n[cyan]Results:[/cyan]")
+    
+    if consensus and result.get("consensus_result"):
+        console.print(result["consensus_result"])
+    else:
+        for i, agent_result in enumerate(result["agent_results"], 1):
+            console.print(f"\n[yellow]Agent {i} ({agent_result['agent_id']}):[/yellow]")
+            console.print(agent_result["result"])
+
+
+@network_group.command()
+@click.option("--mode", type=click.Choice(["local", "distributed", "all"]), default="all", help="Network mode")
+@click.pass_context
+async def agents(ctx, mode: str):
+    """List available agents in network."""
+    try:
+        from hanzo_network import get_network_agents
+    except ImportError:
+        console.print("[red]Error:[/red] hanzo-network not installed")
+        return
+    
+    with console.status("Discovering agents..."):
+        try:
+            agents = await get_network_agents(mode=mode)
+        except Exception as e:
+            console.print(f"[red]Failed to discover agents: {e}[/red]")
+            return
+    
+    if not agents:
+        console.print("[yellow]No agents found[/yellow]")
+        if mode == "local":
+            console.print("Start local agents with: hanzo agent start")
+        return
+    
+    # Group by type
+    local_agents = [a for a in agents if a["type"] == "local"]
+    network_agents = [a for a in agents if a["type"] == "network"]
+    
+    if local_agents:
+        table = Table(title="Local Agents")
+        table.add_column("ID", style="cyan")
+        table.add_column("Name", style="green")
+        table.add_column("Model", style="yellow")
+        table.add_column("Status", style="blue")
+        table.add_column("Jobs", style="magenta")
+        
+        for agent in local_agents:
+            table.add_row(
+                agent["id"][:8],
+                agent["name"],
+                agent.get("model", "default"),
+                agent["status"],
+                str(agent.get("jobs_completed", 0))
+            )
+        
+        console.print(table)
+    
+    if network_agents:
+        table = Table(title="Network Agents")
+        table.add_column("ID", style="cyan")
+        table.add_column("Location", style="green")
+        table.add_column("Model", style="yellow")
+        table.add_column("Latency", style="blue")
+        table.add_column("Cost", style="magenta")
+        
+        for agent in network_agents:
+            table.add_row(
+                agent["id"][:8],
+                agent.get("location", "unknown"),
+                agent.get("model", "various"),
+                f"{agent.get('latency', 0)}ms",
+                f"${agent.get('cost_per_token', 0):.4f}"
+            )
+        
+        console.print(table)
+
+
+@network_group.command()
+@click.option("--active", is_flag=True, help="Show only active jobs")
+@click.option("--limit", "-n", type=int, default=10, help="Number of jobs to show")
+@click.pass_context
+async def jobs(ctx, active: bool, limit: int):
+    """List network jobs."""
+    try:
+        from hanzo_network import get_network_jobs
+    except ImportError:
+        console.print("[red]Error:[/red] hanzo-network not installed")
+        return
+    
+    with console.status("Loading jobs..."):
+        try:
+            jobs = await get_network_jobs(active_only=active, limit=limit)
+        except Exception as e:
+            console.print(f"[red]Failed to load jobs: {e}[/red]")
+            return
+    
+    if not jobs:
+        console.print("[yellow]No jobs found[/yellow]")
+        return
+    
+    table = Table(title="Network Jobs")
+    table.add_column("ID", style="cyan")
+    table.add_column("Status", style="green")
+    table.add_column("Agents", style="yellow")
+    table.add_column("Created", style="blue")
+    table.add_column("Duration", style="magenta")
+    
+    for job in jobs:
+        table.add_row(
+            job["id"][:8],
+            job["status"],
+            str(job["num_agents"]),
+            job["created_at"],
+            f"{job.get('duration', 0)}s" if job.get("duration") else "-"
+        )
+    
+    console.print(table)
+
+
+@network_group.command()
+@click.argument("job_id")
+@click.pass_context
+async def job(ctx, job_id: str):
+    """Show job details."""
+    try:
+        from hanzo_network import get_job_details
+    except ImportError:
+        console.print("[red]Error:[/red] hanzo-network not installed")
+        return
+    
+    with console.status("Loading job details..."):
+        try:
+            job = await get_job_details(job_id)
+        except Exception as e:
+            console.print(f"[red]Failed to load job: {e}[/red]")
+            return
+    
+    console.print(f"[cyan]Job {job_id}[/cyan]")
+    console.print(f"  Status: {job['status']}")
+    console.print(f"  Created: {job['created_at']}")
+    console.print(f"  Agents: {job['num_agents']}")
+    console.print(f"  Mode: {job['mode']}")
+    
+    if job["status"] == "completed":
+        console.print(f"  Duration: {job['duration']}s")
+        console.print(f"  Cost: ${job.get('total_cost', 0):.4f}")
+    
+    console.print(f"\n[cyan]Prompt:[/cyan]")
+    console.print(job["prompt"])
+    
+    if job["status"] == "completed" and job.get("results"):
+        console.print("\n[cyan]Results:[/cyan]")
+        for i, result in enumerate(job["results"], 1):
+            console.print(f"\n[yellow]Agent {i}:[/yellow]")
+            console.print(result["content"])
+
+
+@network_group.command()
+@click.option("--name", "-n", default="default", help="Swarm name")
+@click.option("--agents", "-a", type=int, default=5, help="Number of agents")
+@click.option("--model", "-m", help="Model to use")
+@click.pass_context
+async def swarm(ctx, name: str, agents: int, model: str):
+    """Start a local agent swarm."""
+    try:
+        from hanzo_network import LocalSwarm
+    except ImportError:
+        console.print("[red]Error:[/red] hanzo-network not installed")
+        return
+    
+    swarm = LocalSwarm(name=name, size=agents, model=model)
+    
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        task = progress.add_task("Starting swarm...", total=None)
+        
+        try:
+            await swarm.start()
+            progress.update(task, completed=True)
+        except Exception as e:
+            progress.stop()
+            console.print(f"[red]Failed to start swarm: {e}[/red]")
+            return
+    
+    console.print(f"[green]✓[/green] Swarm '{name}' started with {agents} agents")
+    console.print("Use 'hanzo network dispatch --mode local' to send work to swarm")
+    console.print("\nPress Ctrl+C to stop swarm")
+    
+    try:
+        # Keep swarm running
+        await swarm.run_forever()
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Stopping swarm...[/yellow]")
+        await swarm.stop()
+        console.print("[green]✓[/green] Swarm stopped")
+
+
+@network_group.command()
+@click.pass_context
+async def stats(ctx):
+    """Show network statistics."""
+    try:
+        from hanzo_network import get_network_stats
+    except ImportError:
+        console.print("[red]Error:[/red] hanzo-network not installed")
+        return
+    
+    with console.status("Loading network stats..."):
+        try:
+            stats = await get_network_stats()
+        except Exception as e:
+            console.print(f"[red]Failed to load stats: {e}[/red]")
+            return
+    
+    console.print("[cyan]Network Statistics[/cyan]")
+    console.print(f"  Total agents: {stats['total_agents']}")
+    console.print(f"  Active agents: {stats['active_agents']}")
+    console.print(f"  Total jobs: {stats['total_jobs']}")
+    console.print(f"  Active jobs: {stats['active_jobs']}")
+    console.print(f"  Success rate: {stats['success_rate']}%")
+    
+    console.print(f"\n[cyan]Performance:[/cyan]")
+    console.print(f"  Average latency: {stats['avg_latency']}ms")
+    console.print(f"  Average job time: {stats['avg_job_time']}s")
+    console.print(f"  Throughput: {stats['throughput']} jobs/min")
+    
+    console.print(f"\n[cyan]Economics:[/cyan]")
+    console.print(f"  Total tokens: {stats['total_tokens']:,}")
+    console.print(f"  Average cost: ${stats['avg_cost']:.4f}/job")
+    console.print(f"  Total cost: ${stats['total_cost']:.2f}")
+
+
+@network_group.command()
+@click.option("--enable/--disable", default=True, help="Enable or disable discovery")
+@click.pass_context
+async def discovery(ctx, enable: bool):
+    """Configure network discovery."""
+    try:
+        from hanzo_network import configure_discovery
+    except ImportError:
+        console.print("[red]Error:[/red] hanzo-network not installed")
+        return
+    
+    try:
+        await configure_discovery(enabled=enable)
+        
+        if enable:
+            console.print("[green]✓[/green] Network discovery enabled")
+            console.print("Your agents will be discoverable by the network")
+        else:
+            console.print("[green]✓[/green] Network discovery disabled")
+            console.print("Your agents will only be accessible locally")
+            
+    except Exception as e:
+        console.print(f"[red]Failed to configure discovery: {e}[/red]")

hanzo/commands/repl.py

@@ -0,0 +1,186 @@
+"""REPL command for interactive AI sessions."""
+
+import os
+import sys
+from typing import Optional
+
+import click
+
+from ..utils.output import console
+
+
+@click.group(name="repl")
+def repl_group():
+    """Interactive REPL for AI and MCP tools."""
+    pass
+
+
+@repl_group.command()
+@click.option("--model", "-m", help="Default model to use")
+@click.option("--local/--cloud", default=False, help="Use local cluster")
+@click.option("--ipython", is_flag=True, help="Use IPython interface")
+@click.option("--tui", is_flag=True, help="Use TUI interface")
+@click.option("--voice", is_flag=True, help="Enable voice mode")
+@click.pass_context
+def start(ctx, model: str, local: bool, ipython: bool, tui: bool, voice: bool):
+    """Start interactive REPL (like Claude Code in terminal)."""
+    try:
+        # Set up environment
+        if model:
+            os.environ["HANZO_DEFAULT_MODEL"] = model
+        if local:
+            os.environ["HANZO_USE_LOCAL"] = "true"
+        if voice:
+            os.environ["HANZO_ENABLE_VOICE"] = "true"
+        
+        if ipython:
+            from hanzo_repl.ipython_repl import main
+        elif tui:
+            from hanzo_repl.textual_repl import main
+        else:
+            from hanzo_repl.cli import main
+        
+        console.print("[cyan]Starting Hanzo REPL...[/cyan]")
+        console.print("All MCP tools available. Type 'help' for commands.\n")
+        
+        sys.exit(main())
+        
+    except ImportError:
+        console.print("[red]Error:[/red] hanzo-repl not installed")
+        console.print("Install with: pip install hanzo[repl]")
+        console.print("\nFeatures:")
+        console.print("  • Direct access to 70+ MCP tools")
+        console.print("  • Chat with AI that can use tools")
+        console.print("  • IPython magic commands")
+        console.print("  • Beautiful TUI interface")
+        console.print("  • Voice mode (optional)")
+
+
+@repl_group.command()
+@click.pass_context
+def info(ctx):
+    """Show REPL information and status."""
+    try:
+        from hanzo_repl import __version__
+        import hanzo_mcp
+        
+        console.print("[cyan]Hanzo REPL[/cyan]")
+        console.print(f"  Version: {__version__}")
+        console.print(f"  MCP Tools: {len(hanzo_mcp.get_all_tools())}")
+        
+        # Check available interfaces
+        interfaces = []
+        try:
+            import IPython
+            interfaces.append("IPython")
+        except ImportError:
+            pass
+        
+        try:
+            import textual
+            interfaces.append("TUI")
+        except ImportError:
+            pass
+        
+        try:
+            import speech_recognition
+            interfaces.append("Voice")
+        except ImportError:
+            pass
+        
+        console.print(f"  Interfaces: {', '.join(interfaces) or 'Basic'}")
+        
+        # Check LLM providers
+        providers = []
+        if os.environ.get("OPENAI_API_KEY"):
+            providers.append("OpenAI")
+        if os.environ.get("ANTHROPIC_API_KEY"):
+            providers.append("Anthropic")
+        if os.environ.get("HANZO_API_KEY"):
+            providers.append("Hanzo AI")
+        
+        console.print(f"  Providers: {', '.join(providers) or 'None configured'}")
+        
+        if not providers:
+            console.print("\n[yellow]No LLM providers configured[/yellow]")
+            console.print("Set one of: OPENAI_API_KEY, ANTHROPIC_API_KEY, HANZO_API_KEY")
+        
+    except ImportError:
+        console.print("[red]Error:[/red] hanzo-repl not installed")
+
+
+@repl_group.command()
+@click.option("--interface", type=click.Choice(["all", "ipython", "tui", "voice"]), default="all")
+@click.pass_context
+def install_extras(ctx, interface: str):
+    """Install optional REPL components."""
+    import subprocess
+    
+    packages = {
+        "ipython": ["ipython>=8.0.0", "jupyter>=1.0.0"],
+        "tui": ["textual>=0.41.0", "textual-dev>=1.2.0"],
+        "voice": ["speechrecognition>=3.10.0", "pyttsx3>=2.90", "pyaudio>=0.2.11"]
+    }
+    
+    if interface == "all":
+        to_install = []
+        for pkgs in packages.values():
+            to_install.extend(pkgs)
+    else:
+        to_install = packages.get(interface, [])
+    
+    if to_install:
+        console.print(f"[cyan]Installing {interface} components...[/cyan]")
+        cmd = [sys.executable, "-m", "pip", "install"] + to_install
+        
+        try:
+            subprocess.run(cmd, check=True)
+            console.print(f"[green]✓[/green] Installed {interface} components")
+        except subprocess.CalledProcessError:
+            console.print(f"[red]Failed to install components[/red]")
+            console.print("Try manually: pip install hanzo-repl[voice]")
+
+
+@repl_group.command()
+@click.argument("command", nargs=-1, required=True)
+@click.option("--model", "-m", help="Model to use")
+@click.pass_context
+def exec(ctx, command: tuple, model: str):
+    """Execute a command in REPL and exit."""
+    try:
+        from hanzo_repl import create_repl
+        import asyncio
+        
+        repl = create_repl(model=model)
+        command_str = " ".join(command)
+        
+        async def run():
+            result = await repl.execute(command_str)
+            console.print(result)
+        
+        asyncio.run(run())
+        
+    except ImportError:
+        console.print("[red]Error:[/red] hanzo-repl not installed")
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+
+
+@repl_group.command()
+@click.pass_context
+def demo(ctx):
+    """Run REPL demo showcasing features."""
+    try:
+        from hanzo_repl.demos import run_demo
+        
+        console.print("[cyan]Running Hanzo REPL demo...[/cyan]\n")
+        run_demo()
+        
+    except ImportError:
+        console.print("[red]Error:[/red] hanzo-repl not installed")
+        console.print("\nThe demo would show:")
+        console.print("  • File operations with MCP tools")
+        console.print("  • Code search and analysis")
+        console.print("  • AI chat with tool usage")
+        console.print("  • IPython magic commands")
+        console.print("  • Voice interaction (if available)")