hanzo 0.3.6__py3-none-any.whl → 0.3.7__py3-none-any.whl

hanzo/commands/auth.py

@@ -1,15 +1,12 @@
 """Authentication commands."""
 
-import asyncio
 import os
 from pathlib import Path
-from typing import Optional
 
 import click
-import httpx
 from rich.prompt import Prompt
 
-from ..utils.output import console, handle_errors
+from ..utils.output import console
 
 
 @click.group(name="auth")
@@ -32,9 +29,9 @@ async def login(ctx, email: str, password: str, api_key: str, sso: bool):
         console.print("[red]Error:[/red] hanzoai not installed")
         console.print("Install with: pip install hanzo")
         return
-    
+
     auth = HanzoAuth()
-    
+
     try:
         if api_key:
             # Direct API key authentication
@@ -51,33 +48,33 @@ async def login(ctx, email: str, password: str, api_key: str, sso: bool):
                 email = Prompt.ask("Email")
             if not password:
                 password = Prompt.ask("Password", password=True)
-            
+
             console.print("Authenticating...")
             result = await auth.login(email, password)
-        
+
         # Save credentials
         config_dir = Path.home() / ".hanzo"
         config_dir.mkdir(exist_ok=True)
-        
+
         config_file = config_dir / "auth.json"
         await auth.save_credentials(config_file)
-        
+
         # Also set environment variable if API key is available
         if api_key or result.get("api_key"):
             key = api_key or result.get("api_key")
             console.print(f"\n[dim]To use in environment:[/dim]")
             console.print(f"export HANZO_API_KEY={key}")
-        
+
         console.print(f"[green]✓[/green] Logged in as {result.get('email', 'user')}")
-        
+
         # Check organization
         if org := result.get("organization"):
             console.print(f"  Organization: {org}")
-        
+
         # Check permissions
         if permissions := result.get("permissions"):
             console.print(f"  Permissions: {', '.join(permissions)}")
-            
+
     except Exception as e:
         console.print(f"[red]Login failed: {e}[/red]")
 
@@ -91,19 +88,19 @@ async def logout(ctx):
     except ImportError:
         console.print("[red]Error:[/red] hanzoai not installed")
         return
-    
+
     auth = HanzoAuth()
-    
+
     try:
         await auth.logout()
-        
+
         # Remove saved credentials
         config_file = Path.home() / ".hanzo" / "auth.json"
         if config_file.exists():
             config_file.unlink()
-        
+
         console.print("[green]✓[/green] Logged out successfully")
-        
+
     except Exception as e:
         console.print(f"[red]Logout failed: {e}[/red]")
 
@@ -116,38 +113,41 @@ async def status(ctx):
     if api_key := os.environ.get("HANZO_API_KEY"):
         console.print("[green]✓[/green] HANZO_API_KEY environment variable set")
         console.print(f"  Key: {api_key[:8]}...{api_key[-4:]}")
-    
+
     # Check saved credentials
     config_file = Path.home() / ".hanzo" / "auth.json"
     if config_file.exists():
         try:
             from hanzoai.auth import HanzoAuth
+
             auth = HanzoAuth()
             creds = await auth.load_credentials(config_file)
-            
+
             console.print("[green]✓[/green] Saved credentials found")
             if email := creds.get("email"):
                 console.print(f"  Email: {email}")
             if org := creds.get("organization"):
                 console.print(f"  Organization: {org}")
-            
+
             # Verify credentials are still valid
             with console.status("Verifying credentials..."):
                 try:
                     user_info = await auth.get_user_info()
                     console.print("[green]✓[/green] Credentials are valid")
-                    
+
                     # Show usage stats if available
                     if usage := user_info.get("usage"):
                         console.print("\n[cyan]Usage:[/cyan]")
                         console.print(f"  API calls: {usage.get('api_calls', 0)}")
                         console.print(f"  Tokens: {usage.get('tokens', 0)}")
-                        if quota := usage.get('quota'):
-                            console.print(f"  Quota: {usage.get('tokens', 0)} / {quota}")
+                        if quota := usage.get("quota"):
+                            console.print(
+                                f"  Quota: {usage.get('tokens', 0)} / {quota}"
+                            )
                 except:
                     console.print("[yellow]![/yellow] Credentials may be expired")
                     console.print("Run 'hanzo auth login' to refresh")
-                    
+
         except Exception as e:
             console.print(f"[red]Error reading credentials: {e}[/red]")
     else:
@@ -157,7 +157,9 @@ async def status(ctx):
 
 @auth_group.command()
 @click.option("--name", "-n", required=True, help="API key name")
-@click.option("--permissions", "-p", multiple=True, help="Permissions (e.g., read, write, admin)")
+@click.option(
+    "--permissions", "-p", multiple=True, help="Permissions (e.g., read, write, admin)"
+)
 @click.option("--expires", "-e", help="Expiration (e.g., 30d, 1y, never)")
 @click.pass_context
 async def create_key(ctx, name: str, permissions: tuple, expires: str):
@@ -167,30 +169,32 @@ async def create_key(ctx, name: str, permissions: tuple, expires: str):
     except ImportError:
         console.print("[red]Error:[/red] hanzoai not installed")
         return
-    
+
     auth = HanzoAuth()
-    
+
     # Ensure authenticated
     if not await auth.is_authenticated():
         console.print("[red]Error:[/red] Not authenticated")
         console.print("Run 'hanzo auth login' first")
         return
-    
+
     with console.status(f"Creating API key '{name}'..."):
         try:
             result = await auth.create_api_key(
                 name=name,
                 permissions=list(permissions) if permissions else None,
-                expires=expires
+                expires=expires,
             )
-            
+
             key = result.get("key")
             console.print(f"[green]✓[/green] Created API key: {name}")
-            console.print(f"\n[yellow]Save this key - it won't be shown again:[/yellow]")
+            console.print(
+                f"\n[yellow]Save this key - it won't be shown again:[/yellow]"
+            )
             console.print(f"{key}")
             console.print(f"\nTo use:")
             console.print(f"export HANZO_API_KEY={key}")
-            
+
         except Exception as e:
             console.print(f"[red]Failed to create key: {e}[/red]")
 
@@ -204,43 +208,43 @@ async def list_keys(ctx):
     except ImportError:
         console.print("[red]Error:[/red] hanzoai not installed")
         return
-    
+
     auth = HanzoAuth()
-    
+
     # Ensure authenticated
     if not await auth.is_authenticated():
         console.print("[red]Error:[/red] Not authenticated")
         console.print("Run 'hanzo auth login' first")
         return
-    
+
     with console.status("Loading API keys..."):
         try:
             keys = await auth.list_api_keys()
-            
+
             if keys:
                 from rich.table import Table
-                
+
                 table = Table(title="API Keys")
                 table.add_column("Name", style="cyan")
                 table.add_column("Created", style="green")
                 table.add_column("Last Used", style="yellow")
                 table.add_column("Permissions", style="blue")
                 table.add_column("Status", style="magenta")
-                
+
                 for key in keys:
                     table.add_row(
                         key.get("name", "unknown"),
                         key.get("created_at", "unknown"),
                         key.get("last_used", "never"),
                         ", ".join(key.get("permissions", [])),
-                        key.get("status", "active")
+                        key.get("status", "active"),
                     )
-                
+
                 console.print(table)
             else:
                 console.print("[yellow]No API keys found[/yellow]")
                 console.print("Create one with: hanzo auth create-key")
-                
+
         except Exception as e:
             console.print(f"[red]Failed to list keys: {e}[/red]")
 
@@ -255,15 +259,15 @@ async def revoke_key(ctx, name: str):
     except ImportError:
         console.print("[red]Error:[/red] hanzoai not installed")
         return
-    
+
     auth = HanzoAuth()
-    
+
     # Ensure authenticated
     if not await auth.is_authenticated():
         console.print("[red]Error:[/red] Not authenticated")
         console.print("Run 'hanzo auth login' first")
         return
-    
+
     if click.confirm(f"Revoke API key '{name}'?"):
         with console.status(f"Revoking key '{name}'..."):
             try:
@@ -282,43 +286,43 @@ async def whoami(ctx):
     except ImportError:
         console.print("[red]Error:[/red] hanzoai not installed")
         return
-    
+
     auth = HanzoAuth()
-    
+
     # Check if authenticated
     if not await auth.is_authenticated():
         console.print("[yellow]Not authenticated[/yellow]")
-        
+
         # Check if API key is set
         if os.environ.get("HANZO_API_KEY"):
             console.print("HANZO_API_KEY is set but may be invalid")
         else:
             console.print("Run 'hanzo auth login' to authenticate")
         return
-    
+
     with console.status("Loading user information..."):
         try:
             user = await auth.get_user_info()
-            
+
             console.print(f"[cyan]User Information:[/cyan]")
             console.print(f"  ID: {user.get('id', 'unknown')}")
             console.print(f"  Email: {user.get('email', 'unknown')}")
             console.print(f"  Name: {user.get('name', 'unknown')}")
-            
-            if org := user.get('organization'):
+
+            if org := user.get("organization"):
                 console.print(f"\n[cyan]Organization:[/cyan]")
                 console.print(f"  Name: {org.get('name', 'unknown')}")
                 console.print(f"  Role: {org.get('role', 'member')}")
-            
-            if teams := user.get('teams'):
+
+            if teams := user.get("teams"):
                 console.print(f"\n[cyan]Teams:[/cyan]")
                 for team in teams:
                     console.print(f"  • {team}")
-            
-            if perms := user.get('permissions'):
+
+            if perms := user.get("permissions"):
                 console.print(f"\n[cyan]Permissions:[/cyan]")
                 for perm in sorted(perms):
                     console.print(f"  • {perm}")
-                    
+
         except Exception as e:
-            console.print(f"[red]Error: {e}[/red]")
+            console.print(f"[red]Error: {e}[/red]")

hanzo/commands/chat.py

@@ -7,7 +7,7 @@ import click
 import httpx
 from rich.markdown import Markdown
 
-from ..utils.output import console, handle_errors
+from ..utils.output import console
 
 
 @click.command(name="chat")
@@ -15,19 +15,31 @@ from ..utils.output import console, handle_errors
 @click.option("--local/--cloud", default=True, help="Use local or cloud model")
 @click.option("--once", is_flag=True, help="Single question mode")
 @click.option("--system", "-s", help="System prompt")
-@click.option("--repl", is_flag=True, help="Start full REPL interface (like Claude Code)")
+@click.option(
+    "--repl", is_flag=True, help="Start full REPL interface (like Claude Code)"
+)
 @click.option("--ipython", is_flag=True, help="Use IPython REPL interface")
 @click.option("--tui", is_flag=True, help="Use beautiful TUI interface")
 @click.argument("prompt", nargs=-1)
 @click.pass_context
-def chat_command(ctx, model: str, local: bool, once: bool, system: Optional[str], repl: bool, ipython: bool, tui: bool, prompt: tuple):
+def chat_command(
+    ctx,
+    model: str,
+    local: bool,
+    once: bool,
+    system: Optional[str],
+    repl: bool,
+    ipython: bool,
+    tui: bool,
+    prompt: tuple,
+):
     """Interactive AI chat."""
     # Check if REPL mode requested
     if repl or ipython or tui:
         try:
-            import sys
             import os
-            
+            import sys
+
             # Set up environment
             if model:
                 os.environ["HANZO_DEFAULT_MODEL"] = model
@@ -35,15 +47,18 @@ def chat_command(ctx, model: str, local: bool, once: bool, system: Optional[str]
                 os.environ["HANZO_USE_LOCAL"] = "true"
             if system:
                 os.environ["HANZO_SYSTEM_PROMPT"] = system
-            
+
             if ipython:
                 from hanzo_repl.ipython_repl import main
+
                 sys.exit(main())
             elif tui:
                 from hanzo_repl.textual_repl import main
+
                 sys.exit(main())
             else:
                 from hanzo_repl.cli import main
+
                 sys.exit(main())
         except ImportError:
             console.print("[red]Error:[/red] hanzo-repl not installed")
@@ -51,9 +66,9 @@ def chat_command(ctx, model: str, local: bool, once: bool, system: Optional[str]
             console.print("\nAlternatively:")
             console.print("  pip install hanzo-repl")
             return
-    
+
     prompt_text = " ".join(prompt) if prompt else None
-    
+
     if once or prompt_text:
         # Single question mode
         asyncio.run(ask_once(ctx, prompt_text or "Hello", model, local, system))
@@ -62,35 +77,35 @@ def chat_command(ctx, model: str, local: bool, once: bool, system: Optional[str]
         asyncio.run(interactive_chat(ctx, model, local, system))
 
 
-async def ask_once(ctx, prompt: str, model: str, local: bool, system: Optional[str] = None):
+async def ask_once(
+    ctx, prompt: str, model: str, local: bool, system: Optional[str] = None
+):
     """Ask a single question."""
     messages = []
     if system:
         messages.append({"role": "system", "content": system})
     messages.append({"role": "user", "content": prompt})
-    
+
     try:
         if local:
             # Use local cluster
             base_url = "http://localhost:8000"
-            
+
             # Check if cluster is running
             try:
                 async with httpx.AsyncClient() as client:
                     await client.get(f"{base_url}/health")
             except httpx.ConnectError:
-                console.print("[yellow]Local cluster not running. Start with: hanzo serve[/yellow]")
+                console.print(
+                    "[yellow]Local cluster not running. Start with: hanzo serve[/yellow]"
+                )
                 return
-            
+
             # Make request to local cluster
             async with httpx.AsyncClient() as client:
                 response = await client.post(
                     f"{base_url}/v1/chat/completions",
-                    json={
-                        "model": model,
-                        "messages": messages,
-                        "stream": False
-                    }
+                    json={"model": model, "messages": messages, "stream": False},
                 )
                 response.raise_for_status()
                 result = response.json()
@@ -99,22 +114,23 @@ async def ask_once(ctx, prompt: str, model: str, local: bool, system: Optional[s
             # Use cloud API
             try:
                 from hanzoai import completion
+
                 result = completion(
                     model=f"anthropic/{model}" if "claude" in model else model,
-                    messages=messages
+                    messages=messages,
                 )
                 content = result.choices[0].message.content
             except ImportError:
                 console.print("[red]Error:[/red] hanzoai not installed")
                 console.print("Install with: pip install hanzo[all]")
                 return
-        
+
         # Display response
         if ctx.obj.get("json"):
             console.print_json(data={"response": content})
         else:
             console.print(Markdown(content))
-            
+
     except Exception as e:
         console.print(f"[red]Error: {e}[/red]")
 
@@ -123,27 +139,29 @@ async def interactive_chat(ctx, model: str, local: bool, system: Optional[str]):
     """Run interactive chat session."""
     from prompt_toolkit import PromptSession
     from prompt_toolkit.history import FileHistory
-    
-    console.print(f"[cyan]Chat session started[/cyan] (model: {model}, mode: {'local' if local else 'cloud'})")
+
+    console.print(
+        f"[cyan]Chat session started[/cyan] (model: {model}, mode: {'local' if local else 'cloud'})"
+    )
     console.print("Type 'exit' or Ctrl+D to quit\n")
-    
+
     session = PromptSession(history=FileHistory(".hanzo_chat_history"))
     messages = []
-    
+
     if system:
         messages.append({"role": "system", "content": system})
-    
+
     while True:
         try:
             # Get user input
             user_input = await session.prompt_async("You: ")
-            
+
             if user_input.lower() in ["exit", "quit"]:
                 break
-            
+
             # Add to messages
             messages.append({"role": "user", "content": user_input})
-            
+
             # Get response
             console.print("AI: ", end="")
             with console.status(""):
@@ -155,8 +173,8 @@ async def interactive_chat(ctx, model: str, local: bool, system: Optional[str]):
                             json={
                                 "model": model,
                                 "messages": messages,
-                                "stream": False
-                            }
+                                "stream": False,
+                            },
                         )
                         response.raise_for_status()
                         result = response.json()
@@ -164,20 +182,21 @@ async def interactive_chat(ctx, model: str, local: bool, system: Optional[str]):
                 else:
                     # Use cloud API
                     from hanzoai import completion
+
                     result = completion(
                         model=f"anthropic/{model}" if "claude" in model else model,
-                        messages=messages
+                        messages=messages,
                     )
                     content = result.choices[0].message.content
-            
+
             # Display and save response
             console.print(Markdown(content))
             messages.append({"role": "assistant", "content": content})
             console.print()
-            
+
         except KeyboardInterrupt:
             continue
         except EOFError:
             break
         except Exception as e:
-            console.print(f"\n[red]Error: {e}[/red]\n")
+            console.print(f"\n[red]Error: {e}[/red]\n")