tokenable 1.0.0__py3-none-any.whl

tokenable/cli/__init__.py

@@ -0,0 +1,695 @@
+"""TokEnable CLI — Cost gates for LLM API calls."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+import tokenable
+
+app = typer.Typer(name="tokenable", help="Cost gates for LLM API calls.", no_args_is_help=True)
+console = Console()
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"tokenable {tokenable.__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(
+        False, "--version", "-v", callback=_version_callback, is_eager=True, help="Show version."
+    ),
+) -> None:
+    """Cost gates for LLM API calls."""
+
+
+@app.command()
+def estimate(
+    path: str = typer.Argument(".", help="Directory to scan."),
+    volume: str | None = typer.Option(
+        None, "--volume", "-n", help="Calls/month (number or low/medium/high)."
+    ),
+    format: str = typer.Option("table", "--format", "-f", help="Output format: table, json, csv."),
+    config: str | None = typer.Option(None, "--config", "-c", help="Path to config file."),
+) -> None:
+    """Estimate monthly LLM API costs for a codebase."""
+    from tokenable.config import getEnvVolume, load_config, parseVolume, resolveVolume
+    from tokenable.estimator import buildEstimateRows
+    from tokenable.models import EstimateSummary
+    from tokenable.scanner import scan_directory
+
+    cfg = load_config(config)
+    cli_volume: int | None = None
+    cli_volume_explicit = False
+    if volume is not None:
+        cli_volume = parseVolume(volume)
+        cli_volume_explicit = True
+    elif (env_vol := getEnvVolume()) is not None:
+        cli_volume = env_vol
+
+    ignore = cfg.ignore if cfg else []
+    results = scan_directory(path, ignore)
+
+    if not results:
+        console.print("[yellow]No LLM API calls found.[/yellow]")
+        raise typer.Exit()
+
+    rows, unknown = buildEstimateRows(results, cfg, cli_volume, cli_volume_explicit)
+
+    if unknown:
+        for u in unknown:
+            console.print(f"[dim]⚠ Unknown model: {u}[/dim]")
+
+    total = sum(r.monthly_cost for r in rows)
+    effective_volume = (
+        rows[0].monthly_cost / rows[0].cost_per_call if rows and rows[0].cost_per_call > 0 else 1000
+    )
+
+    if format == "json":
+        import json as json_mod
+
+        summary = EstimateSummary(rows=rows, total_monthly_cost=total, volume=int(effective_volume))
+        typer.echo(json_mod.dumps(summary.model_dump(), indent=2))
+    elif format == "csv":
+        typer.echo("file,line,provider,model,input_tokens,output_tokens,cost_per_call,monthly_cost")
+        for r in rows:
+            typer.echo(
+                f"{r.file},{r.line},{r.provider},{r.model},{r.input_tokens},{r.output_tokens},{r.cost_per_call:.6f},{r.monthly_cost:.2f}"
+            )
+    else:
+        table = Table(title="TokEnable Estimate")
+        table.add_column("File", style="cyan")
+        table.add_column("Line", justify="right")
+        table.add_column("Provider")
+        table.add_column("Model", style="green")
+        table.add_column("In Tokens", justify="right")
+        table.add_column("Out Tokens", justify="right")
+        table.add_column("$/call", justify="right")
+        table.add_column("$/month", justify="right", style="bold")
+        for r in rows:
+            table.add_row(
+                r.file,
+                str(r.line),
+                r.provider,
+                r.model,
+                f"{r.input_tokens:,}",
+                f"{r.output_tokens:,}",
+                f"${r.cost_per_call:.4f}",
+                f"${r.monthly_cost:.2f}",
+            )
+        console.print(table)
+        console.print(f"\n[bold]Total estimated monthly cost:[/bold] [green]${total:.2f}[/green]")
+
+
+@app.command()
+def check(
+    path: str = typer.Argument(".", help="Directory to scan."),
+    volume: str | None = typer.Option(
+        None, "--volume", "-n", help="Calls/month (number or low/medium/high)."
+    ),
+    format: str = typer.Option("table", "--format", "-f", help="Output format: table, json."),
+    config: str | None = typer.Option(None, "--config", "-c", help="Path to config file."),
+    max_monthly_cost: float | None = typer.Option(
+        None, "--max-monthly-cost", help="Fail if total monthly cost exceeds this."
+    ),
+    max_cost_per_call: float | None = typer.Option(
+        None, "--max-cost-per-call", help="Fail if any single call exceeds this."
+    ),
+) -> None:
+    """Check costs against budget thresholds (CI gate)."""
+    from tokenable.config import getEnvVolume, load_config, parseVolume
+    from tokenable.estimator import buildEstimateRows
+    from tokenable.scanner import scan_directory
+
+    cfg = load_config(config)
+    cli_volume: int | None = None
+    cli_volume_explicit = False
+    if volume is not None:
+        cli_volume = parseVolume(volume)
+        cli_volume_explicit = True
+    elif (env_vol := getEnvVolume()) is not None:
+        cli_volume = env_vol
+
+    ignore = cfg.ignore if cfg else []
+    results = scan_directory(path, ignore)
+
+    if not results:
+        console.print("[green]✓ No LLM API calls found.[/green]")
+        raise typer.Exit()
+
+    rows, _ = buildEstimateRows(results, cfg, cli_volume, cli_volume_explicit)
+    total = sum(r.monthly_cost for r in rows)
+
+    # Resolve thresholds from config budgets or CLI flags
+    threshold_monthly = max_monthly_cost
+    threshold_per_call = max_cost_per_call
+    if cfg and cfg.budgets:
+        if threshold_monthly is None and cfg.budgets.max_monthly_cost is not None:
+            threshold_monthly = cfg.budgets.max_monthly_cost
+        if threshold_per_call is None and cfg.budgets.block is not None:
+            threshold_per_call = cfg.budgets.block
+
+    violations: list[str] = []
+
+    if threshold_monthly is not None and total > threshold_monthly:
+        violations.append(f"Total monthly cost ${total:.2f} exceeds limit ${threshold_monthly:.2f}")
+
+    if threshold_per_call is not None:
+        for r in rows:
+            if r.cost_per_call > threshold_per_call:
+                violations.append(
+                    f"{r.file}:{r.line} — ${r.cost_per_call:.4f}/call exceeds ${threshold_per_call:.4f}"
+                )
+
+    if format == "json":
+        import json as json_mod
+
+        typer.echo(
+            json_mod.dumps(
+                {
+                    "passed": len(violations) == 0,
+                    "total_monthly_cost": total,
+                    "violations": violations,
+                },
+                indent=2,
+            )
+        )
+    else:
+        if violations:
+            console.print(f"[bold red]✗ Budget check failed[/bold red] — ${total:.2f}/month")
+            for v in violations:
+                console.print(f"  [red]• {v}[/red]")
+        else:
+            console.print(f"[bold green]✓ Budget check passed[/bold green] — ${total:.2f}/month")
+
+    if violations:
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def init(
+    hooks: bool = typer.Option(True, "--hooks/--no-hooks", help="Install git hooks."),
+    config_flag: bool = typer.Option(True, "--config/--no-config", help="Create config file."),
+    hook: str = typer.Option("pre-commit", "--hook", help="Hook type: pre-commit or pre-push."),
+) -> None:
+    """Initialize TokEnable in a project."""
+    import os
+
+    from tokenable.enforcer import create_config, find_git_root, setup_hooks
+
+    cwd = os.getcwd()
+    console.print("[bold]TokEnable Setup[/bold]\n")
+
+    if config_flag:
+        result = create_config(cwd)
+        if result:
+            console.print("[green]  Created tokenable.config.json[/green]")
+        else:
+            console.print("[dim]  tokenable.config.json already exists, skipping.[/dim]")
+
+    if hooks:
+        git_root = find_git_root(cwd)
+        if git_root:
+            msg = setup_hooks(git_root, hook)
+            console.print(f"[green]  {msg}[/green]")
+        else:
+            console.print("[yellow]  Not a git repository — skipping hooks.[/yellow]")
+
+    console.print("\n[bold]Next steps:[/bold]")
+    console.print("  1. Edit tokenable.config.json to set budget thresholds")
+    console.print("  2. Run: tokenable estimate .")
+    console.print("  3. Commit tokenable.config.json to your repo")
+
+
+@app.command()
+def diff(
+    path: str = typer.Argument(".", help="Directory to scan."),
+    base: str = typer.Option("main", "--base", help="Base git ref."),
+    head: str = typer.Option("HEAD", "--head", help="Head git ref."),
+    volume: str | None = typer.Option(None, "--volume", "-n", help="Calls/month."),
+    format: str = typer.Option("table", "--format", "-f", help="Output format."),
+    fail_on_increase: float | None = typer.Option(
+        None, "--fail-on-increase", help="Exit 1 if monthly increase exceeds this USD amount."
+    ),
+    config: str | None = typer.Option(None, "--config", "-c", help="Path to config file."),
+) -> None:
+    """Compare token costs between two git refs."""
+    import os
+    import tempfile
+
+    from git import Repo
+
+    from tokenable.config import getEnvVolume, load_config, parseVolume
+    from tokenable.estimator import buildEstimateRows
+    from tokenable.scanner import scan_directory
+
+    cfg = load_config(config)
+    cli_volume = parseVolume(volume) if volume else (getEnvVolume() or 1000)
+    cli_volume_explicit = volume is not None
+
+    git_root = os.path.abspath(path)
+    try:
+        repo = Repo(git_root, search_parent_directories=True)
+    except Exception:
+        console.print("[red]Error: Not a git repository.[/red]")
+        raise typer.Exit(1)
+
+    ignore = cfg.ignore if cfg else []
+
+    # Scan head (working dir if HEAD)
+    head_results = scan_directory(git_root, ignore)
+    head_rows, _ = buildEstimateRows(head_results, cfg, cli_volume, cli_volume_explicit)
+    head_total = sum(r.monthly_cost for r in head_rows)
+
+    # Scan base ref in temp dir
+    base_total = 0.0
+    try:
+        with tempfile.TemporaryDirectory():
+            repo.git.checkout(base, "--", ".")
+            base_results = scan_directory(git_root, ignore)
+            base_rows, _ = buildEstimateRows(base_results, cfg, cli_volume, cli_volume_explicit)
+            base_total = sum(r.monthly_cost for r in base_rows)
+            repo.git.checkout(head, "--", ".")
+    except Exception:
+        # Fallback: just compare current state
+        base_total = 0.0
+
+    delta = head_total - base_total
+    delta_str = f"+${delta:.2f}" if delta >= 0 else f"-${abs(delta):.2f}"
+
+    if format == "json":
+        import json as json_mod
+
+        typer.echo(
+            json_mod.dumps(
+                {
+                    "base": base,
+                    "head": head,
+                    "baseMonthlyCost": base_total,
+                    "headMonthlyCost": head_total,
+                    "netMonthlyDelta": delta,
+                },
+                indent=2,
+            )
+        )
+    else:
+        console.print(f"[bold]Cost diff:[/bold] {base} → {head}")
+        console.print(f"  Base: ${base_total:.2f}/mo")
+        console.print(f"  Head: ${head_total:.2f}/mo")
+        color = "red" if delta > 0 else "green"
+        console.print(f"  [bold {color}]Net: {delta_str}/mo[/bold {color}]")
+
+        if cfg and cfg.budgets:
+            if cfg.budgets.warn and delta >= cfg.budgets.warn:
+                console.print(
+                    f"[yellow]⚠ Budget warning: exceeds warn threshold (${cfg.budgets.warn})[/yellow]"
+                )
+            if cfg.budgets.block and delta >= cfg.budgets.block:
+                console.print(
+                    f"[red]✗ Budget blocked: exceeds block threshold (${cfg.budgets.block})[/red]"
+                )
+                raise typer.Exit(1)
+
+    if fail_on_increase is not None and delta > fail_on_increase:
+        console.print(
+            f"[red]✗ Cost increase ${delta:.2f} exceeds threshold ${fail_on_increase:.2f}[/red]"
+        )
+        raise typer.Exit(1)
+
+
+@app.command()
+def audit(
+    path: str = typer.Argument(".", help="Directory to scan."),
+    volume: str | None = typer.Option(None, "--volume", "-n", help="Calls/month."),
+    format: str = typer.Option("table", "--format", "-f", help="Output format."),
+    config: str | None = typer.Option(None, "--config", "-c", help="Path to config file."),
+) -> None:
+    """Scan for cost optimization opportunities."""
+    from tokenable.config import getEnvVolume, load_config, parseVolume
+    from tokenable.recommender import (
+        detect_batch_opportunities,
+        detect_caching_opportunities,
+        detect_smart_alternatives,
+    )
+    from tokenable.scanner import scan_directory
+
+    cfg = load_config(config)
+    vol = parseVolume(volume) if volume else (getEnvVolume() or 1000)
+    results = scan_directory(path, cfg.ignore if cfg else [])
+
+    if not results:
+        console.print("[yellow]No LLM API calls detected.[/yellow]")
+        raise typer.Exit()
+
+    smart = detect_smart_alternatives(results, vol)
+    caching = detect_caching_opportunities(results, vol)
+    batch = detect_batch_opportunities(results, vol)
+    total_savings = (
+        sum(f.monthly_savings for f in smart)
+        + sum(f.monthly_savings for f in caching)
+        + sum(f.monthly_savings for f in batch)
+    )
+
+    if format == "json":
+        import json as json_mod
+
+        typer.echo(
+            json_mod.dumps(
+                {
+                    "totalPotentialSavings": total_savings,
+                    "volume": vol,
+                    "findings": [f.model_dump() for f in smart]
+                    + [f.model_dump() for f in caching]
+                    + [f.model_dump() for f in batch],
+                },
+                indent=2,
+            )
+        )
+    else:
+        if not smart and not caching and not batch:
+            console.print(
+                "[green]No optimization opportunities found. Your LLM usage looks efficient![/green]"
+            )
+            raise typer.Exit()
+
+        console.print(
+            f"[bold]TokEnable Audit — {len(smart) + len(caching) + len(batch)} opportunities found[/bold]\n"
+        )
+
+        if smart:
+            console.print("[bold yellow]SMART MODEL ALTERNATIVES[/bold yellow]")
+            for f in smart:
+                prov_note = (
+                    f" ({f.suggested_provider.value})"
+                    if f.suggested_provider != f.current_provider
+                    else ""
+                )
+                console.print(
+                    f"  [cyan]{f.file}:{f.line}[/cyan]  {f.current_model} → [green]{f.suggested_model}{prov_note}[/green]"
+                )
+                console.print(
+                    f"    Savings: [green]${f.monthly_savings:.0f}/mo[/green] | {f.reasoning}"
+                )
+            console.print()
+
+        if caching:
+            console.print("[bold yellow]PROMPT CACHING OPPORTUNITIES[/bold yellow]")
+            for f in caching:
+                console.print(
+                    f"  System prompt in {len(f.locations)} sites — save ~[green]${f.monthly_savings:.0f}/mo[/green]"
+                )
+            console.print()
+
+        if batch:
+            console.print("[bold yellow]BATCH API OPPORTUNITIES[/bold yellow]")
+            for f in batch:
+                console.print(
+                    f"  [cyan]{f.file}[/cyan]: {f.model} × {f.call_count} calls — save ~[green]${f.monthly_savings:.0f}/mo[/green]"
+                )
+            console.print()
+
+        console.print(
+            f"[bold]Total potential savings: [green]${total_savings:.0f}/mo[/green][/bold]"
+        )
+
+
+@app.command()
+def fix(
+    path: str = typer.Argument(".", help="Directory to scan."),
+    volume: str | None = typer.Option(None, "--volume", "-n", help="Calls/month."),
+    config: str | None = typer.Option(None, "--config", "-c", help="Path to config file."),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Preview changes without applying."),
+    provider: str | None = typer.Option(None, "--provider", help="Only fix this provider."),
+    min_savings: float = typer.Option(0, "--min-savings", help="Minimum monthly savings (USD)."),
+    format: str = typer.Option("table", "--format", "-f", help="Output format."),
+) -> None:
+    """Auto-apply model swap recommendations from audit."""
+    from tokenable.config import getEnvVolume, load_config, parseVolume
+    from tokenable.fixer import apply_recommendations
+    from tokenable.models import ModelSwap
+    from tokenable.recommender import detect_smart_alternatives
+    from tokenable.scanner import scan_directory
+
+    cfg = load_config(config)
+    vol = parseVolume(volume) if volume else (getEnvVolume() or 1000)
+    results = scan_directory(path, cfg.ignore if cfg else [])
+
+    if not results:
+        console.print("[yellow]No LLM API calls detected.[/yellow]")
+        raise typer.Exit()
+
+    findings = detect_smart_alternatives(results, vol)
+    if provider:
+        findings = [f for f in findings if f.current_provider.value == provider]
+    if min_savings > 0:
+        findings = [f for f in findings if f.monthly_savings >= min_savings]
+
+    if not findings:
+        console.print("[yellow]No model swap recommendations match your filters.[/yellow]")
+        raise typer.Exit()
+
+    swaps = [
+        ModelSwap(
+            file=f.file,
+            line=f.line,
+            current_model=f.current_model,
+            suggested_model=f.suggested_model,
+            monthly_savings=f.monthly_savings,
+        )
+        for f in findings
+    ]
+    result = apply_recommendations(swaps, path, dry_run)
+
+    if format == "json":
+        import json as json_mod
+
+        typer.echo(json_mod.dumps(result.model_dump(), indent=2))
+    else:
+        verb = "Would apply" if dry_run else "Applied"
+        if result.applied:
+            console.print(f"[green]{verb} {result.total_applied} model swap(s):[/green]\n")
+            for s in result.applied:
+                console.print(
+                    f"  [cyan]{s.file}[/cyan]:{s.line}  [red]{s.from_model}[/red] → [green]{s.to_model}[/green]"
+                )
+        if result.skipped:
+            console.print(f"\n[yellow]Skipped {result.total_skipped}:[/yellow]")
+            for s in result.skipped:
+                console.print(f"  [cyan]{s.file}[/cyan]:{s.line}  [dim]{s.reason}[/dim]")
+        if result.estimated_monthly_savings > 0:
+            console.print(
+                f"\n[bold]Estimated savings: [green]${result.estimated_monthly_savings:.0f}/mo[/green][/bold]"
+            )
+        if dry_run and result.total_applied > 0:
+            console.print("[dim]\nDry run — no files were modified.[/dim]")
+
+
+@app.command()
+def price(
+    provider: str | None = typer.Argument(None, help="Provider name."),
+    model: str | None = typer.Argument(None, help="Model ID."),
+    input_tokens: int | None = typer.Option(None, "--input-tokens", help="Input token count."),
+    output_tokens: int | None = typer.Option(None, "--output-tokens", help="Output token count."),
+    volume: str | None = typer.Option(
+        None, "--volume", "-n", help="Calls/day for monthly projection."
+    ),
+    list_models: bool = typer.Option(False, "--list", help="List current models for a provider."),
+    list_all: bool = typer.Option(False, "--list-all", help="List all models across providers."),
+    format: str = typer.Option("table", "--format", "-f", help="Output format."),
+    compare: str | None = typer.Option(None, "--compare", help="Compare with provider/model."),
+) -> None:
+    """Look up model pricing."""
+    from tokenable.config import parseVolume
+    from tokenable.models import Provider as ProviderEnum
+    from tokenable.providers import calculate_cost, get_all_models, get_model, get_provider_models
+
+    if list_all:
+        models = get_all_models()
+        table = Table(title="All Models")
+        table.add_column("Provider")
+        table.add_column("Model")
+        table.add_column("Input $/M", justify="right")
+        table.add_column("Output $/M", justify="right")
+        table.add_column("Context", justify="right")
+        for m in sorted(models, key=lambda x: (x.provider.value, x.output_cost_per_million)):
+            if m.status.value != "current":
+                continue
+            table.add_row(
+                m.provider.value,
+                m.id,
+                f"${m.input_cost_per_million:.2f}",
+                f"${m.output_cost_per_million:.2f}",
+                f"{m.context_window:,}",
+            )
+        console.print(table)
+        return
+
+    if list_models and provider:
+        try:
+            prov = ProviderEnum(provider)
+        except ValueError:
+            console.print(f"[red]Unknown provider: {provider}[/red]")
+            raise typer.Exit(1)
+        models = get_provider_models(prov)
+        table = Table(title=f"{provider} Models")
+        table.add_column("Model")
+        table.add_column("Input $/M", justify="right")
+        table.add_column("Output $/M", justify="right")
+        table.add_column("Context", justify="right")
+        table.add_column("Status")
+        for m in models:
+            table.add_row(
+                m.id,
+                f"${m.input_cost_per_million:.2f}",
+                f"${m.output_cost_per_million:.2f}",
+                f"{m.context_window:,}",
+                m.status.value,
+            )
+        console.print(table)
+        return
+
+    if not provider or not model:
+        console.print(
+            "[yellow]Usage: tokenable price <provider> <model> [--input-tokens N --output-tokens N][/yellow]"
+        )
+        console.print("[dim]Or: tokenable price --list-all[/dim]")
+        raise typer.Exit(1)
+
+    try:
+        prov = ProviderEnum(provider)
+    except ValueError:
+        console.print(f"[red]Unknown provider: {provider}[/red]")
+        raise typer.Exit(1)
+
+    pricing = get_model(prov, model)
+    if not pricing:
+        console.print(f"[red]Unknown model: {model} for {provider}[/red]")
+        raise typer.Exit(1)
+
+    console.print(f"[bold]{pricing.name}[/bold] ({pricing.provider.value}/{pricing.id})")
+    console.print(f"  Input:  ${pricing.input_cost_per_million:.2f}/M tokens")
+    console.print(f"  Output: ${pricing.output_cost_per_million:.2f}/M tokens")
+    console.print(
+        f"  Context: {pricing.context_window:,} | Max output: {pricing.max_output_tokens:,}"
+    )
+
+    if input_tokens is not None and output_tokens is not None:
+        cost = calculate_cost(pricing, input_tokens, output_tokens)
+        console.print(
+            f"\n  Cost for {input_tokens:,} in / {output_tokens:,} out: [bold]${cost:.6f}[/bold]"
+        )
+        if volume:
+            vol = parseVolume(volume)
+            monthly = cost * vol * 30
+            console.print(f"  Monthly ({vol:,}/day): [bold]${monthly:.2f}/mo[/bold]")
+
+
+@app.command()
+def calibrate(
+    path: str = typer.Argument(".", help="Directory to scan."),
+    provider: str | None = typer.Option(None, "--provider", help="Provider to calibrate from."),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Preview without saving."),
+    days: int = typer.Option(30, "--days", help="Days of usage data to fetch."),
+    format: str = typer.Option("table", "--format", "-f", help="Output format."),
+    config: str | None = typer.Option(None, "--config", "-c", help="Path to config file."),
+) -> None:
+    """Fetch real usage data from provider APIs and compute correction factors."""
+    from tokenable.calibration import fetch_and_calibrate
+
+    result = fetch_and_calibrate(
+        path, provider=provider, days=days, dry_run=dry_run, config_path=config
+    )
+
+    if format == "json":
+        import json as json_mod
+
+        typer.echo(json_mod.dumps(result, indent=2))
+    else:
+        if "error" in result:
+            console.print(f"[red]{result['error']}[/red]")
+            raise typer.Exit(1)
+        if not result.get("models"):
+            console.print("[yellow]No usage data found for calibration.[/yellow]")
+            raise typer.Exit()
+
+        table = Table(title="Calibration Results")
+        table.add_column("Model")
+        table.add_column("Samples", justify="right")
+        table.add_column("Input Ratio", justify="right")
+        table.add_column("Output Ratio", justify="right")
+        table.add_column("Confidence")
+        for key, cal in result.get("models", {}).items():
+            table.add_row(
+                key,
+                str(cal["sample_size"]),
+                f"{cal['input_ratio']:.2f}",
+                f"{cal['output_ratio']:.2f}",
+                cal["confidence"],
+            )
+        console.print(table)
+
+        if dry_run:
+            console.print("[dim]\nDry run — calibration not saved.[/dim]")
+        else:
+            console.print("\n[green]Calibration saved to .tokenable/calibration.json[/green]")
+
+
+@app.command(name="update-pricing")
+def update_pricing(
+    dynamic: bool = typer.Option(False, "--dynamic", help="Fetch latest prices from LiteLLM at runtime."),
+    provider: str | None = typer.Option(None, "--provider", help="Update only this provider."),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Show changes without writing."),
+) -> None:
+    """Check or update pricing data. Use --dynamic to fetch live from LiteLLM."""
+    from tokenable.providers import get_all_providers, get_provider_models
+
+    if not dynamic:
+        # Static mode: just show status
+        console.print("[bold]Pricing Database Status[/bold]\n")
+        table = Table()
+        table.add_column("Provider")
+        table.add_column("Models")
+        table.add_column("Current")
+
+        for prov in get_all_providers():
+            models = get_provider_models(prov)
+            current = [m for m in models if m.status.value == "current"]
+            table.add_row(prov.value, str(len(models)), str(len(current)))
+
+        console.print(table)
+        console.print("\n[dim]Use --dynamic to fetch latest prices from LiteLLM.[/dim]")
+        console.print("[dim]Or upgrade the package: pip install --upgrade tokenable[/dim]")
+        return
+
+    # Dynamic mode: fetch from LiteLLM and update local JSON files
+    from tokenable.pricing_sync import sync_pricing
+
+    console.print("[bold]Fetching latest pricing from LiteLLM...[/bold]\n")
+    try:
+        result = sync_pricing(provider=provider, dry_run=dry_run)
+    except Exception as e:
+        console.print(f"[red]Error fetching pricing: {e}[/red]")
+        raise typer.Exit(1)
+
+    if result["total_changes"] == 0:
+        console.print("[green]All prices are up to date.[/green]")
+    else:
+        table = Table(title="Price Updates")
+        table.add_column("Model")
+        table.add_column("Field")
+        table.add_column("Old", justify="right")
+        table.add_column("New", justify="right")
+        for change in result["changes"]:
+            table.add_row(change["model"], change["field"], f"${change['old']}", f"${change['new']}")
+        console.print(table)
+
+        if dry_run:
+            console.print(f"\n[dim]Dry run — {result['total_changes']} change(s) would be applied.[/dim]")
+        else:
+            console.print(f"\n[green]✓ Updated {result['total_changes']} price(s). Changes take effect immediately.[/green]")