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

hanzo/interactive/model_selector.py

@@ -0,0 +1,166 @@
+"""Quick model selector with arrow key navigation."""
+
+from typing import List, Optional, Tuple
+from prompt_toolkit import Application
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.layout.containers import HSplit, Window
+from prompt_toolkit.layout.controls import FormattedTextControl
+from prompt_toolkit.layout.layout import Layout
+from prompt_toolkit.widgets import Label
+from rich.console import Console
+
+
+class QuickModelSelector:
+    """Quick model selector with arrow navigation."""
+    
+    def __init__(self, models: List[Tuple[str, str]], tools: List[Tuple[str, str]], current: str):
+        self.models = models
+        self.tools = tools
+        self.current = current
+        self.all_items = tools + models  # Tools first, then models
+        self.selected_index = 0
+        
+        # Find current selection
+        for i, (item_id, _) in enumerate(self.all_items):
+            if item_id == current:
+                self.selected_index = i
+                break
+    
+    def get_display_lines(self) -> List[str]:
+        """Get display lines for the selector."""
+        lines = []
+        
+        if self.tools:
+            lines.append("AI Coding Assistants:")
+            for i, (tool_id, tool_name) in enumerate(self.tools):
+                marker = "→ " if i == self.selected_index else "  "
+                lines.append(f"{marker}{tool_name}")
+        
+        if self.models:
+            if self.tools:
+                lines.append("")  # Empty line
+            lines.append("Language Models:")
+            
+            tool_count = len(self.tools)
+            for i, (model_id, model_name) in enumerate(self.models):
+                actual_idx = tool_count + i
+                marker = "→ " if actual_idx == self.selected_index else "  "
+                lines.append(f"{marker}{model_name}")
+        
+        return lines
+    
+    def move_up(self):
+        """Move selection up."""
+        if self.selected_index > 0:
+            self.selected_index -= 1
+    
+    def move_down(self):
+        """Move selection down."""
+        if self.selected_index < len(self.all_items) - 1:
+            self.selected_index += 1
+    
+    def get_selected(self) -> Tuple[str, str]:
+        """Get the selected item."""
+        if 0 <= self.selected_index < len(self.all_items):
+            return self.all_items[self.selected_index]
+        return None, None
+    
+    async def run(self) -> Optional[str]:
+        """Run the selector and return selected model/tool ID."""
+        kb = KeyBindings()
+        
+        @kb.add('up')
+        def _(event):
+            self.move_up()
+            event.app.invalidate()
+        
+        @kb.add('down')
+        def _(event):
+            self.move_down()
+            event.app.invalidate()
+        
+        @kb.add('enter')
+        def _(event):
+            event.app.exit(result=self.get_selected()[0])
+        
+        @kb.add('c-c')
+        @kb.add('escape')
+        def _(event):
+            event.app.exit(result=None)
+        
+        def get_text():
+            lines = self.get_display_lines()
+            lines.append("")
+            lines.append("↑/↓: Navigate  Enter: Select  Esc: Cancel")
+            return "\n".join(lines)
+        
+        layout = Layout(
+            Window(
+                FormattedTextControl(get_text),
+                wrap_lines=False
+            )
+        )
+        
+        app = Application(
+            layout=layout,
+            key_bindings=kb,
+            full_screen=False,
+            mouse_support=True
+        )
+        
+        return await app.run_async()
+
+
+class BackgroundTaskManager:
+    """Manage background tasks."""
+    
+    def __init__(self, console: Optional[Console] = None):
+        self.console = console or Console()
+        self.tasks = {}  # task_id -> process
+        self.next_id = 1
+    
+    def add_task(self, name: str, process):
+        """Add a background task."""
+        task_id = f"task_{self.next_id}"
+        self.next_id += 1
+        self.tasks[task_id] = {
+            "name": name,
+            "process": process,
+            "started": True
+        }
+        return task_id
+    
+    def list_tasks(self):
+        """List all background tasks."""
+        if not self.tasks:
+            self.console.print("[dim]No background tasks running[/dim]")
+            return
+        
+        self.console.print("[bold]Background Tasks:[/bold]")
+        for task_id, task in self.tasks.items():
+            status = "🟢 Running" if task["process"].poll() is None else "🔴 Stopped"
+            self.console.print(f"  {task_id}: {task['name']} - {status}")
+    
+    def kill_task(self, task_id: str):
+        """Kill a background task."""
+        if task_id in self.tasks:
+            task = self.tasks[task_id]
+            if task["process"].poll() is None:
+                task["process"].terminate()
+                self.console.print(f"[yellow]Terminated {task_id}: {task['name']}[/yellow]")
+            else:
+                self.console.print(f"[dim]Task {task_id} already stopped[/dim]")
+            del self.tasks[task_id]
+        else:
+            self.console.print(f"[red]Task {task_id} not found[/red]")
+    
+    def kill_all(self):
+        """Kill all background tasks."""
+        if not self.tasks:
+            self.console.print("[dim]No tasks to kill[/dim]")
+            return
+        
+        for task_id in list(self.tasks.keys()):
+            self.kill_task(task_id)
+        
+        self.console.print("[green]All tasks terminated[/green]")

hanzo/interactive/repl.py

@@ -45,9 +45,9 @@ class HanzoREPL:
 
         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():

hanzo/tools/__init__.py

@@ -0,0 +1,5 @@
+"""AI tools detection and management."""
+
+from .detector import ToolDetector, AITool
+
+__all__ = ["ToolDetector", "AITool"]

hanzo/tools/detector.py

@@ -0,0 +1,291 @@
+"""Detect available AI coding tools and assistants."""
+
+import os
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+from dataclasses import dataclass
+
+from rich.console import Console
+from rich.table import Table
+from rich import box
+
+
+@dataclass
+class AITool:
+    """Represents an AI coding tool."""
+    name: str
+    command: str
+    display_name: str
+    provider: str
+    priority: int  # Lower is higher priority
+    check_command: Optional[str] = None
+    env_var: Optional[str] = None
+    api_endpoint: Optional[str] = None
+    detected: bool = False
+    version: Optional[str] = None
+    path: Optional[str] = None
+
+
+class ToolDetector:
+    """Detect and manage available AI coding tools."""
+    
+    # Define available tools with priority order
+    TOOLS = [
+        AITool(
+            name="claude-code",
+            command="claude",
+            display_name="Claude Code",
+            provider="anthropic",
+            priority=1,
+            check_command="claude --version",
+            env_var="ANTHROPIC_API_KEY"
+        ),
+        AITool(
+            name="hanzo-dev",
+            command="hanzo dev",
+            display_name="Hanzo Dev (Native)",
+            provider="hanzo",
+            priority=2,
+            check_command="hanzo --version",
+            env_var="HANZO_API_KEY"
+        ),
+        AITool(
+            name="openai-codex",
+            command="openai",
+            display_name="OpenAI Codex",
+            provider="openai",
+            priority=3,
+            check_command="openai --version",
+            env_var="OPENAI_API_KEY"
+        ),
+        AITool(
+            name="gemini-cli",
+            command="gemini",
+            display_name="Gemini CLI",
+            provider="google",
+            priority=4,
+            check_command="gemini --version",
+            env_var="GEMINI_API_KEY"
+        ),
+        AITool(
+            name="grok-cli",
+            command="grok",
+            display_name="Grok CLI",
+            provider="xai",
+            priority=5,
+            check_command="grok --version",
+            env_var="GROK_API_KEY"
+        ),
+        AITool(
+            name="openhands",
+            command="openhands",
+            display_name="OpenHands CLI",
+            provider="openhands",
+            priority=6,
+            check_command="openhands --version",
+            env_var=None
+        ),
+        AITool(
+            name="cursor",
+            command="cursor",
+            display_name="Cursor AI",
+            provider="cursor",
+            priority=7,
+            check_command="cursor --version",
+            env_var=None
+        ),
+        AITool(
+            name="codeium",
+            command="codeium",
+            display_name="Codeium",
+            provider="codeium",
+            priority=8,
+            check_command="codeium --version",
+            env_var="CODEIUM_API_KEY"
+        ),
+        AITool(
+            name="aider",
+            command="aider",
+            display_name="Aider",
+            provider="aider",
+            priority=9,
+            check_command="aider --version",
+            env_var=None
+        ),
+        AITool(
+            name="continue",
+            command="continue",
+            display_name="Continue Dev",
+            provider="continue",
+            priority=10,
+            check_command="continue --version",
+            env_var=None
+        )
+    ]
+    
+    def __init__(self, console: Optional[Console] = None):
+        self.console = console or Console()
+        self.detected_tools: List[AITool] = []
+        
+    def detect_all(self) -> List[AITool]:
+        """Detect all available AI tools."""
+        self.detected_tools = []
+        
+        for tool in self.TOOLS:
+            if self.detect_tool(tool):
+                self.detected_tools.append(tool)
+        
+        # Sort by priority
+        self.detected_tools.sort(key=lambda t: t.priority)
+        return self.detected_tools
+    
+    def detect_tool(self, tool: AITool) -> bool:
+        """Detect if a specific tool is available."""
+        # Check if command exists
+        tool.path = shutil.which(tool.command.split()[0])
+        if tool.path:
+            tool.detected = True
+            
+            # Try to get version
+            if tool.check_command:
+                try:
+                    result = subprocess.run(
+                        tool.check_command.split(),
+                        capture_output=True,
+                        text=True,
+                        timeout=2
+                    )
+                    if result.returncode == 0:
+                        tool.version = result.stdout.strip().split()[-1]
+                except:
+                    pass
+            
+            return True
+        
+        # Check environment variable as fallback
+        if tool.env_var and os.getenv(tool.env_var):
+            tool.detected = True
+            return True
+        
+        return False
+    
+    def get_default_tool(self) -> Optional[AITool]:
+        """Get the default tool based on priority and availability."""
+        if not self.detected_tools:
+            self.detect_all()
+        
+        if self.detected_tools:
+            return self.detected_tools[0]
+        return None
+    
+    def get_tool_by_name(self, name: str) -> Optional[AITool]:
+        """Get a specific tool by name."""
+        for tool in self.TOOLS:
+            if tool.name == name or tool.display_name.lower() == name.lower():
+                if self.detect_tool(tool):
+                    return tool
+        return None
+    
+    def show_available_tools(self):
+        """Display available tools in a table."""
+        self.detect_all()
+        
+        table = Table(title="Available AI Coding Tools", box=box.ROUNDED)
+        table.add_column("#", style="dim")
+        table.add_column("Tool", style="cyan")
+        table.add_column("Provider", style="yellow")
+        table.add_column("Status", style="green")
+        table.add_column("Version", style="blue")
+        table.add_column("Priority", style="magenta")
+        
+        for i, tool in enumerate(self.TOOLS, 1):
+            status = "✅ Available" if tool.detected else "❌ Not Found"
+            version = tool.version or "Unknown" if tool.detected else "-"
+            
+            # Highlight the default tool
+            if tool.detected and tool == self.detected_tools[0] if self.detected_tools else False:
+                table.add_row(
+                    str(i),
+                    f"[bold green]→ {tool.display_name}[/bold green]",
+                    tool.provider,
+                    status,
+                    version,
+                    str(tool.priority)
+                )
+            else:
+                table.add_row(
+                    str(i),
+                    tool.display_name,
+                    tool.provider,
+                    status,
+                    version,
+                    str(tool.priority)
+                )
+        
+        self.console.print(table)
+        
+        if self.detected_tools:
+            default = self.detected_tools[0]
+            self.console.print(f"\n[green]Default tool: {default.display_name}[/green]")
+        else:
+            self.console.print("\n[yellow]No AI coding tools detected.[/yellow]")
+            self.console.print("[dim]Install Claude Code, OpenAI CLI, or other tools to enable AI features.[/dim]")
+    
+    def get_tool_command(self, tool: AITool, prompt: str) -> List[str]:
+        """Get the command to execute for a tool with a prompt."""
+        if tool.name == "claude-code":
+            return ["claude", prompt]
+        elif tool.name == "hanzo-dev":
+            return ["hanzo", "dev", "--prompt", prompt]
+        elif tool.name == "openai-codex":
+            return ["openai", "api", "completions.create", "-m", "code-davinci-002", "-p", prompt]
+        elif tool.name == "gemini-cli":
+            return ["gemini", "generate", "--prompt", prompt]
+        elif tool.name == "grok-cli":
+            return ["grok", "complete", prompt]
+        elif tool.name == "openhands":
+            return ["openhands", "run", prompt]
+        elif tool.name == "cursor":
+            return ["cursor", "--prompt", prompt]
+        elif tool.name == "aider":
+            return ["aider", "--message", prompt]
+        else:
+            return [tool.command, prompt]
+    
+    def execute_with_tool(self, tool: AITool, prompt: str) -> Tuple[bool, str]:
+        """Execute a prompt with a specific tool."""
+        try:
+            command = self.get_tool_command(tool, prompt)
+            result = subprocess.run(
+                command,
+                capture_output=True,
+                text=True,
+                timeout=30
+            )
+            
+            if result.returncode == 0:
+                return True, result.stdout
+            else:
+                return False, result.stderr or "Command failed"
+        except subprocess.TimeoutExpired:
+            return False, "Command timed out"
+        except Exception as e:
+            return False, str(e)
+    
+    def execute_with_fallback(self, prompt: str) -> Tuple[bool, str, AITool]:
+        """Execute with fallback through available tools."""
+        if not self.detected_tools:
+            self.detect_all()
+        
+        for tool in self.detected_tools:
+            self.console.print(f"[dim]Trying {tool.display_name}...[/dim]")
+            success, output = self.execute_with_tool(tool, prompt)
+            
+            if success:
+                return True, output, tool
+            else:
+                self.console.print(f"[yellow]{tool.display_name} failed: {output}[/yellow]")
+        
+        return False, "No available tools could handle the request", None

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()