arbiter-cli 0.1.0__py3-none-any.whl

arbiter/cli/display.py

@@ -0,0 +1,381 @@
+"""Rich terminal display for Arbiter CLI output."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from rich.columns import Columns
+from rich.console import Console
+from rich.layout import Layout
+from rich.live import Live
+from rich.panel import Panel
+from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
+from rich.table import Table
+from rich.text import Text
+
+from arbiter.core.discover import DiscoveredModel
+from arbiter.core.leaderboard import Leaderboard
+from arbiter.core.metrics import ComparisonResult, ModelMetrics
+
+
+console = Console()
+
+# Color palette for models
+MODEL_COLORS = [
+    "cyan",
+    "magenta",
+    "green",
+    "yellow",
+    "blue",
+    "red",
+    "bright_cyan",
+    "bright_magenta",
+]
+
+
+def get_model_color(index: int) -> str:
+    return MODEL_COLORS[index % len(MODEL_COLORS)]
+
+
+def print_header() -> None:
+    """Print the Arbiter header."""
+    header = Text()
+    header.append("  ARBITER  ", style="bold white on blue")
+    header.append("  The final word on your local models.", style="dim")
+    console.print()
+    console.print(header)
+    console.print()
+
+
+def print_comparing(model_specs: list[str], prompt: str) -> None:
+    """Print what we're about to compare."""
+    console.print(f"[dim]Prompt:[/dim] {prompt[:120]}{'...' if len(prompt) > 120 else ''}")
+    models_text = " vs ".join(
+        f"[{get_model_color(i)}]{spec}[/{get_model_color(i)}]"
+        for i, spec in enumerate(model_specs)
+    )
+    console.print(f"[dim]Models:[/dim] {models_text}")
+    console.print()
+
+
+def create_progress(model_specs: list[str]) -> tuple[Progress, dict[str, int]]:
+    """Create a progress display for streaming generation."""
+    progress = Progress(
+        SpinnerColumn(),
+        TextColumn("[bold]{task.description}"),
+        BarColumn(bar_width=30),
+        TextColumn("{task.fields[tokens]} tokens"),
+        TextColumn("{task.fields[tps]} tok/s"),
+        TimeElapsedColumn(),
+        console=console,
+    )
+    task_ids = {}
+    for i, spec in enumerate(model_specs):
+        color = get_model_color(i)
+        task_id = progress.add_task(
+            f"[{color}]{spec}",
+            total=None,
+            tokens=0,
+            tps="--",
+        )
+        task_ids[spec] = task_id
+    return progress, task_ids
+
+
+def update_progress(
+    progress: Progress,
+    task_ids: dict[str, int],
+    model: str,
+    metrics: ModelMetrics,
+) -> None:
+    """Update progress display with latest metrics."""
+    # Match by model name in task_ids (may need to check original spec too)
+    task_id = None
+    for spec, tid in task_ids.items():
+        if model in spec or spec in model:
+            task_id = tid
+            break
+
+    if task_id is None:
+        return
+
+    tps = f"{metrics.tokens_per_sec:.1f}" if metrics.tokens_per_sec else "--"
+    progress.update(
+        task_id,
+        advance=1,
+        tokens=metrics._token_count,
+        tps=tps,
+    )
+
+
+def print_results(result: ComparisonResult) -> None:
+    """Print the full comparison results."""
+    console.print()
+
+    # Summary table
+    table = Table(
+        title="Results",
+        show_header=True,
+        header_style="bold",
+        border_style="dim",
+    )
+    table.add_column("Model", style="bold")
+    table.add_column("Tokens/sec", justify="right")
+    table.add_column("TTFT", justify="right")
+    table.add_column("Total Time", justify="right")
+    table.add_column("Tokens", justify="right")
+    table.add_column("Memory", justify="right")
+    table.add_column("Quality", justify="right")
+    table.add_column("", justify="center")
+
+    for i, m in enumerate(result.models):
+        color = get_model_color(i)
+        is_winner = m.model == result.winner
+
+        tps = f"{m.tokens_per_sec:.1f}" if m.tokens_per_sec else "--"
+        ttft = f"{m.ttft_ms:.0f}ms" if m.ttft_ms else "--"
+        total = f"{m.total_time_s:.1f}s" if m.total_time_s else "--"
+        tokens = str(m.total_tokens) if m.total_tokens else "--"
+        memory = (
+            f"{m.peak_memory_delta_mb:+.1f}MB"
+            if m.peak_memory_delta_mb is not None
+            else "--"
+        )
+        quality = f"{m.overall_score:.1f}/10" if m.overall_score else "--"
+        badge = "[bold green]WINNER[/bold green]" if is_winner else ""
+
+        style = f"bold {color}" if is_winner else color
+        table.add_row(
+            f"[{style}]{m.model}[/{style}]",
+            tps,
+            ttft,
+            total,
+            tokens,
+            memory,
+            quality,
+            badge,
+        )
+
+    console.print(table)
+
+    # Quality breakdown if available
+    scored_models = [m for m in result.models if m.quality_scores]
+    if scored_models:
+        console.print()
+        qtable = Table(
+            title="Quality Breakdown",
+            show_header=True,
+            header_style="bold",
+            border_style="dim",
+        )
+        qtable.add_column("Model", style="bold")
+        qtable.add_column("Correctness", justify="center")
+        qtable.add_column("Completeness", justify="center")
+        qtable.add_column("Clarity", justify="center")
+        qtable.add_column("Code Quality", justify="center")
+
+        for i, m in enumerate(scored_models):
+            color = get_model_color(i)
+            s = m.quality_scores
+            qtable.add_row(
+                f"[{color}]{m.model}[/{color}]",
+                _score_cell(s.get("correctness", 0)),
+                _score_cell(s.get("completeness", 0)),
+                _score_cell(s.get("clarity", 0)),
+                _score_cell(s.get("code_quality", 0)),
+            )
+        console.print(qtable)
+
+    # Scoring breakdown (the real explanation)
+    if result.scoring:
+        print_scoring_breakdown(result.scoring)
+
+    if result.judge_model:
+        console.print(f"[dim]Judged by: {result.judge_model}[/dim]")
+    console.print()
+
+
+def _score_cell(score: int | float) -> str:
+    """Format a score with color coding."""
+    score = float(score)
+    if score >= 8:
+        return f"[green]{score:.0f}[/green]"
+    elif score >= 6:
+        return f"[yellow]{score:.0f}[/yellow]"
+    else:
+        return f"[red]{score:.0f}[/red]"
+
+
+def print_scoring_breakdown(scoring) -> None:
+    """Print the composite scoring breakdown -- shows exactly WHY the winner won."""
+    console.print()
+
+    # Formula
+    console.print(f"[dim]Scoring: {scoring.formula}[/dim]")
+    console.print()
+
+    # Scoring table
+    table = Table(
+        title="Composite Scoring",
+        show_header=True,
+        header_style="bold",
+        border_style="dim",
+    )
+    table.add_column("Model", style="bold")
+    table.add_column("Composite", justify="right", style="bold")
+
+    # Get component names from first model
+    if scoring.model_scores:
+        for comp in scoring.model_scores[0].components:
+            table.add_column(comp.metric_name, justify="right")
+
+    for i, ms in enumerate(scoring.model_scores):
+        color = get_model_color(i)
+        is_winner = ms.model == scoring.winner
+
+        row = [
+            f"[{'bold ' + color if is_winner else color}]{ms.model}[/]",
+            f"[{'bold green' if is_winner else 'white'}]{ms.composite:.2f}[/]",
+        ]
+        for comp in ms.components:
+            rank_badge = " [green]#1[/green]" if comp.rank == 1 and len(scoring.model_scores) > 1 else ""
+            row.append(f"{comp.raw_value:.1f} {comp.raw_unit}{rank_badge}")
+        table.add_row(*row)
+
+    console.print(table)
+
+    # Winner explanation
+    if scoring.winner and scoring.winner_reason:
+        console.print()
+        console.print(
+            Panel(
+                f"[bold green]{scoring.winner}[/bold green]\n\n{scoring.winner_reason}",
+                title="[bold]Winner[/bold]",
+                border_style="green",
+                padding=(1, 2),
+            )
+        )
+    console.print()
+
+
+def print_model_output(model: str, output: str, index: int = 0) -> None:
+    """Print a model's full output in a panel."""
+    color = get_model_color(index)
+    console.print(
+        Panel(
+            output,
+            title=f"[bold {color}]{model}[/bold {color}]",
+            border_style=color,
+            padding=(1, 2),
+        )
+    )
+
+
+def print_discover(models: list[DiscoveredModel]) -> None:
+    """Print discovered models."""
+    if not models:
+        console.print("[yellow]No models found. Is Ollama running?[/yellow]")
+        return
+
+    # Group by provider
+    by_provider: dict[str, list[DiscoveredModel]] = {}
+    for m in models:
+        by_provider.setdefault(m.provider, []).append(m)
+
+    for provider, provider_models in by_provider.items():
+        table = Table(
+            title=f"{provider.upper()} Models",
+            show_header=True,
+            header_style="bold",
+            border_style="dim",
+        )
+        table.add_column("Model", style="bold cyan")
+        table.add_column("Size", justify="right")
+        table.add_column("Parameters", justify="right")
+        table.add_column("Quantization")
+        table.add_column("Family")
+        table.add_column("Vision", justify="center")
+        table.add_column("Spec", style="dim")
+
+        for m in provider_models:
+            size = f"{m.size_gb}GB" if m.size_gb else "--"
+            params = m.parameter_size or "--"
+            quant = m.quantization or "--"
+            family = m.family or "--"
+            vision = "[green]Yes[/green]" if m.multimodal else "[dim]--[/dim]"
+            table.add_row(m.name, size, params, quant, family, vision, m.spec)
+
+        console.print(table)
+        console.print()
+
+    console.print(f"[dim]Total: {len(models)} models across {len(by_provider)} providers[/dim]")
+
+
+def print_leaderboard(leaderboard: Leaderboard) -> None:
+    """Print the persistent leaderboard."""
+    ratings = leaderboard.sorted_ratings()
+
+    if not ratings:
+        console.print("[yellow]No leaderboard data yet. Run some comparisons first![/yellow]")
+        return
+
+    table = Table(
+        title="Arbiter Leaderboard",
+        show_header=True,
+        header_style="bold",
+        border_style="dim",
+    )
+    table.add_column("#", style="dim", justify="right")
+    table.add_column("Model", style="bold")
+    table.add_column("ELO", justify="right", style="bold")
+    table.add_column("W/L/D", justify="center")
+    table.add_column("Win Rate", justify="right")
+    table.add_column("Avg tok/s", justify="right")
+    table.add_column("Avg Quality", justify="right")
+    table.add_column("Comparisons", justify="right")
+
+    for i, r in enumerate(ratings):
+        rank = str(i + 1)
+        if i == 0:
+            rank = "[gold1]1[/gold1]"
+        elif i == 1:
+            rank = "[grey70]2[/grey70]"
+        elif i == 2:
+            rank = "[dark_orange3]3[/dark_orange3]"
+
+        elo_str = f"{r.elo:.0f}"
+        if r.elo >= 1600:
+            elo_str = f"[green]{elo_str}[/green]"
+        elif r.elo < 1400:
+            elo_str = f"[red]{elo_str}[/red]"
+
+        wld = f"{r.wins}/{r.losses}/{r.draws}"
+        win_rate = f"{r.win_rate * 100:.0f}%"
+        avg_tps = f"{r.avg_tokens_sec:.1f}" if r.avg_tokens_sec else "--"
+        avg_q = f"{r.avg_quality:.1f}/10" if r.avg_quality else "--"
+
+        color = get_model_color(i)
+        table.add_row(
+            rank,
+            f"[{color}]{r.name}[/{color}]",
+            elo_str,
+            wld,
+            win_rate,
+            avg_tps,
+            avg_q,
+            str(r.total_comparisons),
+        )
+
+    console.print(table)
+    console.print()
+
+
+def print_error(message: str) -> None:
+    """Print an error message."""
+    console.print(f"[bold red]Error:[/bold red] {message}")
+
+
+def print_json_output(result: ComparisonResult) -> None:
+    """Print results as JSON for scripting."""
+    import json
+    console.print_json(json.dumps(result.to_dict(), indent=2))