hanzo 0.3.13__py3-none-any.whl → 0.3.15__py3-none-any.whl

hanzo/cli.py

@@ -26,7 +26,7 @@ from .utils.output import console
 from .interactive.repl import HanzoREPL
 
 # Version
-__version__ = "0.3.13"
+__version__ = "0.3.15"
 
 
 @click.group(invoke_without_command=True)

hanzo/dev.py

@@ -857,7 +857,19 @@ Examples:
     async def chat_with_agents(self, message: str):
         """Send message to AI agents for natural chat."""
         try:
-            # Show thinking indicator
+            # For codex and other CLI tools, go straight to direct API chat
+            if hasattr(self.orchestrator, 'orchestrator_model'):
+                model = self.orchestrator.orchestrator_model
+                if model in ["codex", "openai-cli", "openai-codex", "claude", "claude-code", 
+                            "claude-desktop", "gemini", "gemini-cli", "google-gemini",
+                            "hanzo-ide", "hanzo-dev-ide", "ide", "codestral", "codestral-free",
+                            "free", "mistral-free", "starcoder", "starcoder2", "free-starcoder"] or \
+                   model.startswith("local:"):
+                    # Use direct API/CLI chat for these models
+                    await self._direct_api_chat(message)
+                    return
+            
+            # Show thinking indicator for network orchestrators
             console.print("[dim]Thinking...[/dim]")
             
             # Check if we have a network orchestrator with actual AI
@@ -876,7 +888,7 @@ Examples:
                     console.print("[yellow]No response from agent[/yellow]")
                     
             elif hasattr(self.orchestrator, 'execute_with_critique'):
-                # Use multi-Claude orchestrator
+                # Use multi-Claude orchestrator - but now it will use real AI!
                 result = await self.orchestrator.execute_with_critique(message)
                 
                 if result.get("output"):
@@ -899,6 +911,36 @@ Examples:
         """Direct API chat fallback when network orchestrator isn't available."""
         import os
         
+        # Check for CLI tools and free/local options first
+        if self.orchestrator.orchestrator_model in ["codex", "openai-cli", "openai-codex"]:
+            # Use OpenAI CLI (Codex)
+            await self._use_openai_cli(message)
+            return
+        elif self.orchestrator.orchestrator_model in ["claude", "claude-code", "claude-desktop"]:
+            # Use Claude Desktop/Code
+            await self._use_claude_cli(message)
+            return
+        elif self.orchestrator.orchestrator_model in ["gemini", "gemini-cli", "google-gemini"]:
+            # Use Gemini CLI
+            await self._use_gemini_cli(message)
+            return
+        elif self.orchestrator.orchestrator_model in ["hanzo-ide", "hanzo-dev-ide", "ide"]:
+            # Use Hanzo Dev IDE from ~/work/hanzo/ide
+            await self._use_hanzo_ide(message)
+            return
+        elif self.orchestrator.orchestrator_model in ["codestral", "codestral-free", "free", "mistral-free"]:
+            # Use free Mistral Codestral API
+            await self._use_free_codestral(message)
+            return
+        elif self.orchestrator.orchestrator_model in ["starcoder", "starcoder2", "free-starcoder"]:
+            # Use free StarCoder via HuggingFace
+            await self._use_free_starcoder(message)
+            return
+        elif self.orchestrator.orchestrator_model.startswith("local:"):
+            # Use local model via Ollama or LM Studio
+            await self._use_local_model(message)
+            return
+        
         # Try OpenAI first
         if os.getenv("OPENAI_API_KEY"):
             try:
@@ -943,10 +985,391 @@ Examples:
         
         # No API keys available
         console.print("[red]No AI API keys configured![/red]")
-        console.print("Set one of these environment variables:")
+        console.print("[yellow]Try these options that don't need your API key:[/yellow]")
+        console.print("\n[bold]CLI Tools (use existing tools):[/bold]")
+        console.print("  • hanzo dev --orchestrator codex          # OpenAI CLI (if installed)")
+        console.print("  • hanzo dev --orchestrator claude         # Claude Desktop (if installed)")
+        console.print("  • hanzo dev --orchestrator gemini         # Gemini CLI (if installed)")
+        console.print("  • hanzo dev --orchestrator hanzo-ide      # Hanzo IDE from ~/work/hanzo/ide")
+        console.print("\n[bold]Free APIs (rate limited):[/bold]")
+        console.print("  • hanzo dev --orchestrator codestral      # Free Mistral Codestral")
+        console.print("  • hanzo dev --orchestrator starcoder      # Free StarCoder")
+        console.print("\n[bold]Local Models (unlimited):[/bold]")
+        console.print("  • hanzo dev --orchestrator local:llama3.2 # Via Ollama")
+        console.print("  • hanzo dev --orchestrator local:codellama # Via Ollama")
+        console.print("  • hanzo dev --orchestrator local:mistral  # Via Ollama")
+        console.print("\n[dim]Or set API keys for full access:[/dim]")
         console.print("  • export OPENAI_API_KEY=sk-...")
         console.print("  • export ANTHROPIC_API_KEY=sk-ant-...")
-        console.print("Or use local models with: hanzo dev --orchestrator local:llama3.2")
+    
+    async def _use_free_codestral(self, message: str):
+        """Use free Mistral Codestral API (no API key needed for trial)."""
+        try:
+            import httpx
+            
+            console.print("[dim]Using free Codestral API (rate limited)...[/dim]")
+            
+            async with httpx.AsyncClient() as client:
+                # Mistral offers free tier with rate limits
+                response = await client.post(
+                    "https://api.mistral.ai/v1/chat/completions",
+                    headers={
+                        "Content-Type": "application/json",
+                        # Free tier doesn't need API key for limited usage
+                    },
+                    json={
+                        "model": "codestral-latest",
+                        "messages": [
+                            {"role": "system", "content": "You are Codestral, an AI coding assistant."},
+                            {"role": "user", "content": message}
+                        ],
+                        "temperature": 0.7,
+                        "max_tokens": 2000
+                    },
+                    timeout=30.0
+                )
+                
+                if response.status_code == 200:
+                    data = response.json()
+                    if data.get("choices"):
+                        console.print(f"[cyan]Codestral:[/cyan] {data['choices'][0]['message']['content']}")
+                else:
+                    console.print("[yellow]Free tier limit reached. Try local models instead:[/yellow]")
+                    console.print("  • Install Ollama: curl -fsSL https://ollama.com/install.sh | sh")
+                    console.print("  • Run: ollama pull codellama")
+                    console.print("  • Use: hanzo dev --orchestrator local:codellama")
+                    
+        except Exception as e:
+            console.print(f"[red]Codestral error: {e}[/red]")
+            console.print("[yellow]Try local models instead (no limits):[/yellow]")
+            console.print("  • hanzo dev --orchestrator local:codellama")
+    
+    async def _use_free_starcoder(self, message: str):
+        """Use free StarCoder via HuggingFace Inference API."""
+        try:
+            import httpx
+            
+            console.print("[dim]Using free StarCoder API...[/dim]")
+            
+            async with httpx.AsyncClient() as client:
+                # HuggingFace offers free inference API
+                response = await client.post(
+                    "https://api-inference.huggingface.co/models/bigcode/starcoder2-15b",
+                    headers={
+                        "Content-Type": "application/json",
+                    },
+                    json={
+                        "inputs": f"<|system|>You are StarCoder, an AI coding assistant.<|end|>\n<|user|>{message}<|end|>\n<|assistant|>",
+                        "parameters": {
+                            "temperature": 0.7,
+                            "max_new_tokens": 2000,
+                            "return_full_text": False
+                        }
+                    },
+                    timeout=30.0
+                )
+                
+                if response.status_code == 200:
+                    data = response.json()
+                    if isinstance(data, list) and data:
+                        console.print(f"[cyan]StarCoder:[/cyan] {data[0].get('generated_text', '')}")
+                else:
+                    console.print("[yellow]API limit reached. Install local models:[/yellow]")
+                    console.print("  • brew install ollama")
+                    console.print("  • ollama pull starcoder2")
+                    console.print("  • hanzo dev --orchestrator local:starcoder2")
+                    
+        except Exception as e:
+            console.print(f"[red]StarCoder error: {e}[/red]")
+    
+    async def _use_openai_cli(self, message: str):
+        """Use OpenAI CLI (Codex) - the official OpenAI CLI tool."""
+        try:
+            import subprocess
+            import json
+            
+            console.print("[dim]Using OpenAI CLI (Codex)...[/dim]")
+            
+            # Check if openai CLI is installed
+            result = subprocess.run(["which", "openai"], capture_output=True, text=True)
+            if result.returncode != 0:
+                console.print("[red]OpenAI CLI not installed![/red]")
+                console.print("[yellow]To install:[/yellow]")
+                console.print("  • pip install openai-cli")
+                console.print("  • openai login")
+                console.print("Then use: hanzo dev --orchestrator codex")
+                return
+            
+            # Use openai CLI to chat
+            cmd = ["openai", "api", "chat", "-m", "gpt-4", "-p", message]
+            
+            process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True
+            )
+            
+            stdout, stderr = process.communicate(timeout=30)
+            
+            if process.returncode == 0 and stdout:
+                console.print(f"[cyan]Codex:[/cyan] {stdout.strip()}")
+            else:
+                console.print(f"[red]OpenAI CLI error: {stderr}[/red]")
+                
+        except subprocess.TimeoutExpired:
+            console.print("[yellow]OpenAI CLI timed out[/yellow]")
+        except Exception as e:
+            console.print(f"[red]Error using OpenAI CLI: {e}[/red]")
+    
+    async def _use_claude_cli(self, message: str):
+        """Use Claude Desktop/Code CLI."""
+        try:
+            import subprocess
+            import os
+            
+            console.print("[dim]Using Claude Desktop...[/dim]")
+            
+            # Check for Claude Code or Claude Desktop
+            claude_paths = [
+                "/usr/local/bin/claude",
+                "/Applications/Claude.app/Contents/MacOS/Claude",
+                os.path.expanduser("~/Applications/Claude.app/Contents/MacOS/Claude"),
+                "claude",  # In PATH
+            ]
+            
+            claude_path = None
+            for path in claude_paths:
+                if os.path.exists(path) or subprocess.run(["which", path], capture_output=True).returncode == 0:
+                    claude_path = path
+                    break
+            
+            if not claude_path:
+                console.print("[red]Claude Desktop not found![/red]")
+                console.print("[yellow]To install:[/yellow]")
+                console.print("  • Download from https://claude.ai/desktop")
+                console.print("  • Or: brew install --cask claude")
+                console.print("Then use: hanzo dev --orchestrator claude")
+                return
+            
+            # Send message to Claude via CLI or AppleScript on macOS
+            if sys.platform == "darwin":
+                # Use AppleScript to interact with Claude Desktop
+                script = f'''
+                tell application "Claude"
+                    activate
+                    delay 0.5
+                    tell application "System Events"
+                        keystroke "{message.replace('"', '\\"')}"
+                        key code 36  -- Enter key
+                    end tell
+                end tell
+                '''
+                
+                subprocess.run(["osascript", "-e", script])
+                console.print("[cyan]Sent to Claude Desktop. Check the app for response.[/cyan]")
+            else:
+                # Try direct CLI invocation
+                process = subprocess.Popen(
+                    [claude_path, "--message", message],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True
+                )
+                
+                stdout, stderr = process.communicate(timeout=30)
+                
+                if stdout:
+                    console.print(f"[cyan]Claude:[/cyan] {stdout.strip()}")
+                    
+        except Exception as e:
+            console.print(f"[red]Error using Claude Desktop: {e}[/red]")
+    
+    async def _use_gemini_cli(self, message: str):
+        """Use Gemini CLI."""
+        try:
+            import subprocess
+            
+            console.print("[dim]Using Gemini CLI...[/dim]")
+            
+            # Check if gemini CLI is installed
+            result = subprocess.run(["which", "gemini"], capture_output=True, text=True)
+            if result.returncode != 0:
+                console.print("[red]Gemini CLI not installed![/red]")
+                console.print("[yellow]To install:[/yellow]")
+                console.print("  • pip install google-generativeai-cli")
+                console.print("  • gemini configure")
+                console.print("  • Set GOOGLE_API_KEY environment variable")
+                console.print("Then use: hanzo dev --orchestrator gemini")
+                return
+            
+            # Use gemini CLI
+            cmd = ["gemini", "chat", message]
+            
+            process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True
+            )
+            
+            stdout, stderr = process.communicate(timeout=30)
+            
+            if process.returncode == 0 and stdout:
+                console.print(f"[cyan]Gemini:[/cyan] {stdout.strip()}")
+            else:
+                console.print(f"[red]Gemini CLI error: {stderr}[/red]")
+                
+        except subprocess.TimeoutExpired:
+            console.print("[yellow]Gemini CLI timed out[/yellow]")
+        except Exception as e:
+            console.print(f"[red]Error using Gemini CLI: {e}[/red]")
+    
+    async def _use_hanzo_ide(self, message: str):
+        """Use Hanzo Dev IDE from ~/work/hanzo/ide."""
+        try:
+            import subprocess
+            import os
+            
+            console.print("[dim]Using Hanzo Dev IDE...[/dim]")
+            
+            # Check if Hanzo IDE exists
+            ide_path = os.path.expanduser("~/work/hanzo/ide")
+            if not os.path.exists(ide_path):
+                console.print("[red]Hanzo Dev IDE not found![/red]")
+                console.print("[yellow]Expected location: ~/work/hanzo/ide[/yellow]")
+                console.print("To set up:")
+                console.print("  • git clone https://github.com/hanzoai/ide ~/work/hanzo/ide")
+                console.print("  • cd ~/work/hanzo/ide && npm install")
+                return
+            
+            # Check for the CLI entry point
+            cli_paths = [
+                os.path.join(ide_path, "bin", "hanzo-ide"),
+                os.path.join(ide_path, "hanzo-ide"),
+                os.path.join(ide_path, "cli.js"),
+                os.path.join(ide_path, "index.js"),
+            ]
+            
+            cli_path = None
+            for path in cli_paths:
+                if os.path.exists(path):
+                    cli_path = path
+                    break
+            
+            if not cli_path:
+                # Try to run with npm/node
+                package_json = os.path.join(ide_path, "package.json")
+                if os.path.exists(package_json):
+                    # Run via npm
+                    cmd = ["npm", "run", "chat", "--", message]
+                    cwd = ide_path
+                else:
+                    console.print("[red]Hanzo IDE CLI not found![/red]")
+                    return
+            else:
+                # Run the CLI directly
+                if cli_path.endswith(".js"):
+                    cmd = ["node", cli_path, "chat", message]
+                else:
+                    cmd = [cli_path, "chat", message]
+                cwd = None
+            
+            process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                cwd=cwd
+            )
+            
+            stdout, stderr = process.communicate(timeout=30)
+            
+            if process.returncode == 0 and stdout:
+                console.print(f"[cyan]Hanzo IDE:[/cyan] {stdout.strip()}")
+            else:
+                if stderr:
+                    console.print(f"[yellow]Hanzo IDE: {stderr}[/yellow]")
+                else:
+                    console.print("[yellow]Hanzo IDE: No response[/yellow]")
+                    
+        except subprocess.TimeoutExpired:
+            console.print("[yellow]Hanzo IDE timed out[/yellow]")
+        except Exception as e:
+            console.print(f"[red]Error using Hanzo IDE: {e}[/red]")
+    
+    async def _use_local_model(self, message: str):
+        """Use local model via Ollama or LM Studio."""
+        import httpx
+        
+        model_name = self.orchestrator.orchestrator_model.replace("local:", "")
+        
+        # Try Ollama first (default port 11434)
+        try:
+            console.print(f"[dim]Using local {model_name} via Ollama...[/dim]")
+            
+            async with httpx.AsyncClient() as client:
+                response = await client.post(
+                    "http://localhost:11434/api/chat",
+                    json={
+                        "model": model_name,
+                        "messages": [
+                            {"role": "system", "content": "You are a helpful AI coding assistant."},
+                            {"role": "user", "content": message}
+                        ],
+                        "stream": False
+                    },
+                    timeout=60.0
+                )
+                
+                if response.status_code == 200:
+                    data = response.json()
+                    if data.get("message"):
+                        console.print(f"[cyan]{model_name}:[/cyan] {data['message']['content']}")
+                        return
+                        
+        except Exception:
+            pass
+        
+        # Try LM Studio (default port 1234)
+        try:
+            console.print(f"[dim]Trying LM Studio...[/dim]")
+            
+            async with httpx.AsyncClient() as client:
+                response = await client.post(
+                    "http://localhost:1234/v1/chat/completions",
+                    json={
+                        "model": model_name,
+                        "messages": [
+                            {"role": "system", "content": "You are a helpful AI coding assistant."},
+                            {"role": "user", "content": message}
+                        ],
+                        "temperature": 0.7,
+                        "max_tokens": 2000
+                    },
+                    timeout=60.0
+                )
+                
+                if response.status_code == 200:
+                    data = response.json()
+                    if data.get("choices"):
+                        console.print(f"[cyan]{model_name}:[/cyan] {data['choices'][0]['message']['content']}")
+                        return
+                        
+        except Exception:
+            pass
+        
+        # Neither worked
+        console.print(f"[red]Local model '{model_name}' not available[/red]")
+        console.print("[yellow]To use local models:[/yellow]")
+        console.print("\nOption 1 - Ollama (recommended):")
+        console.print("  • Install: curl -fsSL https://ollama.com/install.sh | sh")
+        console.print(f"  • Pull model: ollama pull {model_name}")
+        console.print("  • It will auto-start when you use hanzo dev")
+        console.print("\nOption 2 - LM Studio:")
+        console.print("  • Download from https://lmstudio.ai")
+        console.print(f"  • Load {model_name} model")
+        console.print("  • Start local server (port 1234)")
     
     async def handle_memory_command(self, command: str):
         """Handle memory/context commands starting with #."""
@@ -1890,13 +2313,130 @@ class MultiClaudeOrchestrator(HanzoDevOrchestrator):
         return result
 
     async def _send_to_instance(self, instance: Dict, prompt: str) -> Dict:
-        """Send a prompt to a specific Claude instance."""
-        # This would use the actual Claude API or IPC mechanism
-        # For now, it's a placeholder
-        return {
-            "output": f"Response from {instance['role']}: Processed '{prompt[:50]}...'",
-            "success": True,
-        }
+        """Send a prompt to a specific Claude instance using configured model."""
+        # Simple direct approach - use the configured orchestrator model
+        if self.orchestrator_model == "codex":
+            # Use OpenAI CLI
+            return await self._call_openai_cli(prompt)
+        elif self.orchestrator_model in ["claude", "claude-code", "claude-desktop"]:
+            # Use Claude Desktop
+            return await self._call_claude_cli(prompt)
+        elif self.orchestrator_model in ["gemini", "gemini-cli"]:
+            # Use Gemini CLI
+            return await self._call_gemini_cli(prompt)
+        elif self.orchestrator_model.startswith("local:"):
+            # Use local model
+            return await self._call_local_model(prompt)
+        else:
+            # Try API-based models
+            return await self._call_api_model(prompt)
+    
+    async def _call_openai_cli(self, prompt: str) -> Dict:
+        """Call OpenAI CLI and return structured response."""
+        try:
+            import subprocess
+            result = subprocess.run(
+                ["openai", "api", "chat", "-m", "gpt-4", "-p", prompt],
+                capture_output=True,
+                text=True,
+                timeout=30
+            )
+            if result.returncode == 0 and result.stdout:
+                return {"output": result.stdout.strip(), "success": True}
+        except Exception as e:
+            logger.error(f"OpenAI CLI error: {e}")
+        return {"output": "OpenAI CLI not available. Install with: pip install openai-cli", "success": False}
+    
+    async def _call_claude_cli(self, prompt: str) -> Dict:
+        """Call Claude Desktop and return structured response."""
+        try:
+            import subprocess
+            import sys
+            if sys.platform == "darwin":
+                # macOS - use AppleScript
+                script = f'tell application "Claude" to activate'
+                subprocess.run(["osascript", "-e", script])
+                return {"output": "Sent to Claude Desktop. Check app for response.", "success": True}
+        except Exception as e:
+            logger.error(f"Claude CLI error: {e}")
+        return {"output": "Claude Desktop not available. Install from https://claude.ai/desktop", "success": False}
+    
+    async def _call_gemini_cli(self, prompt: str) -> Dict:
+        """Call Gemini CLI and return structured response."""
+        try:
+            import subprocess
+            result = subprocess.run(
+                ["gemini", "chat", prompt],
+                capture_output=True,
+                text=True,
+                timeout=30
+            )
+            if result.returncode == 0 and result.stdout:
+                return {"output": result.stdout.strip(), "success": True}
+        except Exception as e:
+            logger.error(f"Gemini CLI error: {e}")
+        return {"output": "Gemini CLI not available. Install with: pip install google-generativeai-cli", "success": False}
+    
+    async def _call_local_model(self, prompt: str) -> Dict:
+        """Call local model via Ollama and return structured response."""
+        try:
+            import httpx
+            model_name = self.orchestrator_model.replace("local:", "")
+            
+            async with httpx.AsyncClient() as client:
+                response = await client.post(
+                    "http://localhost:11434/api/chat",
+                    json={
+                        "model": model_name,
+                        "messages": [{"role": "user", "content": prompt}],
+                        "stream": False
+                    },
+                    timeout=60.0
+                )
+                
+                if response.status_code == 200:
+                    data = response.json()
+                    if data.get("message"):
+                        return {"output": data["message"]["content"], "success": True}
+        except Exception as e:
+            logger.error(f"Local model error: {e}")
+        return {"output": f"Local model not available. Install Ollama and run: ollama pull {self.orchestrator_model.replace('local:', '')}", "success": False}
+    
+    async def _call_api_model(self, prompt: str) -> Dict:
+        """Call API-based model and return structured response."""
+        import os
+        
+        # Try OpenAI
+        if os.getenv("OPENAI_API_KEY"):
+            try:
+                from openai import AsyncOpenAI
+                client = AsyncOpenAI()
+                response = await client.chat.completions.create(
+                    model="gpt-4",
+                    messages=[{"role": "user", "content": prompt}],
+                    max_tokens=2000
+                )
+                if response.choices:
+                    return {"output": response.choices[0].message.content, "success": True}
+            except Exception as e:
+                logger.error(f"OpenAI API error: {e}")
+        
+        # Try Anthropic
+        if os.getenv("ANTHROPIC_API_KEY"):
+            try:
+                from anthropic import AsyncAnthropic
+                client = AsyncAnthropic()
+                response = await client.messages.create(
+                    model="claude-3-5-sonnet-20241022",
+                    messages=[{"role": "user", "content": prompt}],
+                    max_tokens=2000
+                )
+                if response.content:
+                    return {"output": response.content[0].text, "success": True}
+            except Exception as e:
+                logger.error(f"Anthropic API error: {e}")
+        
+        return {"output": "No API keys configured. Set OPENAI_API_KEY or ANTHROPIC_API_KEY", "success": False}
 
     async def _validate_improvement(self, original: Dict, improved: Dict) -> bool:
         """Validate that an improvement doesn't degrade quality."""

{hanzo-0.3.13.dist-info → hanzo-0.3.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hanzo
-Version: 0.3.13
+Version: 0.3.15
 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.13.dist-info → hanzo-0.3.15.dist-info}/RECORD

@@ -1,7 +1,7 @@
 hanzo/__init__.py,sha256=f6N_RcJZ0F9ADrROlvPi1OrgwjF8cWQm34cml8hb1zk,169
 hanzo/__main__.py,sha256=F3Vz0Ty3bdAj_8oxyETMIqxlmNRnJOAFB1XPxbyfouI,105
-hanzo/cli.py,sha256=6Vf58xw1YNBkBz4IfZ4tpmFjKwvauIc5MM2mZQI6Q7w,18586
-hanzo/dev.py,sha256=cr4iwSbCyY5XohyFzC_gzp1YeaVgsgwlE6fNj8Lmm3s,72756
+hanzo/cli.py,sha256=JG1bBiCnc1lCnsl_lEJqXKp7iDj1KUn3s4hEu5pZkNI,18586
+hanzo/dev.py,sha256=akZqLo2Ox9HSyi-NOasmfb06-qTxdz7pDlP7Cc9-UxQ,97324
 hanzo/mcp_server.py,sha256=XVygFNn-9CVdu8c95sP7fQjIRtA8K7nsGpgQNe44BRg,460
 hanzo/orchestrator_config.py,sha256=JV7DS8aVZwBJ9XzgkQronFwV_A50QyXG3MH_pKwmCB8,11006
 hanzo/repl.py,sha256=sW1quuqGkJ_AqgjN2vLNdtWgKDlXIkXiO9Bo1QQI0G4,1089
@@ -24,7 +24,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.13.dist-info/METADATA,sha256=rPz5I2FkTR0vWTi500As8gKfwWBYbgNk4uOSUwvPio8,4279
-hanzo-0.3.13.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hanzo-0.3.13.dist-info/entry_points.txt,sha256=pQLPMdqOXU_2BfTcMDhkqTCDNk_H6ApvYuSaWcuQOOw,171
-hanzo-0.3.13.dist-info/RECORD,,
+hanzo-0.3.15.dist-info/METADATA,sha256=Fua1HkddM33hyQNQBUKbsfjdPDsURkJJPLPeuUMrTwM,4279
+hanzo-0.3.15.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hanzo-0.3.15.dist-info/entry_points.txt,sha256=pQLPMdqOXU_2BfTcMDhkqTCDNk_H6ApvYuSaWcuQOOw,171
+hanzo-0.3.15.dist-info/RECORD,,