hanzo 0.3.22__py3-none-any.whl → 0.3.24__py3-none-any.whl

hanzo/fallback_handler.py

@@ -6,22 +6,25 @@ Automatically tries available AI options when primary fails.
 import os
 import shutil
 import subprocess
-from typing import Optional, Dict, Any
+from typing import Any, Dict, Optional
 from pathlib import Path
 
+
 class FallbackHandler:
     """Handles automatic fallback to available AI options."""
-    
+
     def __init__(self):
         self.available_options = self._detect_available_options()
         self.fallback_order = self._determine_fallback_order()
-    
+
     def _detect_available_options(self) -> Dict[str, bool]:
         """Detect which AI options are available."""
         options = {
             "openai_api": bool(os.getenv("OPENAI_API_KEY")),
             "anthropic_api": bool(os.getenv("ANTHROPIC_API_KEY")),
-            "google_api": bool(os.getenv("GOOGLE_API_KEY") or os.getenv("GEMINI_API_KEY")),
+            "google_api": bool(
+                os.getenv("GOOGLE_API_KEY") or os.getenv("GEMINI_API_KEY")
+            ),
             "openai_cli": shutil.which("openai") is not None,
             "claude_cli": shutil.which("claude") is not None,
             "gemini_cli": shutil.which("gemini") is not None,
@@ -30,24 +33,25 @@ class FallbackHandler:
             "free_apis": True,  # Always available (Codestral, StarCoder)
         }
         return options
-    
+
     def _check_ollama(self) -> bool:
         """Check if Ollama is running and has models."""
         try:
             import httpx
+
             with httpx.Client(timeout=2.0) as client:
                 response = client.get("http://localhost:11434/api/tags")
                 if response.status_code == 200:
                     data = response.json()
                     return len(data.get("models", [])) > 0
-        except:
+        except Exception:
             pass
         return False
-    
+
     def _determine_fallback_order(self) -> list:
         """Determine the order of fallback options based on availability."""
         order = []
-        
+
         # Priority 1: API keys (fastest, most reliable)
         if self.available_options["openai_api"]:
             order.append(("openai_api", "gpt-4"))
@@ -55,7 +59,7 @@ class FallbackHandler:
             order.append(("anthropic_api", "claude-3-5-sonnet"))
         if self.available_options["google_api"]:
             order.append(("google_api", "gemini-pro"))
-        
+
         # Priority 2: CLI tools (no API key needed)
         if self.available_options["openai_cli"]:
             order.append(("openai_cli", "codex"))
@@ -63,65 +67,72 @@ class FallbackHandler:
             order.append(("claude_cli", "claude-desktop"))
         if self.available_options["gemini_cli"]:
             order.append(("gemini_cli", "gemini"))
-        
+
         # Priority 3: Local models (free, but requires setup)
         if self.available_options["ollama"]:
             order.append(("ollama", "local:llama3.2"))
         if self.available_options["hanzo_ide"]:
             order.append(("hanzo_ide", "hanzo-ide"))
-        
+
         # Priority 4: Free cloud APIs (rate limited)
         if self.available_options["free_apis"]:
             order.append(("free_api", "codestral-free"))
             order.append(("free_api", "starcoder2"))
-        
+
         return order
-    
+
     def get_best_option(self) -> Optional[tuple]:
         """Get the best available AI option."""
         if self.fallback_order:
             return self.fallback_order[0]
         return None
-    
+
     def get_next_option(self, failed_option: str) -> Optional[tuple]:
         """Get the next fallback option after one fails."""
         for i, (option_type, model) in enumerate(self.fallback_order):
             if model == failed_option and i + 1 < len(self.fallback_order):
                 return self.fallback_order[i + 1]
         return None
-    
+
     def suggest_setup(self) -> str:
         """Suggest setup instructions for unavailable options."""
         suggestions = []
-        
+
         if not self.available_options["openai_api"]:
             suggestions.append("• Set OPENAI_API_KEY for GPT-4/GPT-5 access")
-        
+
         if not self.available_options["anthropic_api"]:
             suggestions.append("• Set ANTHROPIC_API_KEY for Claude access")
-        
+
         if not self.available_options["ollama"]:
-            suggestions.append("• Install Ollama: curl -fsSL https://ollama.com/install.sh | sh")
+            suggestions.append(
+                "• Install Ollama: curl -fsSL https://ollama.com/install.sh | sh"
+            )
             suggestions.append("  Then run: ollama pull llama3.2")
-        
+
         if not self.available_options["openai_cli"]:
             suggestions.append("• Install OpenAI CLI: pip install openai-cli")
-        
+
         if not self.available_options["claude_cli"]:
-            suggestions.append("• Install Claude Desktop from https://claude.ai/download")
-        
-        return "\n".join(suggestions) if suggestions else "All AI options are available!"
-    
+            suggestions.append(
+                "• Install Claude Desktop from https://claude.ai/download"
+            )
+
+        return (
+            "\n".join(suggestions) if suggestions else "All AI options are available!"
+        )
+
     def print_status(self, console):
         """Print the current status of available AI options."""
         from rich.table import Table
-        
-        table = Table(title="Available AI Options", show_header=True,
-                     header_style="bold magenta")
+
+        table = Table(
+            title="Available AI Options", show_header=True, header_style="bold magenta"
+        )
         table.add_column("Option", style="cyan", width=20)
         table.add_column("Status", width=10)
         table.add_column("Model", width=20)
-        
+
         status_map = {
             "openai_api": ("OpenAI API", "gpt-4"),
             "anthropic_api": ("Anthropic API", "claude-3-5"),
@@ -133,17 +144,19 @@ class FallbackHandler:
             "hanzo_ide": ("Hanzo IDE", "hanzo-dev"),
             "free_apis": ("Free APIs", "codestral/starcoder"),
         }
-        
+
         for key, available in self.available_options.items():
             if key in status_map:
                 name, model = status_map[key]
                 status = "✅" if available else "❌"
                 table.add_row(name, status, model if available else "Not available")
-        
+
         console.print(table)
-        
+
         if self.fallback_order:
-            console.print(f"\n[green]Primary option: {self.fallback_order[0][1]}[/green]")
+            console.print(
+                f"\n[green]Primary option: {self.fallback_order[0][1]}[/green]"
+            )
             if len(self.fallback_order) > 1:
                 fallbacks = ", ".join([opt[1] for opt in self.fallback_order[1:]])
                 console.print(f"[yellow]Fallback options: {fallbacks}[/yellow]")
@@ -159,91 +172,104 @@ async def smart_chat(message: str, console=None) -> Optional[str]:
     Returns the AI response or None if all options fail.
     """
     from .rate_limiter import smart_limiter
-    
+
     handler = FallbackHandler()
-    
+
     if console:
         console.print("\n[dim]Detecting available AI options...[/dim]")
-    
+
     best_option = handler.get_best_option()
     if not best_option:
         if console:
             handler.print_status(console)
         return None
-    
+
     option_type, model = best_option
-    
+
     # Try the primary option with rate limiting
     try:
         if option_type == "openai_api":
+
             async def call_openai():
                 from openai import AsyncOpenAI
+
                 client = AsyncOpenAI()
                 response = await client.chat.completions.create(
                     model="gpt-4",
                     messages=[{"role": "user", "content": message}],
-                    max_tokens=500
+                    max_tokens=500,
                 )
                 return response.choices[0].message.content
-            
+
             return await smart_limiter.execute_with_limit("openai", call_openai)
-            
+
         elif option_type == "anthropic_api":
             from anthropic import AsyncAnthropic
+
             client = AsyncAnthropic()
             response = await client.messages.create(
                 model="claude-3-5-sonnet-20241022",
                 messages=[{"role": "user", "content": message}],
-                max_tokens=500
+                max_tokens=500,
             )
             return response.content[0].text
-            
+
         elif option_type == "openai_cli":
             # Use OpenAI CLI
             result = subprocess.run(
-                ["openai", "api", "chat.completions.create", "-m", "gpt-4", "-g", message],
+                [
+                    "openai",
+                    "api",
+                    "chat.completions.create",
+                    "-m",
+                    "gpt-4",
+                    "-g",
+                    message,
+                ],
                 capture_output=True,
                 text=True,
-                timeout=30
+                timeout=30,
             )
             if result.returncode == 0:
                 return result.stdout.strip()
-                
+
         elif option_type == "ollama":
             # Use Ollama
             import httpx
+
             async with httpx.AsyncClient() as client:
                 response = await client.post(
                     "http://localhost:11434/api/generate",
                     json={"model": "llama3.2", "prompt": message, "stream": False},
-                    timeout=30.0
+                    timeout=30.0,
                 )
                 if response.status_code == 200:
                     return response.json().get("response", "")
-                    
+
         elif option_type == "free_api":
             # Try free Codestral API
             import httpx
+
             async with httpx.AsyncClient() as client:
                 response = await client.post(
                     "https://codestral.mistral.ai/v1/fim/completions",
                     headers={"Content-Type": "application/json"},
                     json={"prompt": message, "suffix": "", "max_tokens": 500},
-                    timeout=30.0
+                    timeout=30.0,
                 )
                 if response.status_code == 200:
                     return response.json().get("choices", [{}])[0].get("text", "")
-                    
+
     except Exception as e:
         if console:
             console.print(f"[yellow]Primary option {model} failed: {e}[/yellow]")
             console.print("[dim]Trying fallback...[/dim]")
-        
+
         # Try next fallback
         next_option = handler.get_next_option(model)
         if next_option:
             # Recursively try the next option
             handler.fallback_order.remove(best_option)
             return await smart_chat(message, console)
-    
-    return None
+
+    return None

hanzo/interactive/repl.py

@@ -35,8 +35,11 @@ class HanzoREPL:
         # Don't print welcome message here since it's already printed in cli.py
 
         # Set up command completer
+        cli_commands = ["chat", "ask", "agent", "node", "mcp", "network", 
+                       "auth", "config", "tools", "miner", "serve", "net", 
+                       "dev", "router"]
         completer = WordCompleter(
-            list(self.commands.keys()) + ["chat", "agent", "cluster", "mcp", "network"],
+            list(self.commands.keys()) + cli_commands,
             ignore_case=True,
         )
 
@@ -58,8 +61,12 @@ class HanzoREPL:
                 # Execute command
                 if cmd in self.commands:
                     await self.commands[cmd](args)
-                else:
+                elif cmd in ["chat", "ask", "agent", "node", "mcp", "network", "auth", "config", "tools", "miner", "serve", "net", "dev", "router"]:
+                    # Execute known CLI commands
                     await self.execute_command(cmd, args)
+                else:
+                    # Treat as chat message if not a known command
+                    await self.chat_with_ai(command)
 
             except KeyboardInterrupt:
                 continue
@@ -83,7 +90,7 @@ class HanzoREPL:
 All Hanzo CLI commands are available:
 - `chat <message>` - Chat with AI
 - `agent start` - Start an agent
-- `cluster status` - Check cluster status
+- `node status` - Check node status
 - `mcp tools` - List MCP tools
 - `network agents` - List network agents
 
@@ -91,7 +98,7 @@ All Hanzo CLI commands are available:
 ```
 hanzo> chat How do I create a Python web server?
 hanzo> agent list
-hanzo> cluster start --models llama-3.2-3b
+hanzo> node start --models llama-3.2-3b
 hanzo> mcp run read_file --arg path=README.md
 ```
 
@@ -114,53 +121,60 @@ hanzo> mcp run read_file --arg path=README.md
     async def show_status(self, args: str = ""):
         """Show system status."""
         status = {
-            "cluster": await self.check_cluster_status(),
+            "node": await self.check_node_status(),
             "agents": await self.count_agents(),
             "auth": self.check_auth_status(),
         }
 
         self.console.print("[cyan]System Status:[/cyan]")
-        self.console.print(f"  Cluster: {status['cluster']}")
+        self.console.print(f"  Node: {status['node']}")
         self.console.print(f"  Agents: {status['agents']}")
         self.console.print(f"  Auth: {status['auth']}")
 
     async def execute_command(self, cmd: str, args: str):
         """Execute a CLI command."""
-        # Import here to avoid circular imports
+        import os
         import sys
-
-        import click
-
-        from .. import cli
-
-        # Build command line
-        argv = [cmd]
+        import shutil
+        import subprocess
+
+        # Find hanzo executable
+        hanzo_cmd = shutil.which("hanzo")
+        if not hanzo_cmd:
+            # Try using Python module directly
+            hanzo_cmd = sys.executable
+            argv = [hanzo_cmd, "-m", "hanzo", cmd]
+        else:
+            argv = [hanzo_cmd, cmd]
+        
         if args:
             import shlex
-
             argv.extend(shlex.split(args))
 
-        # Create a new context
+        # Execute as subprocess to avoid context issues
         try:
-            # Save original argv
-            orig_argv = sys.argv
-            sys.argv = ["hanzo"] + argv
-
-            # Execute command
-            ctx = click.Context(cli.cli)
-            cli.cli.invoke(ctx)
-
-        except SystemExit:
-            # Catch exit from commands
-            pass
+            result = subprocess.run(
+                argv,
+                capture_output=True,
+                text=True,
+                timeout=30,
+                env=os.environ.copy()  # Pass environment variables
+            )
+            
+            if result.stdout:
+                self.console.print(result.stdout.rstrip())
+            if result.stderr and result.returncode != 0:
+                self.console.print(f"[red]{result.stderr.rstrip()}[/red]")
+                
+        except subprocess.TimeoutExpired:
+            self.console.print("[red]Command timed out[/red]")
+        except FileNotFoundError:
+            self.console.print("[red]Command not found. Make sure 'hanzo' is installed.[/red]")
         except Exception as e:
             self.console.print(f"[red]Command error: {e}[/red]")
-        finally:
-            # Restore argv
-            sys.argv = orig_argv
 
-    async def check_cluster_status(self) -> str:
-        """Check if cluster is running."""
+    async def check_node_status(self) -> str:
+        """Check if node is running."""
         try:
             import httpx
 
@@ -185,3 +199,9 @@ hanzo> mcp run read_file --arg path=README.md
             return "authenticated (saved)"
         else:
             return "not authenticated"
+    
+    async def chat_with_ai(self, message: str):
+        """Chat with AI when user types natural language."""
+        # For natural language input, try to use it as a chat message
+        # Default to cloud mode to avoid needing local server
+        await self.execute_command("ask", f"--cloud {message}")

hanzo/mcp_server.py

@@ -6,11 +6,16 @@ import click
 
 
 def main():
-    """Start the Hanzo MCP server."""
+    """Start the Hanzo MCP server.
+
+    This wrapper defers to hanzo_mcp.cli:main so that the CLI can parse
+    transport flags and configure logging BEFORE importing any heavy modules,
+    preventing stdio protocol corruption.
+    """
     try:
-        from hanzo_mcp.server import main as mcp_main
+        from hanzo_mcp.cli import main as cli_main
 
-        mcp_main()
+        cli_main()
     except ImportError:
         click.echo(
             "Error: hanzo-mcp is not installed. Please run: pip install hanzo[mcp] or pip install hanzo[all]",