arbiter-cli 0.1.0__py3-none-any.whl

arbiter/cli/app.py

@@ -0,0 +1,699 @@
+"""Arbiter CLI - Typer-based command line interface."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Optional
+
+import typer
+from rich.live import Live
+
+from arbiter.cli.display import (
+    console,
+    create_progress,
+    get_model_color,
+    print_comparing,
+    print_discover,
+    print_error,
+    print_header,
+    print_json_output,
+    print_leaderboard,
+    print_model_output,
+    print_results,
+    update_progress,
+)
+
+app = typer.Typer(
+    name="arbiter",
+    help="The final word on your local models. Compare LLMs side-by-side.",
+    add_completion=False,
+    no_args_is_help=True,
+)
+
+
+# ---------------------------------------------------------------------------
+# arbiter run  -- the main command
+# ---------------------------------------------------------------------------
+
+@app.command(context_settings={"allow_extra_args": True, "allow_interspersed_args": True})
+def run(
+    ctx: typer.Context,
+    seq: bool = typer.Option(
+        False, "--seq", help="Run models one at a time (saves memory for 8GB machines)",
+    ),
+    dashboard: bool = typer.Option(
+        False, "--dashboard", "-d", help="Open animated web dashboard",
+    ),
+    image: Optional[str] = typer.Option(None, "--image", "-i", help="Image path for multimodal"),
+    output: Optional[str] = typer.Option(None, "--output", "-o", help="Output format: json"),
+    show: bool = typer.Option(False, "--show", "-s", help="Show full model outputs"),
+    no_judge: bool = typer.Option(False, "--no-judge", help="Skip quality judging"),
+    judge: str = typer.Option("auto", "--judge", "-j", help="Judge model"),
+    system: Optional[str] = typer.Option(None, "--system", help="System prompt"),
+) -> None:
+    """Run a comparison. Put models first, prompt last in quotes.
+
+    Examples:
+        arbiter run gemma4:e2b qwen3.5:4b "explain recursion"
+        arbiter run gemma4:e2b qwen3.5:4b "explain recursion" --seq
+        arbiter run gemma4:e2b qwen3.5:4b "write a sort" --seq --dashboard
+    """
+    args = ctx.args
+
+    # Separate models from prompt
+    # If no args at all, interactive mode: pick models + prompt
+    # If one arg, it's the prompt -- auto-detect models
+    # If 2+, last is prompt, rest are models
+    if len(args) == 0:
+        # Fully interactive: pick models and prompt
+        models, prompt = asyncio.run(_interactive_setup())
+    elif len(args) == 1:
+        # Just a prompt -- auto-pick models
+        prompt = args[0]
+        models = asyncio.run(_auto_select_models())
+    else:
+        prompt = args[-1]
+        models = args[:-1]
+
+    if not models:
+        print_error("No models found. Is Ollama running? Do you have models installed?")
+        console.print("[dim]Run: ollama pull gemma4:e2b[/dim]")
+        raise typer.Exit(1)
+
+    if dashboard:
+        asyncio.run(_run_with_dashboard(models, prompt, image, judge, no_judge, seq, system))
+    else:
+        asyncio.run(_run_cli(models, prompt, image, judge, output, show, no_judge, seq, system))
+
+
+async def _run_cli(
+    model_specs: list[str],
+    prompt: str,
+    image: Optional[str],
+    judge_model: str,
+    output_format: Optional[str],
+    show_output: bool,
+    no_judge: bool,
+    sequential: bool,
+    system: Optional[str],
+) -> None:
+    """Run comparison in CLI mode."""
+    from arbiter.core.judge import judge_comparison
+    from arbiter.core.leaderboard import Leaderboard
+    from arbiter.core.runner import run_comparison, run_single_model
+    from arbiter.core.metrics import ComparisonResult, compute_composite_scores, ScoreWeights
+    from datetime import datetime, timezone
+
+    print_header()
+    print_comparing(model_specs, prompt)
+
+    if sequential:
+        console.print("[dim]Sequential mode (low memory)[/dim]")
+        console.print()
+
+        all_metrics = []
+        for i, spec in enumerate(model_specs):
+            color = get_model_color(i)
+            console.print(f"[{color}]Running {spec}...[/{color}]")
+
+            progress, task_ids = create_progress([spec])
+
+            def on_token(model: str, text: str, metrics, _p=progress, _t=task_ids):
+                update_progress(_p, _t, model, metrics)
+
+            with Live(progress, console=console, refresh_per_second=10):
+                metrics = await run_single_model(
+                    model_spec=spec, prompt=prompt, system=system,
+                    image_path=image, on_token=on_token,
+                )
+            all_metrics.append(metrics)
+
+            tps = f"{metrics.tokens_per_sec:.1f} tok/s" if metrics.tokens_per_sec else "--"
+            console.print(f"  [{color}]Done[/{color}] - {metrics.total_tokens} tokens, {tps}")
+            console.print()
+
+        result = ComparisonResult(
+            prompt=prompt, models=all_metrics,
+            timestamp=datetime.now(timezone.utc).isoformat(),
+        )
+    else:
+        progress, task_ids = create_progress(model_specs)
+
+        def on_token(model: str, text: str, metrics):
+            update_progress(progress, task_ids, model, metrics)
+
+        with Live(progress, console=console, refresh_per_second=10):
+            result = await run_comparison(
+                model_specs=model_specs, prompt=prompt, system=system,
+                image_path=image, on_token=on_token, sequential=False,
+            )
+
+    # Judge quality (optional)
+    if not no_judge and len(model_specs) > 1:
+        with console.status("[bold cyan]Judging quality..."):
+            result = await judge_comparison(result, judge_model=judge_model)
+
+    # Compute composite scores and determine winner
+    has_quality = not no_judge and len(model_specs) > 1
+    result.scoring = compute_composite_scores(result, has_quality=has_quality)
+    result.winner = result.scoring.winner if result.scoring else None
+
+    # Update leaderboard
+    if len(model_specs) > 1:
+        lb = Leaderboard()
+        lb.update_from_comparison(result)
+
+    # Output
+    if output_format == "json":
+        print_json_output(result)
+    else:
+        print_results(result)
+        if show_output:
+            for i, m in enumerate(result.models):
+                print_model_output(m.model, m.output, index=i)
+
+
+async def _auto_select_models(max_models: int = 2) -> list[str]:
+    """Auto-detect installed models and pick the best ones to compare."""
+    from arbiter.core.discover import discover_ollama
+
+    models = await discover_ollama()
+    if not models:
+        return []
+
+    # Sort by size (prefer smaller models that fit in memory)
+    models.sort(key=lambda m: m.size or 0)
+
+    # Prefer models that fit in memory, but include all
+    safe = [m for m in models if m.fits_in_memory]
+    pool = safe if len(safe) >= 2 else models
+
+    # Pick up to max_models, preferring different families
+    selected = []
+    seen_families = set()
+    for m in pool:
+        family = m.family or m.name.split(":")[0]
+        if family not in seen_families or len(selected) < max_models:
+            if m.memory_warning:
+                console.print(f"[yellow]Note: {m.name} ({m.size_gb}GB) - {m.memory_warning}[/yellow]")
+            selected.append(m.spec)
+            seen_families.add(family)
+        if len(selected) >= max_models:
+            break
+
+    return selected
+
+
+async def _interactive_setup() -> tuple[list[str], str]:
+    """Interactive model selection and prompt input."""
+    from arbiter.core.discover import discover_ollama
+    from rich.prompt import Prompt
+
+    print_header()
+
+    with console.status("[bold cyan]Finding installed models..."):
+        available = await discover_ollama()
+
+    if not available:
+        print_error("No models found. Is Ollama running?")
+        console.print("[dim]Install: https://ollama.com/download[/dim]")
+        console.print("[dim]Then: ollama pull gemma4:e2b[/dim]")
+        raise typer.Exit(1)
+
+    # Show available models with numbers
+    console.print("[bold]Available models:[/bold]")
+    console.print()
+    for i, m in enumerate(available, 1):
+        size = f"{m.size_gb}GB" if m.size_gb else "?"
+        params = m.parameter_size or ""
+        console.print(f"  [cyan]{i}[/cyan]. {m.name}  [dim]{size} {params}[/dim]")
+    console.print()
+
+    # Let user pick
+    selection = Prompt.ask(
+        "Pick models to compare (comma-separated numbers, or 'all')",
+        default="1,2" if len(available) >= 2 else "1",
+    )
+
+    if selection.strip().lower() == "all":
+        selected = [m.spec for m in available]
+    else:
+        indices = []
+        for part in selection.split(","):
+            part = part.strip()
+            if part.isdigit():
+                idx = int(part) - 1
+                if 0 <= idx < len(available):
+                    indices.append(idx)
+        selected = [available[i].spec for i in indices]
+
+    if not selected:
+        print_error("No models selected.")
+        raise typer.Exit(1)
+
+    models_str = ", ".join(f"[cyan]{s}[/cyan]" for s in selected)
+    console.print(f"Selected: {models_str}")
+    console.print()
+
+    prompt = Prompt.ask("Enter your prompt")
+    return selected, prompt
+
+
+async def _run_with_dashboard(
+    model_specs: list[str],
+    prompt: str,
+    image: Optional[str],
+    judge_model: str,
+    no_judge: bool,
+    sequential: bool,
+    system: Optional[str],
+) -> None:
+    """Run comparison with the web dashboard."""
+    from arbiter.dashboard.server import start_server
+
+    mode = "sequentially" if sequential else "in parallel"
+    console.print(f"[bold cyan]Starting Arbiter Dashboard...[/bold cyan] ({mode})")
+    console.print("[dim]Opening browser at http://127.0.0.1:7878 ...[/dim]")
+
+    await start_server(
+        model_specs=model_specs, prompt=prompt, image_path=image,
+        judge_model=judge_model, no_judge=no_judge,
+        sequential=sequential, system=system,
+    )
+
+
+# ---------------------------------------------------------------------------
+# arbiter dashboard  -- just open the dashboard
+# ---------------------------------------------------------------------------
+
+@app.command()
+def dashboard(
+    port: int = typer.Option(7878, "--port", "-p", help="Port to run on"),
+) -> None:
+    """Open the Arbiter dashboard in your browser.
+
+    Shows your leaderboard, past results, and waits for new comparisons.
+    """
+    import webbrowser
+    from arbiter.dashboard.server import app as fastapi_app
+    import uvicorn
+
+    print_header()
+    console.print(f"[bold cyan]Dashboard[/bold cyan] running at [underline]http://127.0.0.1:{port}[/underline]")
+    console.print("[dim]Press Ctrl+C to stop[/dim]")
+    console.print()
+
+    # Open browser after a short delay
+    import threading
+    threading.Timer(1.0, lambda: webbrowser.open(f"http://127.0.0.1:{port}")).start()
+
+    uvicorn.run(fastapi_app, host="127.0.0.1", port=port, log_level="warning")
+
+
+# ---------------------------------------------------------------------------
+# arbiter benchmark  -- the real test suite
+# ---------------------------------------------------------------------------
+
+@app.command(context_settings={"allow_extra_args": True, "allow_interspersed_args": True})
+def benchmark(
+    ctx: typer.Context,
+    quick: bool = typer.Option(False, "--quick", "-q", help="Run quick subset (5 tests)"),
+    seq: bool = typer.Option(False, "--seq", help="Run models one at a time (saves memory)"),
+    output: Optional[str] = typer.Option(None, "--output", "-o", help="Output format: json"),
+) -> None:
+    """Run the real benchmark suite. Auto-detects your models.
+
+    20 automated tests across 10 categories. Every test has a
+    programmatic pass/fail -- no LLM-as-judge.
+
+    Categories: math, coding, reasoning, instruction fidelity,
+    constraint adherence, consistency, sycophancy resistance,
+    temporal reasoning, context recall, output stability.
+
+    Examples:
+        arbiter benchmark                  (auto-detect models)
+        arbiter benchmark --quick          (5 tests instead of 20)
+        arbiter benchmark --seq            (one model at a time)
+        arbiter benchmark gemma4:e2b       (specific model)
+    """
+    from arbiter.core.benchmarks import run_benchmark_comparison, run_benchmark_suite
+
+    print_header()
+
+    # Models are optional -- auto-detect if not provided
+    models = ctx.args if ctx.args else None
+    if not models:
+        console.print("[dim]Auto-detecting installed models...[/dim]")
+        detected = asyncio.run(_auto_select_models(max_models=5))
+        if not detected:
+            print_error("No models found. Is Ollama running?")
+            console.print("[dim]Run: ollama pull gemma4:e2b[/dim]")
+            raise typer.Exit(1)
+        models = detected
+
+    from arbiter.core.benchmarks import ALL_TESTS, QUICK_TESTS
+    n_tests = str(len(QUICK_TESTS)) if quick else str(len(ALL_TESTS))
+    model_str = " vs ".join(
+        f"[{get_model_color(i)}]{m}[/{get_model_color(i)}]"
+        for i, m in enumerate(models)
+    )
+    console.print(f"[bold cyan]Benchmarking[/bold cyan] {model_str}")
+    console.print(f"[dim]{n_tests} tests, automated verification, no LLM judge[/dim]")
+    console.print()
+
+    if len(models) == 1:
+        with console.status("[bold cyan]Running benchmark suite..."):
+            result = asyncio.run(run_benchmark_suite(models[0], quick=quick))
+        results = [result]
+    else:
+        if seq:
+            # Run one model at a time
+            results = []
+            for i, model in enumerate(models):
+                color = get_model_color(i)
+                console.print(f"[{color}]Benchmarking {model}...[/{color}]")
+                with console.status(f"[bold cyan]Running tests on {model}..."):
+                    result = asyncio.run(run_benchmark_suite(model, quick=quick))
+                results.append(result)
+                console.print(f"  [{color}]Done[/{color}] - {result.overall_score * 100:.0f}%")
+                console.print()
+        else:
+            with console.status("[bold cyan]Running benchmark suite..."):
+                results = asyncio.run(run_benchmark_comparison(models, quick=quick))
+
+    if output == "json":
+        import json
+        console.print_json(json.dumps([r.to_dict() for r in results], indent=2))
+    else:
+        _print_benchmark_results(results)
+
+
+def _print_benchmark_results(results: list) -> None:
+    """Print benchmark results in a way any user can understand."""
+    from rich.table import Table
+    from rich.panel import Panel
+    from rich.text import Text
+
+    # Category descriptions humans understand
+    CAT_EXPLAIN = {
+        "instruction_following": "Can it follow your instructions exactly?",
+        "code_generation": "Can it write working code?",
+        "factual_accuracy": "Does it give real facts or make things up?",
+        "reasoning": "Can it think step-by-step and solve problems?",
+        "consistency": "Does it give the same answer every time?",
+        "pressure_resistance": "Does it hold its ground when you push back?",
+        "speed": "How fast does it generate on your hardware?",
+        "context_recall": "Can it find specific info in longer text?",
+        "timeout": "Tests that took too long to complete",
+        "error": "Tests that encountered errors",
+    }
+
+    console.print()
+
+    # ── Overall scores (big and clear) ──
+    console.print("[bold]Overall Scores[/bold]")
+    console.print("[dim]Higher is better. 100 = perfect on every test.[/dim]")
+    console.print()
+
+    for i, r in enumerate(results):
+        color = get_model_color(i)
+        score = r.overall_score * 100
+        bar_width = 30
+        filled = int((score / 100) * bar_width)
+        bar = "[green]" + "█" * filled + "[/green]" + "[dim]░[/dim]" * (bar_width - filled)
+        score_color = "green" if score >= 70 else "yellow" if score >= 50 else "red"
+        console.print(
+            f"  [{color}]{r.model:<20}[/{color}] {bar}  [{score_color}]{score:.0f}/100[/{score_color}]"
+            f"  [dim]({r.total_passed}/{r.total_tests} tests passed)[/dim]"
+        )
+    console.print()
+
+    # ── Category breakdown with explanations ──
+    # Group tests by category
+    all_cats = []
+    seen_cats = set()
+    for r in results:
+        for br in r.results:
+            if br.category not in seen_cats:
+                all_cats.append(br.category)
+                seen_cats.add(br.category)
+
+    for cat in all_cats:
+        explain = CAT_EXPLAIN.get(cat, cat.replace("_", " ").title())
+        cat_label = cat.replace("_", " ").title()
+
+        # Get scores for this category per model
+        cat_scores = []
+        for i, r in enumerate(results):
+            score = r.category_scores.get(cat, 0) * 100
+            cat_scores.append((r.model, score, get_model_color(i)))
+
+        # Find best in category
+        best_score = max(s for _, s, _ in cat_scores) if cat_scores else 0
+
+        console.print(f"  [bold]{cat_label}[/bold]  [dim]{explain}[/dim]")
+
+        # Per-model scores for this category
+        for model_name, score, color in cat_scores:
+            is_best = score == best_score and best_score > 0 and len(results) > 1
+            badge = " [green]BEST[/green]" if is_best else ""
+            score_color = "green" if score >= 70 else "yellow" if score >= 50 else "red"
+            console.print(f"    [{color}]{model_name:<18}[/{color}] [{score_color}]{score:>3.0f}%[/{score_color}]{badge}")
+
+        # Show individual test results for this category
+        for r in results[:1]:  # use first model's test list as reference
+            cat_tests = [br for br in r.results if br.category == cat]
+            for test in cat_tests:
+                # Collect all model results for this test
+                test_results = []
+                for ri, rr in enumerate(results):
+                    br = next((b for b in rr.results if b.name == test.name), None)
+                    if br:
+                        if br.passed:
+                            test_results.append(f"[green]PASS[/green]")
+                        else:
+                            test_results.append(f"[red]FAIL[/red]")
+                    else:
+                        test_results.append("[dim]--[/dim]")
+
+                result_str = "  ".join(test_results)
+                # Show what the test actually checked
+                desc = test.description if test.description else test.name
+                console.print(f"      [dim]{desc}:[/dim] {result_str}")
+
+        console.print()
+
+    # ── Winner explanation ──
+    if len(results) > 1:
+        best = max(results, key=lambda r: r.overall_score)
+        best_color = get_model_color(results.index(best))
+
+        # Build explanation
+        strengths = []
+        weaknesses = []
+        for cat in all_cats:
+            if cat in ("timeout", "error"):
+                continue
+            scores = [(r.model, r.category_scores.get(cat, 0)) for r in results]
+            scores.sort(key=lambda x: x[1], reverse=True)
+            if scores[0][0] == best.model and scores[0][1] > 0:
+                strengths.append(cat.replace("_", " "))
+            elif len(scores) > 1 and scores[0][0] != best.model and scores[0][1] > scores[-1][1]:
+                weaknesses.append((cat.replace("_", " "), scores[0][0]))
+
+        explanation_parts = [
+            f"[bold {best_color}]{best.model}[/bold {best_color}] scored [bold]{best.overall_score * 100:.0f}/100[/bold]",
+            f"passing {best.total_passed} of {best.total_tests} tests.",
+        ]
+        if strengths:
+            explanation_parts.append(f"\nStrong at: {', '.join(strengths)}.")
+        if weaknesses:
+            weak_strs = [f"{cat} (beaten by {model})" for cat, model in weaknesses[:3]]
+            explanation_parts.append(f"Weaker at: {', '.join(weak_strs)}.")
+
+        console.print(Panel(
+            " ".join(explanation_parts),
+            title="[bold]Winner[/bold]",
+            border_style="green",
+            padding=(1, 2),
+        ))
+    elif len(results) == 1:
+        r = results[0]
+        console.print(Panel(
+            f"[bold]{r.model}[/bold] scored [bold]{r.overall_score * 100:.0f}/100[/bold], "
+            f"passing {r.total_passed} of {r.total_tests} tests.",
+            title="[bold]Result[/bold]",
+            border_style="cyan",
+            padding=(1, 2),
+        ))
+    console.print()
+
+
+# ---------------------------------------------------------------------------
+# ---------------------------------------------------------------------------
+# arbiter swe  -- SWE-bench style testing in Docker
+# ---------------------------------------------------------------------------
+
+@app.command(context_settings={"allow_extra_args": True, "allow_interspersed_args": True})
+def swe(
+    ctx: typer.Context,
+    output: Optional[str] = typer.Option(None, "--output", "-o", help="Output format: json"),
+) -> None:
+    """Run SWE-bench style tests in Docker containers.
+
+    Real buggy code + real test suites. Models write patches,
+    Docker runs pytest to verify. The gold standard for code testing.
+
+    Requires Docker Desktop to be running.
+
+    Examples:
+        arbiter swe                          (auto-detect models)
+        arbiter swe gemma4:e2b qwen3.5:4b    (specific models)
+    """
+    from arbiter.core.swe.container import check_docker
+    from arbiter.core.swe.runner import run_swe_comparison
+    from arbiter.core.swe.test_packs import TOTAL_SWE_TESTS
+    from rich.table import Table
+    from rich.panel import Panel
+
+    print_header()
+
+    # Check Docker
+    if not check_docker():
+        print_error("Docker is not running.")
+        console.print("[dim]Install Docker Desktop: https://docker.com/products/docker-desktop[/dim]")
+        console.print("[dim]Then start it and try again.[/dim]")
+        raise typer.Exit(1)
+
+    # Models
+    models = ctx.args if ctx.args else None
+    if not models:
+        console.print("[dim]Auto-detecting models...[/dim]")
+        detected = asyncio.run(_auto_select_models(max_models=2))
+        if not detected:
+            print_error("No models found.")
+            raise typer.Exit(1)
+        models = detected
+
+    model_str = " vs ".join(
+        f"[{get_model_color(i)}]{m}[/{get_model_color(i)}]"
+        for i, m in enumerate(models)
+    )
+    console.print(f"[bold magenta]SWE Testing[/bold magenta] {model_str}")
+    console.print(f"[dim]{TOTAL_SWE_TESTS} real code tests in Docker containers[/dim]")
+    console.print()
+
+    with console.status("[bold magenta]Running SWE tests (this takes a while)..."):
+        results = asyncio.run(run_swe_comparison(models))
+
+    if output == "json":
+        import json
+        console.print_json(json.dumps([r.to_dict() for r in results], indent=2))
+        return
+
+    # Display results
+    table = Table(title="SWE Test Results", border_style="dim")
+    table.add_column("Model", style="bold")
+    table.add_column("Passed", justify="right")
+    table.add_column("Total", justify="right")
+    table.add_column("Pass Rate", justify="right", style="bold")
+
+    for i, r in enumerate(results):
+        color = get_model_color(i)
+        rate = f"{r.pass_rate * 100:.0f}%"
+        rate_color = "green" if r.pass_rate >= 0.7 else "yellow" if r.pass_rate >= 0.5 else "red"
+        table.add_row(
+            f"[{color}]{r.model}[/{color}]",
+            str(r.total_passed), str(r.total_tests),
+            f"[{rate_color}]{rate}[/{rate_color}]",
+        )
+    console.print(table)
+    console.print()
+
+    # Per-test breakdown
+    detail = Table(title="Test Details", border_style="dim")
+    detail.add_column("Test", style="bold")
+    detail.add_column("Category", style="dim")
+    for i, r in enumerate(results):
+        detail.add_column(f"[{get_model_color(i)}]{r.model}[/{get_model_color(i)}]", justify="center")
+
+    if results:
+        for ti, test in enumerate(results[0].results):
+            row = [test.test_case, test.category]
+            for r in results:
+                t = r.results[ti] if ti < len(r.results) else None
+                if t and t.passed:
+                    row.append(f"[green]{t.tests_passed}/{t.tests_total} PASS[/green]")
+                elif t:
+                    row.append(f"[red]{t.tests_passed}/{t.tests_total} FAIL[/red]")
+                else:
+                    row.append("[dim]--[/dim]")
+            detail.add_row(*row)
+
+    console.print(detail)
+    console.print()
+
+    if len(results) > 1:
+        best = max(results, key=lambda r: r.pass_rate)
+        console.print(Panel(
+            f"[bold green]{best.model}[/bold green] passed {best.total_passed}/{best.total_tests} tests ({best.pass_rate*100:.0f}%)",
+            title="[bold]SWE Winner[/bold]",
+            border_style="green",
+        ))
+    console.print()
+
+
+# ---------------------------------------------------------------------------
+# arbiter discover / leaderboard / config
+# ---------------------------------------------------------------------------
+
+@app.command()
+def discover() -> None:
+    """List all available models across providers."""
+    from arbiter.core.discover import discover_all
+
+    print_header()
+    with console.status("[bold cyan]Discovering models..."):
+        models = asyncio.run(discover_all())
+    print_discover(models)
+
+
+@app.command()
+def leaderboard() -> None:
+    """View the persistent ELO leaderboard."""
+    from arbiter.core.leaderboard import Leaderboard
+
+    print_header()
+    lb = Leaderboard()
+    print_leaderboard(lb)
+
+
+@app.command()
+def config(
+    ollama_host: Optional[str] = typer.Option(None, "--ollama-host", help="Set Ollama API host"),
+    show_config: bool = typer.Option(False, "--show", help="Show current config"),
+) -> None:
+    """View or modify Arbiter configuration."""
+    from arbiter.core.config import load_config, save_config, get_ollama_host
+
+    if show_config:
+        cfg = load_config()
+        console.print(f"Ollama host: {get_ollama_host()}")
+        for k, v in cfg.items():
+            console.print(f"{k}: {v}")
+        return
+
+    if ollama_host:
+        cfg = load_config()
+        cfg["ollama_host"] = ollama_host
+        save_config(cfg)
+        console.print(f"[green]Ollama host set to: {ollama_host}[/green]")
+
+
+def entry() -> None:
+    """Entry point for the CLI."""
+    app()
+
+
+if __name__ == "__main__":
+    entry()