aniate 1.0.0__py3-none-any.whl

aniate/__init__.py

@@ -0,0 +1,10 @@
+"""
+Aniate - Terminal Intelligence Layer
+"""
+
+__version__ = "1.0.0"
+__author__ = "Kabir Murjani"
+
+from .cli import app
+
+__all__ = ["app"]

aniate/auth.py

@@ -0,0 +1,96 @@
+import os
+import json
+import re
+import getpass
+from rich.console import Console
+from rich.prompt import Prompt
+from supabase import create_client, Client
+from aniate.config import SUPABASE_URL, SUPABASE_KEY, SESSION_FILE, CONFIG_DIR
+
+console = Console()
+supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
+
+def get_session():
+    """Load session from file."""
+    if not SESSION_FILE.exists():
+        return None
+    try:
+        with open(SESSION_FILE, 'r') as f:
+            return json.load(f)
+    except:
+        return None
+
+def save_session(data):
+    """Save session to file."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    with open(SESSION_FILE, 'w') as f:
+        json.dump(data, f)
+
+def signup():
+    """Create a new account."""
+    session = get_session()
+    if session:
+        console.print("[yellow]Already logged in. Run: ant logout[/yellow]")
+        return
+    
+    console.print("\n[bold white]ANIATE[/bold white] [dim]Create Account[/dim]\n")
+    email = Prompt.ask("[white]Email[/white]")
+    while True:
+        password = getpass.getpass("Password (8+ chars, 1 number): ")
+        if len(password) < 8 or not re.search(r"\d", password):
+            console.print("[red]Password too weak. Try again.[/red]")
+            continue
+        break
+    with console.status("[dim]Creating account...[/dim]", spinner="dots"):
+        try:
+            res = supabase.auth.sign_up({"email": email, "password": password})
+            if res.user:
+                console.print(f"\n[green]Account created.[/green] {email}")
+                console.print("[dim]Check your email to verify.\n[/dim]")
+            else:
+                console.print("[yellow]Account created. Check email for verification.[/yellow]")
+        except Exception as e:
+            console.print(f"[red]Failed:[/red] {str(e)}")
+
+def login():
+    """Login via Email/Password."""
+    session = get_session()
+    if session:
+        console.print(f"[dim]Already authenticated as[/dim] {session['email']}")
+        return
+    
+    console.print("\n[bold white]ANIATE[/bold white] [dim]Login[/dim]\n")
+    email = Prompt.ask("[white]Email[/white]")
+    password = getpass.getpass("Password: ")
+    
+    with console.status("[dim]Authenticating...[/dim]", spinner="dots"):
+        try:
+            res = supabase.auth.sign_in_with_password({"email": email, "password": password})
+            save_session({
+                "access_token": res.session.access_token,
+                "refresh_token": res.session.refresh_token,
+                "user_id": res.user.id,
+                "email": res.user.email
+            })
+            console.print(f"\n[green]Authenticated.[/green] {res.user.email}\n")
+        except Exception as e:
+            console.print(f"[red]Authentication failed.[/red] Check credentials.")
+
+def logout():
+    """Logout and clear session."""
+    if not SESSION_FILE.exists():
+        console.print("[dim]No active session.[/dim]")
+        return
+    
+    os.remove(SESSION_FILE)
+    console.print("[dim]Session cleared.[/dim]")
+
+def whoami():
+    """Show current logged in user."""
+    session = get_session()
+    if not session:
+        console.print("[dim]No active session. Run: ant login[/dim]")
+        return
+    
+    console.print(f"\n[white]{session['email']}[/white]")
+    console.print(f"[dim]{session['user_id']}[/dim]\n")

aniate/brew.py

@@ -0,0 +1,73 @@
+"""
+Brew System - Create and manage custom commands
+"""
+from rich.console import Console
+from pathlib import Path
+
+console = Console()
+
+def brew_cmd(name: str):
+    """Brew a custom command template."""
+    console.print(f"\n[bold cyan]🍺 Brewing Command: {name}[/bold cyan]\n")
+    
+    commands_dir = Path(__file__).parent / "commands"
+    cmd_file = commands_dir / f"{name}.py"
+    
+    if cmd_file.exists():
+        console.print(f"[yellow]Command '{name}' already exists.[/yellow]")
+        return
+    
+    # Template for custom commands
+    template = f'''"""
+{name.title()} Command - Custom brewed command
+"""
+import requests
+from rich.console import Console
+import sys
+import os
+# Package imports
+
+from aniate.config import SERVER_URL
+
+console = Console()
+
+def {name}_execute(arg: str):
+    """Execute the {name} command."""
+    console.print(f"[cyan]{name.title()} command executing:[/cyan] {{arg}}")
+    
+    # TODO: Implement your command logic here
+    # You can use the LLM via SERVER_URL
+    # You can access other APIs
+    # You can process files, data, etc.
+    
+    console.print(f"[green]✓ {name.title()} completed[/green]")
+'''
+    
+    try:
+        cmd_file.write_text(template)
+        console.print(f"[green]✓ Command '{name}' brewed successfully[/green]")
+        console.print(f"[dim]Edit: {cmd_file}[/dim]")
+        console.print(f"[dim]Use: ant {name} \"your input\"[/dim]\n")
+    except Exception as e:
+        console.print(f"[red]Brew failed:[/red] {e}")
+
+def delete_cmd(name: str):
+    """Delete a custom brewed command."""
+    commands_dir = Path(__file__).parent / "commands"
+    cmd_file = commands_dir / f"{name}.py"
+    
+    if not cmd_file.exists():
+        console.print(f"[yellow]Command '{name}' not found.[/yellow]")
+        return
+    
+    # Prevent deleting core commands
+    core_commands = ['chat', 'net']
+    if name in core_commands:
+        console.print(f"[red]Cannot delete core command '{name}'[/red]")
+        return
+    
+    try:
+        cmd_file.unlink()
+        console.print(f"[bold red]✓ Command '{name}' deleted[/bold red]")
+    except Exception as e:
+        console.print(f"[red]Delete failed:[/red] {e}")

aniate/brews/__init__.py

@@ -0,0 +1,12 @@
+"""
+Global Brews - Cloud-enabled commands accessible from any terminal
+"""
+from .document_storage import save_file, fetch_file, list_files
+from .secrets import add_secret, get_secret, list_secrets, delete_secret
+from .maker import brew_make
+
+__all__ = [
+    'save_file', 'fetch_file', 'list_files',
+    'add_secret', 'get_secret', 'list_secrets', 'delete_secret',
+    'brew_make'
+]

aniate/brews/document_storage/__init__.py

@@ -0,0 +1,6 @@
+"""Document Storage - Cloud file management"""
+from .save import save_file
+from .fetch import fetch_file
+from .files import list_files
+
+__all__ = ['save_file', 'fetch_file', 'list_files']

aniate/brews/document_storage/fetch.py

@@ -0,0 +1,143 @@
+"""
+Fetch Command - Download files from cloud storage
+"""
+import os
+from pathlib import Path
+from typing import Optional
+import typer
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn
+from rich.prompt import Prompt
+from rich.table import Table
+from supabase import create_client
+
+import sys
+# Package imports
+
+from aniate.config import SUPABASE_URL, SUPABASE_KEY
+from aniate.auth import get_session
+
+console = Console()
+
+def fetch_file(filename: Optional[str] = typer.Argument(None, help="File to download")):
+    """Download a file from cloud storage."""
+    session = get_session()
+    if not session:
+        console.print("[red]Login required. Run: ant login[/red]")
+        return
+    
+    # Create Supabase client
+    supabase = create_client(SUPABASE_URL, SUPABASE_KEY)
+    supabase.auth.set_session(session['access_token'], session.get('refresh_token', ''))
+    
+    user_id = session['user_id']
+    
+    # If no filename provided, show interactive list
+    if not filename:
+        filename = _select_file_interactive(supabase, user_id)
+        if not filename:
+            return
+    
+    # Get file metadata
+    try:
+        result = supabase.table("user_files").select("*").eq("user_id", user_id).eq("filename", filename).execute()
+        
+        if not result.data:
+            console.print(f"[red]File not found in cloud:[/red] {filename}")
+            return
+        
+        file_meta = result.data[0]
+        storage_path = file_meta['storage_path']
+        file_size = file_meta['file_size']
+        
+        # Always save to Desktop
+        desktop = Path.home() / "Desktop"
+        dest_path = desktop / filename
+        
+        # Check if file exists locally
+        if dest_path.exists():
+            overwrite = Prompt.ask(f"[yellow]File exists. Overwrite?[/yellow]", choices=["y", "n"], default="n")
+            if overwrite == 'n':
+                console.print("[dim]Download cancelled[/dim]")
+                return
+        
+        # Download file
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[cyan]{task.description}"),
+            BarColumn(),
+            TaskProgressColumn(),
+            console=console
+        ) as progress:
+            task = progress.add_task(f"Downloading {filename}...", total=100)
+            
+            # Download from Supabase Storage
+            file_data = supabase.storage.from_('user-files').download(storage_path)
+            
+            progress.update(task, advance=70)
+            
+            # Write to local file
+            with open(dest_path, 'wb') as f:
+                f.write(file_data)
+            
+            progress.update(task, advance=30)
+        
+        # Success message
+        size_str = _format_size(file_size)
+        console.print(f"[bold green]✓ Downloaded {filename}[/bold green] [dim]({size_str})[/dim]")
+        console.print(f"[dim]Saved to: {dest_path}[/dim]")
+        
+    except Exception as e:
+        console.print(f"[red]Download failed:[/red] {e}")
+
+def _select_file_interactive(supabase, user_id):
+    """Show interactive file selector."""
+    try:
+        result = supabase.table("user_files").select("*").eq("user_id", user_id).order("uploaded_at", desc=True).execute()
+        
+        if not result.data:
+            console.print("[dim]No files in cloud storage[/dim]")
+            return None
+        
+        # Show table
+        table = Table(title="Cloud Files")
+        table.add_column("#", style="cyan")
+        table.add_column("Filename", style="white")
+        table.add_column("Size", style="dim")
+        table.add_column("Date", style="dim")
+        
+        for idx, file in enumerate(result.data, 1):
+            size = _format_size(file['file_size'])
+            date = file['uploaded_at'][:10]  # Just the date
+            table.add_row(str(idx), file['filename'], size, date)
+        
+        console.print(table)
+        
+        # Prompt for selection
+        choice = Prompt.ask("\n[cyan]Select file number (or 'q' to quit)[/cyan]")
+        
+        if choice.lower() == 'q':
+            return None
+        
+        try:
+            idx = int(choice) - 1
+            if 0 <= idx < len(result.data):
+                return result.data[idx]['filename']
+            else:
+                console.print("[red]Invalid selection[/red]")
+                return None
+        except ValueError:
+            console.print("[red]Invalid input[/red]")
+            return None
+            
+    except Exception as e:
+        console.print(f"[red]Error listing files:[/red] {e}")
+        return None
+
+def _format_size(bytes_size):
+    """Format bytes to human-readable size."""
+    for unit in ['B', 'KB', 'MB', 'GB']:
+        if bytes_size < 1024.0:
+            return f"{bytes_size:.1f} {unit}"
+        bytes_size /= 1024.0
+    return f"{bytes_size:.1f} TB"

aniate/brews/document_storage/files.py

@@ -0,0 +1,65 @@
+"""
+Files Command - List all files in cloud storage
+"""
+import os
+from rich.console import Console
+from rich.table import Table
+from supabase import create_client
+
+import sys
+# Package imports
+
+from aniate.config import SUPABASE_URL, SUPABASE_KEY
+from aniate.auth import get_session
+
+console = Console()
+
+def list_files():
+    """List all files in cloud storage."""
+    session = get_session()
+    if not session:
+        console.print("[red]Login required. Run: ant login[/red]")
+        return
+    
+    # Create Supabase client
+    supabase = create_client(SUPABASE_URL, SUPABASE_KEY)
+    supabase.auth.set_session(session['access_token'], session.get('refresh_token', ''))
+    
+    user_id = session['user_id']
+    
+    try:
+        result = supabase.table("user_files").select("*").eq("user_id", user_id).order("uploaded_at", desc=True).execute()
+        
+        if not result.data:
+            console.print("[dim]No files in cloud storage[/dim]")
+            return
+        
+        # Calculate totals
+        total_size = sum(f['file_size'] for f in result.data)
+        total_count = len(result.data)
+        
+        # Create table
+        table = Table(title=f"Cloud Files ({total_count} files, {_format_size(total_size)} total)")
+        table.add_column("Filename", style="cyan")
+        table.add_column("Size", style="white")
+        table.add_column("Type", style="dim")
+        table.add_column("Uploaded", style="dim")
+        
+        for file in result.data:
+            size = _format_size(file['file_size'])
+            mime = file['mime_type'].split('/')[-1] if file['mime_type'] else 'unknown'
+            date = file['uploaded_at'][:10]  # Just the date
+            table.add_row(file['filename'], size, mime, date)
+        
+        console.print(table)
+        
+    except Exception as e:
+        console.print(f"[red]Error listing files:[/red] {e}")
+
+def _format_size(bytes_size):
+    """Format bytes to human-readable size."""
+    for unit in ['B', 'KB', 'MB', 'GB']:
+        if bytes_size < 1024.0:
+            return f"{bytes_size:.1f} {unit}"
+        bytes_size /= 1024.0
+    return f"{bytes_size:.1f} TB"

aniate/brews/document_storage/save.py

@@ -0,0 +1,112 @@
+"""
+Save Command - Upload files to cloud storage
+"""
+import os
+from pathlib import Path
+from typing import Optional
+import typer
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn
+from supabase import create_client
+import mimetypes
+
+import sys
+# Package imports
+
+from aniate.config import SUPABASE_URL, SUPABASE_KEY
+from aniate.auth import get_session
+
+console = Console()
+
+def save_file(filepath: str = typer.Argument(..., help="File to upload"), cloud_name: Optional[str] = typer.Argument(None, help="Custom name in cloud")):
+    """Upload a file to cloud storage."""
+    session = get_session()
+    if not session:
+        console.print("[red]Login required. Run: ant login[/red]")
+        return
+    
+    # Resolve file path
+    file_path = Path(filepath).expanduser().resolve()
+    
+    if not file_path.exists():
+        console.print(f"[red]File not found:[/red] {filepath}")
+        return
+    
+    if not file_path.is_file():
+        console.print(f"[red]Not a file:[/red] {filepath}")
+        return
+    
+    # Get file info
+    file_size = file_path.stat().st_size
+    filename = cloud_name if cloud_name else file_path.name
+    mime_type = mimetypes.guess_type(str(file_path))[0] or 'application/octet-stream'
+    
+    # Size warning for large files
+    if file_size > 10 * 1024 * 1024:  # 10MB
+        size_mb = file_size / (1024 * 1024)
+        console.print(f"[yellow]Warning: Large file ({size_mb:.1f} MB)[/yellow]")
+        confirm = console.input("Continue? (y/n): ")
+        if confirm.lower() != 'y':
+            console.print("[dim]Upload cancelled[/dim]")
+            return
+    
+    # Create Supabase client
+    supabase = create_client(SUPABASE_URL, SUPABASE_KEY)
+    supabase.auth.set_session(session['access_token'], session.get('refresh_token', ''))
+    
+    user_id = session['user_id']
+    storage_path = f"{user_id}/{filename}"
+    
+    try:
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[cyan]{task.description}"),
+            BarColumn(),
+            TaskProgressColumn(),
+            console=console
+        ) as progress:
+            task = progress.add_task(f"Uploading {filename}...", total=100)
+            
+            # Read file
+            with open(file_path, 'rb') as f:
+                file_data = f.read()
+            
+            progress.update(task, advance=30)
+            
+            # Upload to Supabase Storage
+            supabase.storage.from_('user-files').upload(
+                storage_path,
+                file_data,
+                file_options={"content-type": mime_type, "upsert": "true"}
+            )
+            
+            progress.update(task, advance=40)
+            
+            # Save metadata to database
+            metadata = {
+                "user_id": user_id,
+                "filename": filename,
+                "storage_path": storage_path,
+                "file_size": file_size,
+                "mime_type": mime_type
+            }
+            
+            # Upsert (insert or update)
+            supabase.table("user_files").upsert(metadata, on_conflict="user_id,filename").execute()
+            
+            progress.update(task, advance=30)
+        
+        # Success message
+        size_str = _format_size(file_size)
+        console.print(f"[bold green]✓ Uploaded {filename}[/bold green] [dim]({size_str})[/dim]")
+        
+    except Exception as e:
+        console.print(f"[red]Upload failed:[/red] {e}")
+
+def _format_size(bytes_size):
+    """Format bytes to human-readable size."""
+    for unit in ['B', 'KB', 'MB', 'GB']:
+        if bytes_size < 1024.0:
+            return f"{bytes_size:.1f} {unit}"
+        bytes_size /= 1024.0
+    return f"{bytes_size:.1f} TB"