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

hanzo/__init__.py

@@ -1,6 +1,6 @@
 """Hanzo - Complete AI Infrastructure Platform with CLI, Router, MCP, and Agent Runtime."""
 
-__version__ = "0.3.26"
+__version__ = "0.3.28"
 __all__ = ["main", "cli", "__version__"]
 
 from .cli import cli, main

hanzo/interactive/enhanced_repl.py

@@ -32,6 +32,11 @@ except ImportError:
     QuickModelSelector = None
     BackgroundTaskManager = None
 
+try:
+    from .todo_manager import TodoManager
+except ImportError:
+    TodoManager = None
+
 
 class EnhancedHanzoREPL:
     """Enhanced REPL with model selection and authentication."""
@@ -99,6 +104,9 @@ class EnhancedHanzoREPL:
         # Initialize background task manager
         self.task_manager = BackgroundTaskManager(console) if BackgroundTaskManager else None
         
+        # Initialize todo manager
+        self.todo_manager = TodoManager(console) if TodoManager else None
+        
         # Detect available tools and set default
         if self.tool_detector:
             self.detected_tools = self.tool_detector.detect_all()
@@ -139,6 +147,8 @@ class EnhancedHanzoREPL:
             "tasks": self.show_tasks,
             "kill": self.kill_task,
             "quick": self.quick_model_select,
+            "todo": self.manage_todos,
+            "todos": self.manage_todos,  # Alias
         }
         
         self.running = False
@@ -295,6 +305,9 @@ class EnhancedHanzoREPL:
             "models": "models",
             "login": "login",
             "logout": "logout",
+            "todo": "todo",
+            "todos": "todos",
+            "t": "todo",  # Shortcut for todo
         }
         
         mapped_cmd = slash_map.get(cmd, cmd)
@@ -550,6 +563,7 @@ class EnhancedHanzoREPL:
 # Hanzo Enhanced REPL
 
 ## Slash Commands:
+- `/todo [cmd]` - Manage todos (see `/todo help`)
 - `/model [name]` - Change AI model (or `/m`)
 - `/models` - List available models
 - `/tools` - List available AI tools
@@ -685,4 +699,215 @@ class EnhancedHanzoREPL:
                     else:
                         self.task_manager.kill_task(task_id)
             except (KeyboardInterrupt, EOFError):
-                pass
+                pass
+    
+    async def manage_todos(self, args: str = ""):
+        """Manage todos."""
+        if not self.todo_manager:
+            self.console.print("[yellow]Todo manager not available[/yellow]")
+            return
+        
+        # Parse command
+        parts = args.strip().split(maxsplit=1)
+        
+        if not parts:
+            # Show todos
+            self.todo_manager.display_todos()
+            return
+        
+        subcommand = parts[0].lower()
+        rest = parts[1] if len(parts) > 1 else ""
+        
+        # Handle subcommands
+        if subcommand in ["add", "a", "+"]:
+            # Add todo
+            if rest:
+                # Quick add
+                try:
+                    todo = self.todo_manager.quick_add(rest)
+                    self.console.print(f"[green]✅ Added todo: {todo.title} (ID: {todo.id})[/green]")
+                except ValueError as e:
+                    self.console.print(f"[red]Error: {e}[/red]")
+            else:
+                # Interactive add
+                await self.add_todo_interactive()
+        
+        elif subcommand in ["list", "ls", "l"]:
+            # List todos with optional filter
+            filter_parts = rest.split()
+            status = None
+            priority = None
+            tag = None
+            
+            for i in range(0, len(filter_parts), 2):
+                if i + 1 < len(filter_parts):
+                    key = filter_parts[i]
+                    value = filter_parts[i + 1]
+                    
+                    if key in ["status", "s"]:
+                        status = value
+                    elif key in ["priority", "p"]:
+                        priority = value
+                    elif key in ["tag", "t"]:
+                        tag = value
+            
+            todos = self.todo_manager.list_todos(status=status, priority=priority, tag=tag)
+            title = "Filtered Todos" if (status or priority or tag) else "All Todos"
+            self.todo_manager.display_todos(todos, title)
+        
+        elif subcommand in ["done", "d", "complete", "finish"]:
+            # Mark as done
+            if rest:
+                todo = self.todo_manager.update_todo(rest, status="done")
+                if todo:
+                    self.console.print(f"[green]✅ Marked as done: {todo.title}[/green]")
+                else:
+                    self.console.print(f"[red]Todo not found: {rest}[/red]")
+            else:
+                self.console.print("[yellow]Usage: /todo done <id>[/yellow]")
+        
+        elif subcommand in ["start", "begin", "progress"]:
+            # Mark as in progress
+            if rest:
+                todo = self.todo_manager.update_todo(rest, status="in_progress")
+                if todo:
+                    self.console.print(f"[cyan]🔄 Started: {todo.title}[/cyan]")
+                else:
+                    self.console.print(f"[red]Todo not found: {rest}[/red]")
+            else:
+                self.console.print("[yellow]Usage: /todo start <id>[/yellow]")
+        
+        elif subcommand in ["cancel", "x"]:
+            # Cancel todo
+            if rest:
+                todo = self.todo_manager.update_todo(rest, status="cancelled")
+                if todo:
+                    self.console.print(f"[red]❌ Cancelled: {todo.title}[/red]")
+                else:
+                    self.console.print(f"[red]Todo not found: {rest}[/red]")
+            else:
+                self.console.print("[yellow]Usage: /todo cancel <id>[/yellow]")
+        
+        elif subcommand in ["delete", "del", "rm", "remove"]:
+            # Delete todo
+            if rest:
+                if self.todo_manager.delete_todo(rest):
+                    self.console.print(f"[green]✅ Deleted todo: {rest}[/green]")
+                else:
+                    self.console.print(f"[red]Todo not found: {rest}[/red]")
+            else:
+                self.console.print("[yellow]Usage: /todo delete <id>[/yellow]")
+        
+        elif subcommand in ["view", "show", "detail"]:
+            # View todo detail
+            if rest:
+                todo = self.todo_manager.get_todo(rest)
+                if todo:
+                    self.todo_manager.display_todo_detail(todo)
+                else:
+                    self.console.print(f"[red]Todo not found: {rest}[/red]")
+            else:
+                self.console.print("[yellow]Usage: /todo view <id>[/yellow]")
+        
+        elif subcommand in ["stats", "statistics"]:
+            # Show statistics
+            self.todo_manager.display_statistics()
+        
+        elif subcommand in ["clear", "reset"]:
+            # Clear all todos (with confirmation)
+            try:
+                confirm = await self.session.prompt_async("Are you sure you want to delete ALL todos? (yes/no): ")
+                if confirm.lower() in ["yes", "y"]:
+                    self.todo_manager.todos = []
+                    self.todo_manager.save_todos()
+                    self.console.print("[green]✅ All todos cleared[/green]")
+                else:
+                    self.console.print("[yellow]Cancelled[/yellow]")
+            except (KeyboardInterrupt, EOFError):
+                self.console.print("[yellow]Cancelled[/yellow]")
+        
+        elif subcommand in ["help", "h", "?"]:
+            # Show todo help
+            self.show_todo_help()
+        
+        else:
+            # Unknown subcommand, treat as quick add
+            try:
+                todo = self.todo_manager.quick_add(args)
+                self.console.print(f"[green]✅ Added todo: {todo.title} (ID: {todo.id})[/green]")
+            except ValueError:
+                self.console.print(f"[yellow]Unknown todo command: {subcommand}[/yellow]")
+                self.console.print("[dim]Use /todo help for available commands[/dim]")
+    
+    async def add_todo_interactive(self):
+        """Add todo interactively."""
+        try:
+            # Get title
+            title = await self.session.prompt_async("Title: ")
+            if not title:
+                self.console.print("[yellow]Cancelled[/yellow]")
+                return
+            
+            # Get description
+            description = await self.session.prompt_async("Description (optional): ")
+            
+            # Get priority
+            priority = await self.session.prompt_async("Priority (low/medium/high/urgent) [medium]: ")
+            if not priority:
+                priority = "medium"
+            
+            # Get tags
+            tags_input = await self.session.prompt_async("Tags (comma-separated, optional): ")
+            tags = [t.strip() for t in tags_input.split(",") if t.strip()] if tags_input else []
+            
+            # Get due date
+            due_date = await self.session.prompt_async("Due date (optional): ")
+            
+            # Add todo
+            todo = self.todo_manager.add_todo(
+                title=title,
+                description=description,
+                priority=priority,
+                tags=tags,
+                due_date=due_date if due_date else None
+            )
+            
+            self.console.print(f"[green]✅ Added todo: {todo.title} (ID: {todo.id})[/green]")
+            
+        except (KeyboardInterrupt, EOFError):
+            self.console.print("[yellow]Cancelled[/yellow]")
+    
+    def show_todo_help(self):
+        """Show todo help."""
+        help_text = """
+[bold cyan]Todo Management[/bold cyan]
+
+[bold]Quick Add:[/bold]
+  /todo Buy milk #shopping !high @tomorrow
+  Format: title #tag1 #tag2 !priority @due_date
+
+[bold]Commands:[/bold]
+  /todo                  - List all todos
+  /todo add <text>       - Quick add todo
+  /todo list [filters]   - List with filters
+  /todo done <id>        - Mark as done
+  /todo start <id>       - Mark as in progress
+  /todo cancel <id>      - Cancel todo
+  /todo delete <id>      - Delete todo
+  /todo view <id>        - View todo details
+  /todo stats            - Show statistics
+  /todo clear            - Clear all todos
+  /todo help             - Show this help
+
+[bold]List Filters:[/bold]
+  /todo list status todo
+  /todo list priority high
+  /todo list tag work
+
+[bold]Shortcuts:[/bold]
+  /todo a    = add
+  /todo ls   = list
+  /todo d    = done
+  /todo rm   = delete
+"""
+        self.console.print(help_text)

hanzo/interactive/todo_manager.py

@@ -0,0 +1,457 @@
+"""Native todo management for Hanzo REPL."""
+
+import json
+import uuid
+from datetime import datetime
+from pathlib import Path
+from typing import List, Dict, Optional, Any
+from enum import Enum
+
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.text import Text
+from rich import box
+from rich.prompt import Prompt, Confirm
+
+
+class TodoPriority(Enum):
+    """Todo priority levels."""
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+    URGENT = "urgent"
+
+
+class TodoStatus(Enum):
+    """Todo status."""
+    TODO = "todo"
+    IN_PROGRESS = "in_progress"
+    DONE = "done"
+    CANCELLED = "cancelled"
+
+
+class Todo:
+    """Single todo item."""
+    
+    def __init__(
+        self,
+        title: str,
+        description: str = "",
+        priority: TodoPriority = TodoPriority.MEDIUM,
+        status: TodoStatus = TodoStatus.TODO,
+        tags: List[str] = None,
+        due_date: Optional[str] = None,
+        id: Optional[str] = None,
+        created_at: Optional[str] = None,
+        updated_at: Optional[str] = None,
+        completed_at: Optional[str] = None
+    ):
+        self.id = id or str(uuid.uuid4())[:8]
+        self.title = title
+        self.description = description
+        self.priority = priority
+        self.status = status
+        self.tags = tags or []
+        self.due_date = due_date
+        self.created_at = created_at or datetime.now().isoformat()
+        self.updated_at = updated_at or datetime.now().isoformat()
+        self.completed_at = completed_at
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "id": self.id,
+            "title": self.title,
+            "description": self.description,
+            "priority": self.priority.value,
+            "status": self.status.value,
+            "tags": self.tags,
+            "due_date": self.due_date,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+            "completed_at": self.completed_at
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Todo":
+        """Create from dictionary."""
+        return cls(
+            id=data.get("id"),
+            title=data["title"],
+            description=data.get("description", ""),
+            priority=TodoPriority(data.get("priority", "medium")),
+            status=TodoStatus(data.get("status", "todo")),
+            tags=data.get("tags", []),
+            due_date=data.get("due_date"),
+            created_at=data.get("created_at"),
+            updated_at=data.get("updated_at"),
+            completed_at=data.get("completed_at")
+        )
+
+
+class TodoManager:
+    """Manage todos with persistent storage."""
+    
+    def __init__(self, console: Optional[Console] = None):
+        self.console = console or Console()
+        self.config_dir = Path.home() / ".hanzo"
+        self.todos_file = self.config_dir / "todos.json"
+        self.todos: List[Todo] = []
+        self.load_todos()
+    
+    def load_todos(self):
+        """Load todos from file."""
+        if self.todos_file.exists():
+            try:
+                data = json.loads(self.todos_file.read_text())
+                self.todos = [Todo.from_dict(t) for t in data.get("todos", [])]
+            except Exception as e:
+                self.console.print(f"[red]Error loading todos: {e}[/red]")
+                self.todos = []
+        else:
+            self.todos = []
+    
+    def save_todos(self):
+        """Save todos to file."""
+        self.config_dir.mkdir(exist_ok=True)
+        data = {
+            "todos": [t.to_dict() for t in self.todos],
+            "last_updated": datetime.now().isoformat()
+        }
+        self.todos_file.write_text(json.dumps(data, indent=2))
+    
+    def add_todo(
+        self,
+        title: str,
+        description: str = "",
+        priority: str = "medium",
+        tags: List[str] = None,
+        due_date: Optional[str] = None
+    ) -> Todo:
+        """Add a new todo."""
+        try:
+            priority_enum = TodoPriority(priority.lower())
+        except ValueError:
+            priority_enum = TodoPriority.MEDIUM
+        
+        todo = Todo(
+            title=title,
+            description=description,
+            priority=priority_enum,
+            tags=tags or [],
+            due_date=due_date
+        )
+        
+        self.todos.append(todo)
+        self.save_todos()
+        
+        return todo
+    
+    def update_todo(self, todo_id: str, **kwargs) -> Optional[Todo]:
+        """Update a todo."""
+        todo = self.get_todo(todo_id)
+        if not todo:
+            return None
+        
+        # Update fields
+        if "title" in kwargs:
+            todo.title = kwargs["title"]
+        if "description" in kwargs:
+            todo.description = kwargs["description"]
+        if "priority" in kwargs:
+            try:
+                todo.priority = TodoPriority(kwargs["priority"].lower())
+            except ValueError:
+                pass
+        if "status" in kwargs:
+            try:
+                new_status = TodoStatus(kwargs["status"].lower())
+                todo.status = new_status
+                
+                # Update completed timestamp
+                if new_status == TodoStatus.DONE:
+                    todo.completed_at = datetime.now().isoformat()
+                elif todo.status == TodoStatus.DONE and new_status != TodoStatus.DONE:
+                    todo.completed_at = None
+            except ValueError:
+                pass
+        if "tags" in kwargs:
+            todo.tags = kwargs["tags"]
+        if "due_date" in kwargs:
+            todo.due_date = kwargs["due_date"]
+        
+        todo.updated_at = datetime.now().isoformat()
+        self.save_todos()
+        
+        return todo
+    
+    def delete_todo(self, todo_id: str) -> bool:
+        """Delete a todo."""
+        todo = self.get_todo(todo_id)
+        if todo:
+            self.todos.remove(todo)
+            self.save_todos()
+            return True
+        return False
+    
+    def get_todo(self, todo_id: str) -> Optional[Todo]:
+        """Get a todo by ID."""
+        for todo in self.todos:
+            if todo.id == todo_id:
+                return todo
+        return None
+    
+    def list_todos(
+        self,
+        status: Optional[str] = None,
+        priority: Optional[str] = None,
+        tag: Optional[str] = None
+    ) -> List[Todo]:
+        """List todos with optional filters."""
+        filtered = self.todos
+        
+        # Filter by status
+        if status:
+            try:
+                status_enum = TodoStatus(status.lower())
+                filtered = [t for t in filtered if t.status == status_enum]
+            except ValueError:
+                pass
+        
+        # Filter by priority
+        if priority:
+            try:
+                priority_enum = TodoPriority(priority.lower())
+                filtered = [t for t in filtered if t.priority == priority_enum]
+            except ValueError:
+                pass
+        
+        # Filter by tag
+        if tag:
+            filtered = [t for t in filtered if tag in t.tags]
+        
+        # Sort by priority and status
+        priority_order = {
+            TodoPriority.URGENT: 0,
+            TodoPriority.HIGH: 1,
+            TodoPriority.MEDIUM: 2,
+            TodoPriority.LOW: 3
+        }
+        
+        status_order = {
+            TodoStatus.IN_PROGRESS: 0,
+            TodoStatus.TODO: 1,
+            TodoStatus.DONE: 2,
+            TodoStatus.CANCELLED: 3
+        }
+        
+        filtered.sort(key=lambda t: (
+            status_order.get(t.status, 999),
+            priority_order.get(t.priority, 999),
+            t.created_at
+        ))
+        
+        return filtered
+    
+    def display_todos(
+        self,
+        todos: Optional[List[Todo]] = None,
+        title: str = "Todos"
+    ):
+        """Display todos in a nice table."""
+        if todos is None:
+            todos = self.list_todos()
+        
+        if not todos:
+            self.console.print("[yellow]No todos found[/yellow]")
+            return
+        
+        # Create table
+        table = Table(title=title, box=box.ROUNDED)
+        table.add_column("ID", style="cyan", width=8)
+        table.add_column("Status", width=12)
+        table.add_column("Priority", width=8)
+        table.add_column("Title", style="white")
+        table.add_column("Tags", style="dim")
+        table.add_column("Due", style="yellow")
+        
+        for todo in todos:
+            # Status emoji
+            status_display = {
+                TodoStatus.TODO: "⭕ Todo",
+                TodoStatus.IN_PROGRESS: "🔄 In Progress",
+                TodoStatus.DONE: "✅ Done",
+                TodoStatus.CANCELLED: "❌ Cancelled"
+            }.get(todo.status, todo.status.value)
+            
+            # Priority color
+            priority_color = {
+                TodoPriority.URGENT: "red bold",
+                TodoPriority.HIGH: "red",
+                TodoPriority.MEDIUM: "yellow",
+                TodoPriority.LOW: "green"
+            }.get(todo.priority, "white")
+            
+            priority_display = f"[{priority_color}]{todo.priority.value.upper()}[/{priority_color}]"
+            
+            # Tags
+            tags_display = ", ".join(todo.tags) if todo.tags else "-"
+            
+            # Due date
+            due_display = todo.due_date if todo.due_date else "-"
+            
+            table.add_row(
+                todo.id,
+                status_display,
+                priority_display,
+                todo.title,
+                tags_display,
+                due_display
+            )
+        
+        self.console.print(table)
+        
+        # Summary
+        total = len(todos)
+        done = len([t for t in todos if t.status == TodoStatus.DONE])
+        in_progress = len([t for t in todos if t.status == TodoStatus.IN_PROGRESS])
+        todo_count = len([t for t in todos if t.status == TodoStatus.TODO])
+        
+        summary = f"Total: {total} | Todo: {todo_count} | In Progress: {in_progress} | Done: {done}"
+        self.console.print(f"\n[dim]{summary}[/dim]")
+    
+    def display_todo_detail(self, todo: Todo):
+        """Display detailed view of a todo."""
+        # Status color
+        status_color = {
+            TodoStatus.TODO: "yellow",
+            TodoStatus.IN_PROGRESS: "cyan",
+            TodoStatus.DONE: "green",
+            TodoStatus.CANCELLED: "red"
+        }.get(todo.status, "white")
+        
+        # Priority color
+        priority_color = {
+            TodoPriority.URGENT: "red bold",
+            TodoPriority.HIGH: "red",
+            TodoPriority.MEDIUM: "yellow",
+            TodoPriority.LOW: "green"
+        }.get(todo.priority, "white")
+        
+        # Build content
+        content = f"""
+[bold]{todo.title}[/bold]
+
+[dim]ID:[/dim] {todo.id}
+[dim]Status:[/dim] [{status_color}]{todo.status.value.replace('_', ' ').title()}[/{status_color}]
+[dim]Priority:[/dim] [{priority_color}]{todo.priority.value.upper()}[/{priority_color}]
+[dim]Tags:[/dim] {', '.join(todo.tags) if todo.tags else 'None'}
+[dim]Due Date:[/dim] {todo.due_date if todo.due_date else 'Not set'}
+
+[dim]Description:[/dim]
+{todo.description if todo.description else 'No description'}
+
+[dim]Created:[/dim] {todo.created_at}
+[dim]Updated:[/dim] {todo.updated_at}
+[dim]Completed:[/dim] {todo.completed_at if todo.completed_at else 'Not completed'}
+"""
+        
+        panel = Panel(content.strip(), title=f"Todo: {todo.title}", box=box.ROUNDED)
+        self.console.print(panel)
+    
+    def quick_add(self, text: str) -> Todo:
+        """Quick add todo from text.
+        
+        Format: title #tag1 #tag2 !priority @due_date
+        """
+        import re
+        
+        # Extract tags (words starting with #)
+        tags = re.findall(r'#(\w+)', text)
+        text = re.sub(r'#\w+', '', text)
+        
+        # Extract priority (word after !)
+        priority_match = re.search(r'!(\w+)', text)
+        priority = priority_match.group(1) if priority_match else "medium"
+        text = re.sub(r'!\w+', '', text)
+        
+        # Extract due date (text after @)
+        due_match = re.search(r'@([^\s]+)', text)
+        due_date = due_match.group(1) if due_match else None
+        text = re.sub(r'@[^\s]+', '', text)
+        
+        # Clean up title
+        title = text.strip()
+        
+        if not title:
+            raise ValueError("Todo title cannot be empty")
+        
+        return self.add_todo(
+            title=title,
+            priority=priority,
+            tags=tags,
+            due_date=due_date
+        )
+    
+    def get_statistics(self) -> Dict[str, Any]:
+        """Get todo statistics."""
+        total = len(self.todos)
+        
+        # Status counts
+        status_counts = {}
+        for status in TodoStatus:
+            count = len([t for t in self.todos if t.status == status])
+            status_counts[status.value] = count
+        
+        # Priority counts
+        priority_counts = {}
+        for priority in TodoPriority:
+            count = len([t for t in self.todos if t.priority == priority])
+            priority_counts[priority.value] = count
+        
+        # Tags
+        all_tags = set()
+        for todo in self.todos:
+            all_tags.update(todo.tags)
+        
+        # Completion rate
+        done = status_counts.get("done", 0)
+        completion_rate = (done / total * 100) if total > 0 else 0
+        
+        return {
+            "total": total,
+            "status": status_counts,
+            "priority": priority_counts,
+            "tags": list(all_tags),
+            "completion_rate": completion_rate
+        }
+    
+    def display_statistics(self):
+        """Display todo statistics."""
+        stats = self.get_statistics()
+        
+        # Create stats panel
+        content = f"""
+[bold cyan]Todo Statistics[/bold cyan]
+
+[bold]Total Todos:[/bold] {stats['total']}
+[bold]Completion Rate:[/bold] {stats['completion_rate']:.1f}%
+
+[bold]By Status:[/bold]
+  ⭕ Todo: {stats['status'].get('todo', 0)}
+  🔄 In Progress: {stats['status'].get('in_progress', 0)}
+  ✅ Done: {stats['status'].get('done', 0)}
+  ❌ Cancelled: {stats['status'].get('cancelled', 0)}
+
+[bold]By Priority:[/bold]
+  🔴 Urgent: {stats['priority'].get('urgent', 0)}
+  🟠 High: {stats['priority'].get('high', 0)}
+  🟡 Medium: {stats['priority'].get('medium', 0)}
+  🟢 Low: {stats['priority'].get('low', 0)}
+
+[bold]Tags:[/bold] {', '.join(stats['tags']) if stats['tags'] else 'None'}
+"""
+        
+        panel = Panel(content.strip(), title="📊 Statistics", box=box.ROUNDED)
+        self.console.print(panel)

hanzo/tools/detector.py

@@ -3,6 +3,7 @@
 import os
 import shutil
 import subprocess
+import httpx
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple
 from dataclasses import dataclass
@@ -33,12 +34,33 @@ class ToolDetector:
     
     # Define available tools with priority order
     TOOLS = [
+        # Hanzo Local Node - highest priority for privacy and local control
+        AITool(
+            name="hanzod",
+            command="hanzo node",
+            display_name="Hanzo Node (Local Private AI)",
+            provider="hanzo-local",
+            priority=0,  # Highest priority - local and private
+            check_command=None,  # Check via API endpoint
+            api_endpoint="http://localhost:8000/health",
+            env_var=None
+        ),
+        AITool(
+            name="hanzo-router",
+            command="hanzo router",
+            display_name="Hanzo Router (LLM Proxy)",
+            provider="hanzo-router",
+            priority=1,
+            check_command=None,
+            api_endpoint="http://localhost:4000/health",
+            env_var=None
+        ),
         AITool(
             name="claude-code",
             command="claude",
             display_name="Claude Code",
             provider="anthropic",
-            priority=1,
+            priority=2,
             check_command="claude --version",
             env_var="ANTHROPIC_API_KEY"
         ),
@@ -47,7 +69,7 @@ class ToolDetector:
             command="hanzo dev",
             display_name="Hanzo Dev (Native)",
             provider="hanzo",
-            priority=2,
+            priority=3,
             check_command="hanzo --version",
             env_var="HANZO_API_KEY"
         ),
@@ -56,7 +78,7 @@ class ToolDetector:
             command="openai",
             display_name="OpenAI Codex",
             provider="openai",
-            priority=3,
+            priority=4,
             check_command="openai --version",
             env_var="OPENAI_API_KEY"
         ),
@@ -65,7 +87,7 @@ class ToolDetector:
             command="gemini",
             display_name="Gemini CLI",
             provider="google",
-            priority=4,
+            priority=5,
             check_command="gemini --version",
             env_var="GEMINI_API_KEY"
         ),
@@ -74,7 +96,7 @@ class ToolDetector:
             command="grok",
             display_name="Grok CLI",
             provider="xai",
-            priority=5,
+            priority=6,
             check_command="grok --version",
             env_var="GROK_API_KEY"
         ),
@@ -83,7 +105,7 @@ class ToolDetector:
             command="openhands",
             display_name="OpenHands CLI",
             provider="openhands",
-            priority=6,
+            priority=7,
             check_command="openhands --version",
             env_var=None
         ),
@@ -92,7 +114,7 @@ class ToolDetector:
             command="cursor",
             display_name="Cursor AI",
             provider="cursor",
-            priority=7,
+            priority=8,
             check_command="cursor --version",
             env_var=None
         ),
@@ -101,7 +123,7 @@ class ToolDetector:
             command="codeium",
             display_name="Codeium",
             provider="codeium",
-            priority=8,
+            priority=9,
             check_command="codeium --version",
             env_var="CODEIUM_API_KEY"
         ),
@@ -110,7 +132,7 @@ class ToolDetector:
             command="aider",
             display_name="Aider",
             provider="aider",
-            priority=9,
+            priority=10,
             check_command="aider --version",
             env_var=None
         ),
@@ -119,7 +141,7 @@ class ToolDetector:
             command="continue",
             display_name="Continue Dev",
             provider="continue",
-            priority=10,
+            priority=11,
             check_command="continue --version",
             env_var=None
         )
@@ -143,26 +165,51 @@ class ToolDetector:
     
     def detect_tool(self, tool: AITool) -> bool:
         """Detect if a specific tool is available."""
+        # Check API endpoint first (for services like hanzod)
+        if tool.api_endpoint:
+            try:
+                response = httpx.get(tool.api_endpoint, timeout=1.0)
+                if response.status_code == 200:
+                    tool.detected = True
+                    tool.version = "Running"
+                    
+                    # Special handling for Hanzo services
+                    if tool.name == "hanzod":
+                        # Check if models are loaded
+                        try:
+                            models_response = httpx.get("http://localhost:8000/models", timeout=1.0)
+                            if models_response.status_code == 200:
+                                models = models_response.json()
+                                if models:
+                                    tool.version = f"Running ({len(models)} models)"
+                        except:
+                            pass
+                    
+                    return True
+            except:
+                pass
+        
         # 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
+        if tool.command:
+            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):
@@ -229,13 +276,25 @@ class ToolDetector:
         if self.detected_tools:
             default = self.detected_tools[0]
             self.console.print(f"\n[green]Default tool: {default.display_name}[/green]")
+            
+            # Special message for Hanzo Node
+            if default.name == "hanzod":
+                self.console.print("[cyan]🔒 Using local private AI - your data stays on your machine[/cyan]")
+                self.console.print("[dim]Manage models with: hanzo node models[/dim]")
         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]")
+            self.console.print("[dim]Start Hanzo Node for local AI: hanzo node start[/dim]")
+            self.console.print("[dim]Or install Claude Code, OpenAI CLI, etc.[/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":
+        if tool.name == "hanzod":
+            # Use the local Hanzo node API
+            return ["hanzo", "ask", "--local", prompt]
+        elif tool.name == "hanzo-router":
+            # Use the router proxy
+            return ["hanzo", "ask", "--router", prompt]
+        elif tool.name == "claude-code":
             return ["claude", prompt]
         elif tool.name == "hanzo-dev":
             return ["hanzo", "dev", "--prompt", prompt]
@@ -257,6 +316,43 @@ class ToolDetector:
     def execute_with_tool(self, tool: AITool, prompt: str) -> Tuple[bool, str]:
         """Execute a prompt with a specific tool."""
         try:
+            # Special handling for Hanzo services
+            if tool.name == "hanzod":
+                # Use the local API directly
+                try:
+                    response = httpx.post(
+                        "http://localhost:8000/chat/completions",
+                        json={
+                            "messages": [{"role": "user", "content": prompt}],
+                            "stream": False
+                        },
+                        timeout=30.0
+                    )
+                    if response.status_code == 200:
+                        result = response.json()
+                        return True, result.get("choices", [{}])[0].get("message", {}).get("content", "")
+                except Exception as e:
+                    return False, f"Hanzo Node error: {e}"
+            
+            elif tool.name == "hanzo-router":
+                # Use the router API
+                try:
+                    response = httpx.post(
+                        "http://localhost:4000/chat/completions",
+                        json={
+                            "messages": [{"role": "user", "content": prompt}],
+                            "model": "gpt-3.5-turbo",  # Router will route to best available
+                            "stream": False
+                        },
+                        timeout=30.0
+                    )
+                    if response.status_code == 200:
+                        result = response.json()
+                        return True, result.get("choices", [{}])[0].get("message", {}).get("content", "")
+                except Exception as e:
+                    return False, f"Router error: {e}"
+            
+            # Default command execution
             command = self.get_tool_command(tool, prompt)
             result = subprocess.run(
                 command,

{hanzo-0.3.26.dist-info → hanzo-0.3.28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hanzo
-Version: 0.3.26
+Version: 0.3.28
 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

{hanzo-0.3.26.dist-info → hanzo-0.3.28.dist-info}/RECORD

@@ -1,4 +1,4 @@
-hanzo/__init__.py,sha256=LfN4DPjEcez05Rm3sPHjkvkZyjKX9G3flmwmBPSaXrc,185
+hanzo/__init__.py,sha256=g4XELSN8aLffy0YoVIjALuubohGyKAN9lejacSqkEOs,185
 hanzo/__main__.py,sha256=F3Vz0Ty3bdAj_8oxyETMIqxlmNRnJOAFB1XPxbyfouI,105
 hanzo/base_agent.py,sha256=ojPaSgFETYl7iARWnNpg8eyAt7sg8eKhn9xZThyvxRA,15324
 hanzo/batch_orchestrator.py,sha256=vn6n5i9gTfZ4DtowFDd5iWgYKjgNTioIomkffKbipSM,35827
@@ -27,12 +27,13 @@ hanzo/commands/router.py,sha256=kB8snUM82cFk3znjFvs3jOJGqv5giKn8DiTkdbXnWYU,5332
 hanzo/commands/tools.py,sha256=fG27wRweVmaFJowBpmwp5PgkRUtIF8bIlu_hGWr69Ss,10393
 hanzo/interactive/__init__.py,sha256=ENHkGOqu-JYI05lqoOKDczJGl96oq6nM476EPhflAbI,74
 hanzo/interactive/dashboard.py,sha256=XB5H_PMlReriCip-wW9iuUiJQOAtSATFG8EyhhFhItU,3842
-hanzo/interactive/enhanced_repl.py,sha256=dmYun_rtWswoxVIVGamKASMJVS7QK5-TkuS_lIVzb4w,25493
+hanzo/interactive/enhanced_repl.py,sha256=G_r1MEg3F0Hq9PQiDuJfiOYA2KT5A6_f-xerJWvTSo0,34235
 hanzo/interactive/model_selector.py,sha256=4HcXvr8AI8Y5IttMH7Dhb8M0vqzP5y3S5kQrQmopYuw,5519
 hanzo/interactive/repl.py,sha256=PXpRw1Cfqdqy1pQsKLqz9AwKJBFZ_Y758MpDlJIb9ao,6938
+hanzo/interactive/todo_manager.py,sha256=tKsmfN4snILLkgwnjQcStP4CxYfNCXS5_pvQfmxkIjw,14640
 hanzo/router/__init__.py,sha256=_cRG9nHC_wwq17iVYZSUNBYiJDdByfLDVEuIQn5-ePM,978
 hanzo/tools/__init__.py,sha256=SsgmDvw5rO--NF4vKL9tV3O4WCNEl9aAIuqyTGSZ4RQ,122
-hanzo/tools/detector.py,sha256=xCpIkva4GZ2s92j2I63B7Q-rSohaHrXfeVOSOeiDL-U,9756
+hanzo/tools/detector.py,sha256=qwVc1fIDt2lDuqFqjhTVCnToRka91n125mpOpsPCfTU,14054
 hanzo/ui/__init__.py,sha256=Ea22ereOm5Y0DDfyonA6qsO9Qkzofzd1CUE-VGW2lqw,241
 hanzo/ui/inline_startup.py,sha256=7Y5dwqzt-L1J0F9peyqJ8XZgjHSua2nkItDTrLlBnhU,4265
 hanzo/ui/startup.py,sha256=s7gP1QleQEIoCS1K0XBY7d6aufnwhicRLZDL7ej8ZZY,12235
@@ -40,7 +41,7 @@ hanzo/utils/__init__.py,sha256=5RRwKI852vp8smr4xCRgeKfn7dLEnHbdXGfVYTZ5jDQ,69
 hanzo/utils/config.py,sha256=FD_LoBpcoF5dgJ7WL4o6LDp2pdOy8kS-dJ6iRO2GcGM,4728
 hanzo/utils/net_check.py,sha256=YFbJ65SzfDYHkHLZe3n51VhId1VI3zhyx8p6BM-l6jE,3017
 hanzo/utils/output.py,sha256=W0j3psF07vJiX4s02gbN4zYWfbKNsb8TSIoagBSf5vA,2704
-hanzo-0.3.26.dist-info/METADATA,sha256=uZcjicpcs7ZJMa4YqgpNYifLYPA5CqkEKpzZEPRVrzg,6061
-hanzo-0.3.26.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hanzo-0.3.26.dist-info/entry_points.txt,sha256=pQLPMdqOXU_2BfTcMDhkqTCDNk_H6ApvYuSaWcuQOOw,171
-hanzo-0.3.26.dist-info/RECORD,,
+hanzo-0.3.28.dist-info/METADATA,sha256=19BVN0yCDTn0FUruIXi1Mnh3VyqvlINVgySZ_HfYJ4o,6061
+hanzo-0.3.28.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hanzo-0.3.28.dist-info/entry_points.txt,sha256=pQLPMdqOXU_2BfTcMDhkqTCDNk_H6ApvYuSaWcuQOOw,171
+hanzo-0.3.28.dist-info/RECORD,,