hanzo 0.3.23__py3-none-any.whl → 0.3.25__py3-none-any.whl

hanzo/interactive/repl.py

@@ -35,16 +35,19 @@ 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,
         )
 
         while self.running:
             try:
-                # Get input
+                # Get input with simple prompt
                 command = await self.session.prompt_async(
-                    "hanzo> ", completer=completer
+                    "> ", completer=completer
                 )
 
                 if not command.strip():
@@ -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]",

hanzo/memory_manager.py

@@ -116,7 +116,7 @@ class MemoryManager:
             try:
                 with open(self.session_file, "r") as f:
                     self.session_context = json.load(f)
-            except:
+            except Exception:
                 self.session_context = {}
         else:
             self.session_context = {

hanzo/model_registry.py

@@ -6,9 +6,9 @@ eliminating duplication and ensuring consistency across the codebase.
 
 from __future__ import annotations
 
-from dataclasses import dataclass, field
-from typing import Dict, List, Optional, Set
 from enum import Enum
+from typing import Set, Dict, List, Optional
+from dataclasses import field, dataclass
 
 
 class ModelProvider(Enum):

hanzo/rate_limiter.py

@@ -218,7 +218,7 @@ class ErrorRecovery:
                     if isinstance(e, error_type):
                         try:
                             return await handler(*args, **kwargs)
-                        except:
+                        except Exception:
                             pass  # Fallback failed, continue with retry
 
                 # Calculate backoff

hanzo/streaming.py

@@ -273,7 +273,7 @@ async def stream_with_fallback(message: str, console: Console = None) -> Optiona
     # Try Ollama streaming
     try:
         return await handler.stream_ollama(message)
-    except:
+    except Exception:
         pass
 
     # Fallback to non-streaming with simulated effect

hanzo/ui/__init__.py

@@ -0,0 +1,13 @@
+"""
+Hanzo UI components for CLI.
+"""
+
+from .startup import show_startup, StartupUI
+from .inline_startup import show_inline_startup, show_status
+
+__all__ = [
+    "show_startup",
+    "StartupUI", 
+    "show_inline_startup",
+    "show_status"
+]

hanzo/ui/inline_startup.py

@@ -0,0 +1,136 @@
+"""
+Inline startup notifications for Hanzo commands.
+"""
+
+import os
+import json
+from pathlib import Path
+from datetime import datetime, timedelta
+from typing import Optional
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from rich import box
+
+console = Console()
+
+
+class InlineStartup:
+    """Lightweight inline startup notifications."""
+    
+    def __init__(self):
+        self.config_dir = Path.home() / ".hanzo"
+        self.last_shown_file = self.config_dir / ".last_inline_shown"
+        self.show_interval = timedelta(hours=24)  # Show once per day
+        
+    def should_show(self) -> bool:
+        """Check if we should show inline startup."""
+        # Check environment variable
+        if os.environ.get("HANZO_NO_STARTUP") == "1":
+            return False
+            
+        # Check last shown time
+        if self.last_shown_file.exists():
+            try:
+                last_shown = datetime.fromisoformat(
+                    self.last_shown_file.read_text().strip()
+                )
+                if datetime.now() - last_shown < self.show_interval:
+                    return False
+            except:
+                pass
+                
+        return True
+    
+    def mark_shown(self):
+        """Mark inline startup as shown."""
+        self.config_dir.mkdir(exist_ok=True)
+        self.last_shown_file.write_text(datetime.now().isoformat())
+    
+    def show_mini(self, command: str = None):
+        """Show mini inline startup."""
+        if not self.should_show():
+            return
+            
+        # Build message
+        message = Text()
+        message.append("✨ ", style="yellow")
+        message.append("Hanzo AI ", style="bold cyan")
+        message.append("v0.3.23", style="green")
+        
+        # Add what's new teaser
+        message.append(" • ", style="dim")
+        message.append("What's new: ", style="dim")
+        message.append("Router management, improved docs", style="yellow dim")
+        
+        # Show panel
+        console.print(
+            Panel(
+                message,
+                box=box.MINIMAL,
+                border_style="cyan",
+                padding=(0, 1)
+            )
+        )
+        
+        self.mark_shown()
+    
+    def show_command_hint(self, command: str):
+        """Show command-specific hints."""
+        hints = {
+            "chat": "💡 Tip: Use --model to change AI model, --router for local proxy",
+            "node": "💡 Tip: Run 'hanzo node start' to enable local AI inference",
+            "router": "💡 Tip: Router provides unified access to 100+ LLM providers",
+            "repl": "💡 Tip: REPL combines Python with AI assistance",
+            "agent": "💡 Tip: Agents can work in parallel with 'hanzo agent swarm'"
+        }
+        
+        hint = hints.get(command)
+        if hint and os.environ.get("HANZO_SHOW_HINTS") != "0":
+            console.print(f"[dim]{hint}[/dim]")
+    
+    def show_status_bar(self):
+        """Show a compact status bar."""
+        items = []
+        
+        # Check router
+        try:
+            import httpx
+            response = httpx.get("http://localhost:4000/health", timeout=0.5)
+            if response.status_code == 200:
+                items.append("[green]Router ✓[/green]")
+        except:
+            pass
+            
+        # Check node
+        try:
+            import httpx
+            response = httpx.get("http://localhost:8000/health", timeout=0.5)
+            if response.status_code == 200:
+                items.append("[green]Node ✓[/green]")
+        except:
+            pass
+            
+        # Check API key
+        if os.environ.get("HANZO_API_KEY"):
+            items.append("[green]API ✓[/green]")
+        else:
+            items.append("[yellow]API ⚠[/yellow]")
+            
+        if items:
+            status = " • ".join(items)
+            console.print(f"[dim]Status: {status}[/dim]")
+
+
+def show_inline_startup(command: str = None):
+    """Show inline startup notification."""
+    startup = InlineStartup()
+    startup.show_mini(command)
+    if command:
+        startup.show_command_hint(command)
+
+
+def show_status():
+    """Show compact status bar."""
+    startup = InlineStartup()
+    startup.show_status_bar()