router-maestro 0.1.2__py3-none-any.whl

router_maestro/cli/model.py

@@ -0,0 +1,288 @@
+"""Model management commands."""
+
+import asyncio
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from router_maestro.cli.client import ServerNotRunningError, get_admin_client
+
+app = typer.Typer(no_args_is_help=True)
+console = Console()
+
+
+def _handle_server_error(e: Exception) -> None:
+    """Handle server connection errors."""
+    if isinstance(e, ServerNotRunningError):
+        console.print(f"[red]{e}[/red]")
+    else:
+        console.print(f"[red]Error: {e}[/red]")
+    raise typer.Exit(1)
+
+
+@app.command(name="list")
+def list_models() -> None:
+    """List all available models with their priorities."""
+    client = get_admin_client()
+
+    # Get models and priorities
+    try:
+        models = asyncio.run(client.list_models())
+        priorities_data = asyncio.run(client.get_priorities())
+        priorities_list = priorities_data.get("priorities", [])
+    except Exception as e:
+        _handle_server_error(e)
+        return
+
+    if not models:
+        console.print("[dim]No models available.[/dim]")
+        console.print("[dim]Make sure you have authenticated with at least one provider.[/dim]")
+        return
+
+    table = Table(title="Available Models")
+    table.add_column("Priority", style="cyan", justify="right")
+    table.add_column("Model Key", style="green")
+    table.add_column("Display Name", style="white")
+    table.add_column("Provider", style="magenta")
+
+    for model in models:
+        model_key = f"{model['provider']}/{model['id']}"
+        # Check if this model is in the priority list
+        try:
+            priority_idx = priorities_list.index(model_key)
+            priority_str = str(priority_idx + 1)
+        except ValueError:
+            priority_str = "-"
+
+        table.add_row(
+            priority_str,
+            model_key,
+            model["name"],
+            model["provider"],
+        )
+
+    console.print(table)
+
+
+@app.command(name="refresh")
+def refresh_models() -> None:
+    """Refresh the models cache from all providers."""
+    client = get_admin_client()
+
+    console.print("[dim]Refreshing models cache...[/dim]")
+
+    try:
+        success = asyncio.run(client.refresh_models())
+        if success:
+            console.print("[green]Models cache refreshed successfully[/green]")
+        else:
+            console.print("[red]Failed to refresh models cache[/red]")
+            raise typer.Exit(1)
+    except Exception as e:
+        _handle_server_error(e)
+
+
+# Priority subcommand group
+priority_app = typer.Typer(no_args_is_help=True, help="Manage model priorities")
+app.add_typer(priority_app, name="priority")
+
+
+@priority_app.command(name="list")
+def priority_list() -> None:
+    """List current model priorities."""
+    client = get_admin_client()
+
+    try:
+        data = asyncio.run(client.get_priorities())
+        priorities = data.get("priorities", [])
+    except Exception as e:
+        _handle_server_error(e)
+        return
+
+    if not priorities:
+        console.print("[dim]No priorities configured.[/dim]")
+        console.print(
+            "[dim]Use 'router-maestro model priority add <provider/model>' to add priorities.[/dim]"
+        )
+        return
+
+    table = Table(title="Model Priorities")
+    table.add_column("#", style="cyan", justify="right")
+    table.add_column("Model Key", style="green")
+
+    for idx, model_key in enumerate(priorities):
+        table.add_row(str(idx + 1), model_key)
+
+    console.print(table)
+
+
+@priority_app.command(name="add")
+def priority_add(
+    model_key: Annotated[str, typer.Argument(help="Model key in format 'provider/model'")],
+    position: Annotated[
+        int | None,
+        typer.Option("--position", "-p", help="Position in priority list (1-based)"),
+    ] = None,
+) -> None:
+    """Add or move a model in the priority list."""
+    if "/" not in model_key:
+        console.print("[red]Model key must be in format 'provider/model'[/red]")
+        raise typer.Exit(1)
+
+    client = get_admin_client()
+
+    try:
+        # Get current priorities
+        data = asyncio.run(client.get_priorities())
+        priorities = data.get("priorities", [])
+        fallback = data.get("fallback")
+
+        # Remove if already exists
+        if model_key in priorities:
+            priorities.remove(model_key)
+
+        # Insert at position
+        if position is None:
+            priorities.append(model_key)
+        else:
+            pos = position - 1  # Convert 1-based to 0-based
+            priorities.insert(pos, model_key)
+
+        # Save
+        asyncio.run(client.set_priorities(priorities, fallback))
+
+        if position:
+            console.print(f"[green]Added '{model_key}' at position {position}[/green]")
+        else:
+            console.print(f"[green]Added '{model_key}' to end of priority list[/green]")
+
+    except Exception as e:
+        _handle_server_error(e)
+
+
+@priority_app.command(name="remove")
+def priority_remove(
+    model_key: Annotated[str, typer.Argument(help="Model key in format 'provider/model'")],
+) -> None:
+    """Remove a model from the priority list."""
+    if "/" not in model_key:
+        console.print("[red]Model key must be in format 'provider/model'[/red]")
+        raise typer.Exit(1)
+
+    client = get_admin_client()
+
+    try:
+        # Get current priorities
+        data = asyncio.run(client.get_priorities())
+        priorities = data.get("priorities", [])
+        fallback = data.get("fallback")
+
+        if model_key in priorities:
+            priorities.remove(model_key)
+            asyncio.run(client.set_priorities(priorities, fallback))
+            console.print(f"[green]Removed '{model_key}' from priority list[/green]")
+        else:
+            console.print(f"[yellow]'{model_key}' was not in the priority list[/yellow]")
+
+    except Exception as e:
+        _handle_server_error(e)
+
+
+@priority_app.command(name="clear")
+def priority_clear() -> None:
+    """Clear all priorities."""
+    client = get_admin_client()
+
+    try:
+        data = asyncio.run(client.get_priorities())
+        fallback = data.get("fallback")
+        asyncio.run(client.set_priorities([], fallback))
+        console.print("[green]Cleared all priorities[/green]")
+    except Exception as e:
+        _handle_server_error(e)
+
+
+# Fallback subcommand group
+fallback_app = typer.Typer(no_args_is_help=True, help="Manage fallback configuration")
+app.add_typer(fallback_app, name="fallback")
+
+VALID_STRATEGIES = ["priority", "same-model", "none"]
+
+
+@fallback_app.command(name="show")
+def fallback_show() -> None:
+    """Show current fallback configuration."""
+    client = get_admin_client()
+
+    try:
+        data = asyncio.run(client.get_priorities())
+        fallback = data.get("fallback", {})
+    except Exception as e:
+        _handle_server_error(e)
+        return
+
+    strategy = fallback.get("strategy", "priority")
+    max_retries = fallback.get("maxRetries", 2)
+
+    console.print()
+    console.print("[bold]Fallback Configuration[/bold]")
+    console.print(f"  Strategy:    [cyan]{strategy}[/cyan]")
+    console.print(f"  Max Retries: [cyan]{max_retries}[/cyan]")
+    console.print()
+
+
+@fallback_app.command(name="set")
+def fallback_set(
+    strategy: Annotated[
+        str | None,
+        typer.Option("--strategy", "-s", help="Fallback strategy (priority, same-model, none)"),
+    ] = None,
+    max_retries: Annotated[
+        int | None,
+        typer.Option("--max-retries", "-r", help="Maximum number of fallback retries (0-10)"),
+    ] = None,
+) -> None:
+    """Set fallback configuration."""
+    # Validate that at least one option is provided
+    if strategy is None and max_retries is None:
+        console.print("[red]At least one of --strategy or --max-retries must be provided[/red]")
+        raise typer.Exit(1)
+
+    # Validate strategy
+    if strategy is not None and strategy not in VALID_STRATEGIES:
+        console.print(f"[red]Invalid strategy '{strategy}'[/red]")
+        console.print(f"[dim]Valid strategies: {', '.join(VALID_STRATEGIES)}[/dim]")
+        raise typer.Exit(1)
+
+    # Validate max_retries
+    if max_retries is not None and (max_retries < 0 or max_retries > 10):
+        console.print("[red]max-retries must be between 0 and 10[/red]")
+        raise typer.Exit(1)
+
+    client = get_admin_client()
+
+    try:
+        # Get current config
+        data = asyncio.run(client.get_priorities())
+        priorities = data.get("priorities", [])
+        fallback = data.get("fallback", {})
+
+        # Update fallback config
+        if strategy is not None:
+            fallback["strategy"] = strategy
+        if max_retries is not None:
+            fallback["maxRetries"] = max_retries
+
+        # Save
+        asyncio.run(client.set_priorities(priorities, fallback))
+
+        console.print("[green]Fallback configuration updated[/green]")
+
+        # Show updated config
+        console.print(f"  Strategy:    [cyan]{fallback.get('strategy', 'priority')}[/cyan]")
+        console.print(f"  Max Retries: [cyan]{fallback.get('maxRetries', 2)}[/cyan]")
+
+    except Exception as e:
+        _handle_server_error(e)

router_maestro/cli/server.py

@@ -0,0 +1,117 @@
+"""Server management commands."""
+
+import os
+import socket
+
+import typer
+import uvicorn
+from rich.console import Console
+from rich.panel import Panel
+
+from router_maestro.config.server import get_current_context_api_key, get_or_create_api_key
+
+app = typer.Typer(no_args_is_help=True)
+console = Console()
+
+
+def is_port_in_use(port: int, host: str = "127.0.0.1") -> bool:
+    """Check if a port is in use."""
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        return s.connect_ex((host, port)) == 0
+
+
+@app.command()
+def start(
+    port: int = typer.Option(8080, "--port", "-p", help="Port to listen on"),
+    host: str = typer.Option("127.0.0.1", "--host", "-h", help="Host to bind to"),
+    api_key: str | None = typer.Option(None, "--api-key", "-k", help="API key for authentication"),
+    reload: bool = typer.Option(False, "--reload", help="Enable auto-reload (development)"),
+    log_level: str = typer.Option(
+        "INFO",
+        "--log-level",
+        "-l",
+        help="Log level (DEBUG, INFO, WARNING, ERROR)",
+        case_sensitive=False,
+    ),
+) -> None:
+    """Start router-maestro API server."""
+    if is_port_in_use(port, host):
+        console.print(f"[red]Error: Port {port} is already in use[/red]")
+        raise typer.Exit(1)
+
+    # Validate log level
+    valid_levels = ("DEBUG", "INFO", "WARNING", "ERROR")
+    log_level = log_level.upper()
+    if log_level not in valid_levels:
+        console.print(
+            f"[red]Error: Invalid log level '{log_level}'. Valid: {', '.join(valid_levels)}[/red]"
+        )
+        raise typer.Exit(1)
+
+    # Get or create API key
+    key, was_generated = get_or_create_api_key(api_key)
+
+    # Set environment variables for server process to read
+    os.environ["ROUTER_MAESTRO_API_KEY"] = key
+    os.environ["ROUTER_MAESTRO_LOG_LEVEL"] = log_level
+
+    console.print(f"[green]Starting Router-Maestro server on {host}:{port}...[/green]")
+    console.print(f"[dim]API endpoint: http://{host}:{port}/v1[/dim]")
+    console.print(f"[dim]Log level: {log_level}[/dim]")
+
+    if was_generated:
+        console.print(
+            Panel(
+                f"[yellow]API Key (auto-generated):[/yellow]\n[bold]{key}[/bold]",
+                title="Authentication",
+                border_style="yellow",
+            )
+        )
+    else:
+        console.print(f"[dim]API Key: {key[:12]}...{key[-4:]}[/dim]")
+
+    console.print("[dim]Press Ctrl+C to stop[/dim]\n")
+
+    # Map log level to uvicorn format
+    uvicorn_level = log_level.lower()
+
+    uvicorn.run(
+        "router_maestro.server:app",
+        host=host,
+        port=port,
+        reload=reload,
+        log_level=uvicorn_level,
+    )
+
+
+@app.command()
+def status() -> None:
+    """Show current server status (uses current context)."""
+    import asyncio
+
+    from router_maestro.cli.client import get_admin_client, get_current_endpoint
+
+    client = get_admin_client()
+    endpoint = get_current_endpoint()
+
+    console.print(f"[dim]Context endpoint: {endpoint}[/dim]")
+
+    try:
+        data = asyncio.run(client.test_connection())
+        console.print(f"[green]Server is running[/green]")
+        console.print(f"  Version: {data.get('version', 'unknown')}")
+        console.print(f"  Status: {data.get('status', 'unknown')}")
+    except Exception as e:
+        console.print(f"[yellow]Server not reachable: {e}[/yellow]")
+
+
+@app.command()
+def show_key() -> None:
+    """Show current server API key."""
+    api_key = get_current_context_api_key()
+    if api_key:
+        console.print(f"[green]API Key:[/green] {api_key}")
+    else:
+        console.print(
+            "[yellow]No API key configured. One will be generated on server start.[/yellow]"
+        )

router_maestro/cli/stats.py

@@ -0,0 +1,76 @@
+"""Token usage statistics command."""
+
+import asyncio
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from router_maestro.cli.client import AdminClientError, get_admin_client
+
+console = Console()
+
+
+def stats(
+    days: int = typer.Option(7, "--days", "-d", help="Number of days to show"),
+    provider: str = typer.Option(None, "--provider", "-p", help="Filter by provider"),
+    model: str = typer.Option(None, "--model", "-m", help="Filter by model"),
+) -> None:
+    """Show token usage statistics."""
+    client = get_admin_client()
+
+    try:
+        data = asyncio.run(client.get_stats(days=days, provider=provider, model=model))
+    except AdminClientError as e:
+        console.print(f"[red]{e}[/red]")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Failed to get stats: {e}[/red]")
+        raise typer.Exit(1)
+
+    if data.get("total_requests", 0) == 0:
+        console.print("[dim]No usage data available.[/dim]")
+        return
+
+    # Summary table
+    console.print(f"\n[bold]Token Usage Summary (Last {days} Days)[/bold]\n")
+
+    summary_table = Table(show_header=False, box=None)
+    summary_table.add_column("Metric", style="cyan")
+    summary_table.add_column("Value", style="green", justify="right")
+
+    summary_table.add_row("Total Requests", f"{data.get('total_requests', 0):,}")
+    summary_table.add_row("Total Tokens", f"{data.get('total_tokens', 0):,}")
+    summary_table.add_row("  Prompt", f"{data.get('prompt_tokens', 0):,}")
+    summary_table.add_row("  Completion", f"{data.get('completion_tokens', 0):,}")
+
+    console.print(summary_table)
+
+    # By model table
+    by_model = data.get("by_model", {})
+    if by_model:
+        console.print("\n[bold]Usage by Model[/bold]\n")
+
+        model_table = Table()
+        model_table.add_column("Model", style="cyan")
+        model_table.add_column("Provider", style="magenta")
+        model_table.add_column("Requests", justify="right")
+        model_table.add_column("Total Tokens", justify="right", style="green")
+        model_table.add_column("Avg Latency", justify="right")
+
+        for model_key, record in by_model.items():
+            parts = model_key.split("/", 1)
+            provider_name = parts[0] if len(parts) > 1 else "-"
+            model_name = parts[1] if len(parts) > 1 else model_key
+
+            avg_latency = record.get("avg_latency_ms")
+            latency = f"{avg_latency:.0f} ms" if avg_latency else "-"
+            model_table.add_row(
+                model_name,
+                provider_name,
+                f"{record.get('request_count', 0):,}",
+                f"{record.get('total_tokens', 0):,}",
+                latency,
+            )
+
+        console.print(model_table)

router_maestro/config/__init__.py

@@ -0,0 +1,72 @@
+"""Config module for router-maestro."""
+
+from router_maestro.config.contexts import ContextConfig, ContextsConfig
+from router_maestro.config.paths import (
+    AUTH_FILE,
+    CONTEXTS_FILE,
+    LOG_FILE,
+    PRIORITIES_FILE,
+    PROVIDERS_FILE,
+    SERVER_CONFIG_FILE,
+    STATS_DB_FILE,
+    get_config_dir,
+    get_data_dir,
+)
+from router_maestro.config.priorities import (
+    FallbackConfig,
+    FallbackStrategy,
+    PrioritiesConfig,
+)
+from router_maestro.config.providers import (
+    CustomProviderConfig,
+    ModelConfig,
+    ProvidersConfig,
+)
+from router_maestro.config.server import (
+    get_current_context_api_key,
+    get_or_create_api_key,
+    set_local_api_key,
+)
+from router_maestro.config.settings import (
+    load_contexts_config,
+    load_priorities_config,
+    load_providers_config,
+    save_contexts_config,
+    save_priorities_config,
+    save_providers_config,
+)
+
+__all__ = [
+    # Paths
+    "get_data_dir",
+    "get_config_dir",
+    "AUTH_FILE",
+    "SERVER_CONFIG_FILE",
+    "PROVIDERS_FILE",
+    "PRIORITIES_FILE",
+    "CONTEXTS_FILE",
+    "STATS_DB_FILE",
+    "LOG_FILE",
+    # Provider models
+    "ModelConfig",
+    "CustomProviderConfig",
+    "ProvidersConfig",
+    # Priority models
+    "PrioritiesConfig",
+    "FallbackConfig",
+    "FallbackStrategy",
+    # Context models
+    "ContextConfig",
+    "ContextsConfig",
+    # Settings functions
+    "load_providers_config",
+    "save_providers_config",
+    "load_priorities_config",
+    "save_priorities_config",
+    "load_contexts_config",
+    "save_contexts_config",
+    # Server functions
+    "get_current_context_api_key",
+    "get_or_create_api_key",
+    "set_local_api_key",
+]

router_maestro/config/contexts.py

@@ -0,0 +1,29 @@
+"""Context configuration for remote deployments."""
+
+from pydantic import BaseModel, Field
+
+
+class ContextConfig(BaseModel):
+    """Configuration for a single deployment context."""
+
+    endpoint: str = Field(..., description="API endpoint URL")
+    api_key: str | None = Field(default=None, description="API key for authentication")
+
+
+class ContextsConfig(BaseModel):
+    """Root configuration for deployment contexts."""
+
+    current: str = Field(default="local", description="Currently active context name")
+    contexts: dict[str, ContextConfig] = Field(
+        default_factory=dict, description="Available contexts"
+    )
+
+    @classmethod
+    def get_default(cls) -> "ContextsConfig":
+        """Get default configuration with local context."""
+        return cls(
+            current="local",
+            contexts={
+                "local": ContextConfig(endpoint="http://localhost:8080"),
+            },
+        )

router_maestro/config/paths.py

@@ -0,0 +1,50 @@
+"""File path definitions for router-maestro."""
+
+import os
+from pathlib import Path
+
+
+def get_data_dir() -> Path:
+    """Get the data directory for router-maestro.
+
+    Returns ~/.local/share/router-maestro on Unix-like systems.
+    Returns %LOCALAPPDATA%/router-maestro on Windows.
+    """
+    if os.name == "nt":
+        # Windows
+        base = Path(os.environ.get("LOCALAPPDATA", Path.home() / "AppData" / "Local"))
+    else:
+        # Unix-like (Linux, macOS)
+        base = Path(os.environ.get("XDG_DATA_HOME", Path.home() / ".local" / "share"))
+
+    data_dir = base / "router-maestro"
+    data_dir.mkdir(parents=True, exist_ok=True)
+    return data_dir
+
+
+def get_config_dir() -> Path:
+    """Get the config directory for router-maestro.
+
+    Returns ~/.config/router-maestro on Unix-like systems.
+    Returns %LOCALAPPDATA%/router-maestro on Windows.
+    """
+    if os.name == "nt":
+        # Windows - use same as data dir
+        base = Path(os.environ.get("LOCALAPPDATA", Path.home() / "AppData" / "Local"))
+    else:
+        # Unix-like (Linux, macOS)
+        base = Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config"))
+
+    config_dir = base / "router-maestro"
+    config_dir.mkdir(parents=True, exist_ok=True)
+    return config_dir
+
+
+# File paths
+AUTH_FILE = get_data_dir() / "auth.json"
+SERVER_CONFIG_FILE = get_data_dir() / "server.json"
+PROVIDERS_FILE = get_config_dir() / "providers.json"
+PRIORITIES_FILE = get_config_dir() / "priorities.json"
+CONTEXTS_FILE = get_config_dir() / "contexts.json"
+STATS_DB_FILE = get_data_dir() / "stats.db"
+LOG_FILE = get_data_dir() / "router-maestro.log"