snowglobe-cli 0.1.0__py3-none-any.whl

snowglobe/cli/cost.py

@@ -0,0 +1,291 @@
+import typer
+import pandas as pd
+from snowglobe.core.cost_service import CostService
+from snowglobe.output import cli
+
+cost_app = typer.Typer(
+    help="Inspect Snowflake costs — compute, storage, AI, budgets, and more",
+    no_args_is_help=True,
+)
+
+
+def _get_cost_service(ctx: typer.Context) -> CostService:
+    return CostService(ctx.obj)
+
+
+def _export_csv(df, csv_path: str | None) -> bool:
+    if csv_path:
+        df.to_csv(csv_path, index=False)
+        typer.secho(f"Exported to: {csv_path}", fg=typer.colors.GREEN)
+        return True
+    return False
+
+
+def _print_note(note: str | None) -> None:
+    if note:
+        typer.secho(f"⚠  {note}", fg=typer.colors.YELLOW)
+
+
+@cost_app.command()
+def summary(
+    ctx: typer.Context,
+    days: int = typer.Option(30, help="Number of days to analyze"),
+    csv: str = typer.Option(None, help="Export to CSV file path"),
+    refresh: bool = typer.Option(False, help="Force fresh query to Snowflake"),
+):
+    """Account cost summary by service type."""
+    cost_service = _get_cost_service(ctx)
+    df, cache_age = cost_service.get_account_summary(days, refresh=refresh)
+    if df.empty:
+        typer.echo("No cost data found.")
+        return
+    if _export_csv(df, csv):
+        return
+    total = df["CREDITS"].sum()
+    typer.secho(f"\nTotal: {total:,.2f} credits ({days} days)", fg=typer.colors.GREEN, bold=True)
+    typer.echo("")
+    for _, row in df.iterrows():
+        bar_len = int(row["PCT"] / 2)
+        bar = "█" * bar_len
+        typer.echo(f"  {row['SERVICE_TYPE']:<40} {row['CREDITS']:>10,.2f}  {row['PCT']:>5.1f}%  {bar}")
+    typer.echo("")
+
+
+@cost_app.command()
+def warehouses(
+    ctx: typer.Context,
+    days: int = typer.Option(30, help="Number of days to analyze"),
+    csv: str = typer.Option(None, help="Export to CSV file path"),
+    refresh: bool = typer.Option(False, help="Force fresh query to Snowflake"),
+):
+    """Cost breakdown per warehouse."""
+    cost_service = _get_cost_service(ctx)
+    df, _ = cost_service.get_warehouse_breakdown(days, refresh=refresh)
+    if df.empty:
+        typer.echo("No warehouse data found.")
+        return
+    if _export_csv(df, csv):
+        return
+    cli.print_table(df, title=f"Warehouse Costs ({days} days)")
+
+
+@cost_app.command()
+def users(
+    ctx: typer.Context,
+    days: int = typer.Option(7, help="Number of days to analyze (max 7 recommended)"),
+    csv: str = typer.Option(None, help="Export to CSV file path"),
+    refresh: bool = typer.Option(False, help="Force fresh query to Snowflake"),
+):
+    """Complete cost per user — warehouse + AI services."""
+    cost_service = _get_cost_service(ctx)
+    df, _, note = cost_service.get_user_breakdown(min(days, 7), refresh=refresh)
+    if df.empty:
+        typer.echo("No user data found.")
+        return
+    if _export_csv(df, csv):
+        return
+    _print_note(note)
+    cli.print_table(df, title=f"User Cost Attribution ({days} days)")
+
+
+@cost_app.command()
+def ai(
+    ctx: typer.Context,
+    days: int = typer.Option(30, help="Number of days to analyze"),
+    csv: str = typer.Option(None, help="Export to CSV file path"),
+    refresh: bool = typer.Option(False, help="Force fresh query to Snowflake"),
+):
+    """AI/ML token costs by service type."""
+    cost_service = _get_cost_service(ctx)
+    df, _, note = cost_service.get_ai_costs(days, refresh=refresh)
+    if df.empty:
+        typer.echo("No AI usage found.")
+        return
+    if _export_csv(df, csv):
+        return
+    _print_note(note)
+    total = df["TOTAL_CREDITS"].astype(float).sum()
+    typer.secho(f"\nTotal AI credits: {total:,.2f} ({days} days)", fg=typer.colors.GREEN, bold=True)
+    typer.echo("")
+    for _, row in df.iterrows():
+        bar_len = int(row["PCT"] / 2)
+        bar = "█" * bar_len
+        typer.echo(f"  {row['SERVICE']:<30} {float(row['TOTAL_CREDITS']):>10,.2f}  {row['PCT']:>5.1f}%  {bar}")
+    typer.echo("")
+
+
+@cost_app.command(name="ai-users")
+def ai_users(
+    ctx: typer.Context,
+    days: int = typer.Option(30, help="Number of days to analyze"),
+    csv: str = typer.Option(None, help="Export to CSV file path"),
+    refresh: bool = typer.Option(False, help="Force fresh query to Snowflake"),
+):
+    """AI/ML token costs per user with service breakdown."""
+    cost_service = _get_cost_service(ctx)
+    df, _, note = cost_service.get_ai_costs_by_user(days, refresh=refresh)
+    if df.empty:
+        typer.echo("No AI usage found.")
+        return
+    if _export_csv(df, csv):
+        return
+    _print_note(note)
+    cli.print_table(df, title=f"AI Token Costs by User ({days} days)")
+
+
+@cost_app.command()
+def services(
+    ctx: typer.Context,
+    days: int = typer.Option(30, help="Number of days to analyze"),
+    csv: str = typer.Option(None, help="Export to CSV file path"),
+    refresh: bool = typer.Option(False, help="Force fresh query to Snowflake"),
+):
+    """Non-warehouse service costs — pipes, tasks, SPCS, clustering."""
+    cost_service = _get_cost_service(ctx)
+    df, _ = cost_service.get_service_breakdown(days, refresh=refresh)
+    if df.empty:
+        typer.echo("No service cost data found.")
+        return
+    if _export_csv(df, csv):
+        return
+    cli.print_table(df, title=f"Service Resource Costs ({days} days)")
+
+
+@cost_app.command()
+def queries(
+    ctx: typer.Context,
+    days: int = typer.Option(7, help="Number of days of query history"),
+    limit: int = typer.Option(10, help="Number of queries to return"),
+    sort_by: str = typer.Option("credits", help="Sort by: credits or bytes"),
+    csv: str = typer.Option(None, help="Export to CSV file path"),
+    refresh: bool = typer.Option(False, help="Force fresh query to Snowflake"),
+):
+    """Top expensive individual queries by attributed credits."""
+    cost_service = _get_cost_service(ctx)
+    df, _, note = cost_service.get_top_queries(days, limit=limit, sort_by=sort_by, refresh=refresh)
+    if df.empty:
+        typer.echo("No query data found.")
+        return
+    if _export_csv(df, csv):
+        return
+    _print_note(note)
+    cli.print_table(df, title=f"Top Expensive Queries ({days} days)")
+
+
+@cost_app.command()
+def trend(
+    ctx: typer.Context,
+    days: int = typer.Option(30, help="Number of days for trend analysis"),
+    csv: str = typer.Option(None, help="Export to CSV file path"),
+    refresh: bool = typer.Option(False, help="Force fresh query to Snowflake"),
+):
+    """Daily spend trend with day-over-day delta and 7-day rolling average."""
+    cost_service = _get_cost_service(ctx)
+    df, cache_age = cost_service.get_daily_trend(days, refresh=refresh)
+    if df.empty:
+        typer.echo("No trend data found.")
+        return
+    if _export_csv(df, csv):
+        return
+
+    total = df["CREDITS"].sum()
+    avg_daily = df["CREDITS"].mean()
+    typer.secho(f"\nTotal: {total:,.2f} credits | Avg daily: {avg_daily:,.2f}", fg=typer.colors.GREEN, bold=True)
+    typer.echo("")
+    typer.echo(f"  {'DATE':<12} {'CREDITS':>10} {'DELTA %':>9} {'7D AVG':>10}  {'TREND'}")
+    typer.echo(f"  {'─' * 12} {'─' * 10} {'─' * 9} {'─' * 10}  {'─' * 20}")
+    max_credits = df["CREDITS"].max() if not df.empty else 1
+    for _, row in df.iterrows():
+        bar_len = int((row["CREDITS"] / max_credits) * 20) if max_credits > 0 else 0
+        bar = "▓" * bar_len
+        delta_str = f"{row['DELTA_PCT']:+.1f}%" if pd.notna(row["DELTA_PCT"]) else "    —"
+        avg_str = f"{row['ROLLING_7D_AVG']:,.2f}" if pd.notna(row["ROLLING_7D_AVG"]) else "—"
+        typer.echo(f"  {str(row['DATE']):<12} {row['CREDITS']:>10,.2f} {delta_str:>9} {avg_str:>10}  {bar}")
+    typer.echo("")
+
+
+@cost_app.command()
+def storage(
+    ctx: typer.Context,
+    days: int = typer.Option(30, help="Number of days to average storage over"),
+    csv: str = typer.Option(None, help="Export to CSV file path"),
+    refresh: bool = typer.Option(False, help="Force fresh query to Snowflake"),
+):
+    """Per-database storage breakdown with estimated monthly cost."""
+    cost_service = _get_cost_service(ctx)
+    df, _ = cost_service.get_storage_usage(days, refresh=refresh)
+    if df.empty:
+        typer.echo("No storage data found.")
+        return
+    if _export_csv(df, csv):
+        return
+
+    total_tb = df["TOTAL_TB"].sum()
+    total_cost = df["EST_MONTHLY_COST"].sum()
+    rate = cost_service.get_storage_rate()
+    typer.secho(f"\nTotal storage: {total_tb:,.4f} TB | Est. monthly: ${total_cost:,.2f}", fg=typer.colors.GREEN, bold=True)
+    rate_source = "contracted rate" if rate != 23.0 else "on-demand default"
+    typer.echo(f"(Estimated at ${rate:.2f}/TB/month — {rate_source})")
+    typer.echo("")
+    display_df = df[["DATABASE_NAME", "TOTAL_TB", "EST_MONTHLY_COST"]].copy()
+    display_df = display_df[display_df["TOTAL_TB"] > 0]
+    if not display_df.empty:
+        cli.print_table(display_df, title=f"Storage by Database ({days}-day avg)")
+
+
+@cost_app.command()
+def budget(
+    ctx: typer.Context,
+    csv: str = typer.Option(None, help="Export to CSV file path"),
+):
+    """Snowflake-native budget status and spending history."""
+    cost_service = _get_cost_service(ctx)
+    df, error = cost_service.get_budget_status()
+    if error:
+        typer.secho(error, fg=typer.colors.YELLOW)
+        return
+    if df.empty:
+        typer.echo("No budget spending history found.")
+        return
+    if _export_csv(df, csv):
+        return
+    cli.print_table(df, title="Budget Spending History")
+
+
+@cost_app.command()
+def replication(
+    ctx: typer.Context,
+    days: int = typer.Option(30, help="Number of days to analyze"),
+    csv: str = typer.Option(None, help="Export to CSV file path"),
+    refresh: bool = typer.Option(False, help="Force fresh query to Snowflake"),
+):
+    """Replication costs by replication group."""
+    cost_service = _get_cost_service(ctx)
+    df, _ = cost_service.get_replication_costs(days, refresh=refresh)
+    if df.empty:
+        typer.echo("No replication cost data found.")
+        return
+    if _export_csv(df, csv):
+        return
+    cli.print_table(df, title=f"Replication Costs ({days} days)")
+
+
+@cost_app.command(name="mv")
+def materialized_views(
+    ctx: typer.Context,
+    days: int = typer.Option(30, help="Number of days to analyze"),
+    csv: str = typer.Option(None, help="Export to CSV file path"),
+    refresh: bool = typer.Option(False, help="Force fresh query to Snowflake"),
+):
+    """Materialized view refresh costs."""
+    cost_service = _get_cost_service(ctx)
+    df, _ = cost_service.get_materialized_view_costs(days, refresh=refresh)
+    if df.empty:
+        typer.echo("No materialized view cost data found.")
+        return
+    if _export_csv(df, csv):
+        return
+    total = df["CREDITS"].sum() if "CREDITS" in df.columns else 0
+    typer.secho(f"\nTotal MV refresh credits: {total:,.2f}", fg=typer.colors.GREEN, bold=True)
+    typer.echo("")
+    cli.print_table(df, title=f"Materialized View Costs ({days} days)")

snowglobe/cli/debug.py

@@ -0,0 +1,265 @@
+import typer
+from pathlib import Path
+from typing import Callable, Optional, Protocol
+
+debug_app = typer.Typer(
+    help="Diagnose configuration and connectivity issues",
+    no_args_is_help=False,
+)
+
+
+class DiagnosticsReporter(Protocol):
+    """
+    Sink for diagnostics output. Each frontend (CLI, TUI, test) supplies one.
+
+    Levels:
+      header — top banner / separator
+      step   — "[n/total] label"
+      ok     — success line for the current check
+      fail   — failure line + optional hint
+      info   — supplementary detail or remediation tip
+      done   — final summary line at the end of a successful run
+    """
+    def header(self, msg: str) -> None: ...
+    def step(self, n: int, total: int, label: str) -> None: ...
+    def ok(self, msg: str) -> None: ...
+    def fail(self, msg: str, hint: str = "") -> None: ...
+    def info(self, msg: str) -> None: ...
+    def done(self, msg: str) -> None: ...
+
+
+class TyperReporter:
+    """Default reporter — renders coloured output via typer."""
+
+    def header(self, msg: str) -> None:
+        typer.echo(f"\n{msg}")
+        typer.echo("=" * 40)
+
+    def step(self, n: int, total: int, label: str) -> None:
+        typer.echo(f"\n[{n}/{total}] {label}")
+
+    def ok(self, msg: str) -> None:
+        typer.secho(f"  ✓ {msg}", fg=typer.colors.GREEN)
+
+    def fail(self, msg: str, hint: str = "") -> None:
+        typer.secho(f"  ✗ {msg}", fg=typer.colors.RED)
+        if hint:
+            typer.secho(f"    → {hint}", fg=typer.colors.YELLOW)
+
+    def info(self, msg: str) -> None:
+        typer.secho(f"    {msg}", dim=True)
+
+    def done(self, msg: str) -> None:
+        typer.echo("\n" + "=" * 40)
+        typer.secho(msg, fg=typer.colors.GREEN, bold=True)
+        typer.echo("")
+
+
+class CallableReporter:
+    """
+    Reporter that delegates every line to a single callback `(level, msg)`.
+
+    Use from the TUI to route output into a RichLog or any other sink:
+
+        reporter = CallableReporter(lambda level, msg: my_log.write(level, msg))
+        run_diagnostics(reporter=reporter)
+    """
+
+    def __init__(self, write: Callable[[str, str], None]):
+        self._write = write
+
+    def header(self, msg: str) -> None:
+        self._write("header", msg)
+
+    def step(self, n: int, total: int, label: str) -> None:
+        self._write("step", f"[{n}/{total}] {label}")
+
+    def ok(self, msg: str) -> None:
+        self._write("ok", msg)
+
+    def fail(self, msg: str, hint: str = "") -> None:
+        self._write("fail", msg)
+        if hint:
+            self._write("info", f"→ {hint}")
+
+    def info(self, msg: str) -> None:
+        self._write("info", msg)
+
+    def done(self, msg: str) -> None:
+        self._write("done", msg)
+
+
+def run_diagnostics(
+    profile_name: str = "default",
+    verbose: bool = False,
+    reporter: Optional[DiagnosticsReporter] = None,
+) -> bool:
+    """
+    Run all diagnostic checks and report results via the supplied reporter.
+
+    Returns True if every check passed, False otherwise. Does not raise on
+    a failed check — callers decide how to react (CLI exits, TUI just shows
+    the log).
+    """
+    r = reporter or TyperReporter()
+    TOTAL = 8
+
+    r.header("Snowglobe Connection Diagnostics")
+
+    # --- Step 1: Config file exists ---
+    r.step(1, TOTAL, "Config file")
+    from snowglobe.config.loader import SnowglobeConfig
+    config_path = SnowglobeConfig.CONFIG_PATH
+
+    if not config_path.exists():
+        r.fail(f"Config not found at {config_path}")
+        r.info(f"Create {config_path} with your Snowflake profiles.")
+        r.info("See: snowglobe/config.yml for an example.")
+        return False
+    r.ok(f"Found {config_path}")
+
+    # --- Step 2: Valid YAML ---
+    r.step(2, TOTAL, "YAML parsing")
+    try:
+        import yaml
+        with open(config_path, "r") as f:
+            raw = yaml.safe_load(f)
+        if not isinstance(raw, dict):
+            r.fail("Config file is not a YAML mapping")
+            return False
+        r.ok(f"Valid YAML with {len(raw)} profile(s): {', '.join(raw.keys())}")
+    except yaml.YAMLError as e:
+        r.fail(f"YAML parse error: {e}")
+        return False
+
+    # --- Step 3: Profile exists ---
+    r.step(3, TOTAL, f"Profile '{profile_name}'")
+    try:
+        config = SnowglobeConfig()
+        profile = config.get_profile(profile_name)
+        r.ok(f"Profile '{profile_name}' loaded")
+    except Exception as e:
+        r.fail(f"Profile not found: {e}")
+        try:
+            r.info(f"Available profiles: {', '.join(config.list_profiles())}")
+        except Exception:
+            pass
+        return False
+
+    # --- Step 4: Required fields ---
+    r.step(4, TOTAL, "Required fields")
+    required = ["account", "user"]
+    missing = [f for f in required if not profile.get(f)]
+    has_auth = bool(profile.get("password") or profile.get("private_key_path"))
+
+    if missing:
+        r.fail(f"Missing required fields: {', '.join(missing)}")
+        return False
+    if not has_auth:
+        r.fail("No auth method — need 'password' or 'private_key_path'")
+        return False
+    r.ok(f"account={profile['account']}, user={profile['user']}")
+
+    # --- Step 5: Auth credentials resolve ---
+    r.step(5, TOTAL, "Auth credentials")
+    auth_method = "key_pair" if profile.get("private_key_path") else "password"
+
+    if auth_method == "key_pair":
+        key_path = Path(profile["private_key_path"]).expanduser()
+        if not key_path.exists():
+            r.fail(f"Key file not found: {key_path}")
+            r.info("Check that private_key_path points to an existing .pem file")
+            return False
+        r.ok(f"Key pair auth — key file exists at {key_path}")
+
+        try:
+            from cryptography.hazmat.primitives import serialization
+            pwd = profile.get("private_key_pwd")
+            with key_path.open("rb") as f:
+                serialization.load_pem_private_key(
+                    f.read(),
+                    password=pwd.encode() if pwd else None,
+                )
+            r.ok("Key file is a valid PEM private key")
+        except Exception as e:
+            r.fail(f"Key file parse error: {e}")
+            r.info("Ensure the key is in PEM format and the passphrase (if any) is correct")
+            return False
+    else:
+        password = profile.get("password", "")
+        if password.startswith("$") or not password:
+            r.fail(f"Password appears unresolved: '{password}'")
+            r.info("Check that the environment variable is set")
+            return False
+        r.ok("Password auth — credentials present")
+
+    # --- Step 6: Snowflake connectivity ---
+    r.step(6, TOTAL, "Snowflake connection")
+    try:
+        from snowglobe.snowflake.connection import SnowflakeReadOnly
+        sf = SnowflakeReadOnly(
+            account=profile["account"],
+            user=profile["user"],
+            role=profile.get("role"),
+            warehouse=profile.get("warehouse"),
+            password=profile.get("password"),
+            private_key_path=profile.get("private_key_path"),
+            private_key_pwd=profile.get("private_key_pwd"),
+        )
+        with sf:
+            r.ok("Connected to Snowflake successfully")
+
+            # --- Step 7: Role ---
+            r.step(7, TOTAL, "Role")
+            result = sf.query("SELECT CURRENT_ROLE() AS role")
+            current_role = result[0]["ROLE"] if result else None
+            if current_role:
+                r.ok(f"Active role: {current_role}")
+            else:
+                r.fail("Could not determine current role")
+
+            # --- Step 8: Warehouse ---
+            r.step(8, TOTAL, "Warehouse")
+            result = sf.query("SELECT CURRENT_WAREHOUSE() AS wh")
+            current_wh = result[0]["WH"] if result else None
+            if current_wh:
+                r.ok(f"Active warehouse: {current_wh}")
+            else:
+                r.fail("No warehouse active", hint="Set 'warehouse' in your profile or run USE WAREHOUSE")
+
+    except Exception as e:
+        r.fail(f"Connection failed: {e}")
+        error_str = str(e).lower()
+        if "incorrect username or password" in error_str:
+            r.info("Check your username and password in the profile")
+        elif "account" in error_str:
+            r.info(f"Verify account identifier: {profile['account']}")
+            r.info("Format should be: <orgname>-<accountname> or <locator>.<region>.<cloud>")
+        elif "private key" in error_str:
+            r.info("Key pair auth failed — check key file and passphrase")
+        elif "timeout" in error_str or "could not connect" in error_str:
+            r.info("Network issue — check firewall, VPN, or proxy settings")
+        else:
+            r.info("See Snowflake documentation for connection troubleshooting")
+        return False
+
+    r.done("All checks passed.")
+    return True
+
+
+@debug_app.callback(invoke_without_command=True)
+def debug(
+    ctx: typer.Context,
+    profile_name: Optional[str] = typer.Option(None, "--profile", help="Profile to test (overrides global --profile)"),
+):
+    """
+    Run connection diagnostics.
+
+    Checks config file, credentials, and Snowflake connectivity
+    step by step, reporting exactly where things fail.
+    """
+    context = ctx.obj
+    name = profile_name or (context.profile_name if context else "default")
+    verbose = context.verbose if context else False
+    if not run_diagnostics(profile_name=name, verbose=verbose):
+        raise typer.Exit(1)

snowglobe/cli/diff.py

@@ -0,0 +1,34 @@
+import typer
+
+diff_app = typer.Typer(
+    help="Compare Snowflake state over time",
+    no_args_is_help=True,
+)
+
+
+@diff_app.command()
+def access(
+    ctx: typer.Context,
+    days: int = typer.Option(
+        None, "--days",
+        help="Compare against N days ago. Default: since the last refresh.",
+    ),
+    output: str = typer.Option(
+        "text", "--output",
+        help="Output format: text, json",
+    ),
+):
+    """
+    Show access changes (grants, role edges, user assignments) since the
+    last refresh, or in the last `--days` days.
+    """
+    from snowglobe.core.access_service import AccessService
+    from snowglobe.output import cli
+
+    service = AccessService(ctx.obj)
+    result = service.detect_drift(days=days)
+
+    if output == "json":
+        cli.format_json(result)
+    else:
+        typer.echo(cli.format_drift_text(result))

snowglobe/cli/optimizer.py

@@ -0,0 +1,91 @@
+import typer
+from snowglobe.core.optimizer import QueryOptimizerService
+from snowglobe.core.query_service import QueryService
+from snowglobe.output import cli
+
+opt_app = typer.Typer(
+    help="Query optimizer — analyze and suggest improvements for Snowflake queries",
+    no_args_is_help=True,
+)
+
+
+@opt_app.command()
+def query(
+    ctx: typer.Context,
+    query_id: str = typer.Option(..., help="Snowflake query ID to analyze"),
+    no_ai: bool = typer.Option(False, "--no-ai", help="Skip AI analysis"),
+    model: str = typer.Option("claude-haiku-4-5", help="Cortex AI model for suggestions"),
+):
+    """
+    Analyze a query and provide optimization suggestions.
+    Shows Snowflake-native insights, operator analysis, and optionally AI suggestions.
+    """
+    context = ctx.obj
+    optimizer_service = QueryOptimizerService(context)
+    optimizer_service.collect_query_profile(query_id)
+    optimizer_service.analyze_query()
+
+    # 1. Snowflake-native insights (primary)
+    insights = optimizer_service.collect_insights()
+    if insights:
+        typer.echo(cli.format_query_insights(query_id, insights))
+
+    # 2. Local rule-based suggestions
+    opt_suggestions = optimizer_service.suggestions()
+    typer.echo(cli.format_optimizer_suggestions(query_id, opt_suggestions.suggestions))
+
+    # 3. Operator tree + scoring
+    tree = optimizer_service.build_operator_tree()
+    scores = optimizer_service.score()
+    cli.print_operator_tree(tree, scores)
+
+    # 4. Cost attribution
+    opt_cost_attribution = optimizer_service.cost_attribution()
+    typer.echo(cli.format_cost_attribution(opt_cost_attribution))
+
+    # 5. Expensive operators
+    opt_exp = optimizer_service.expensive_operators()
+    typer.echo(cli.format_expensive_operators(opt_exp))
+
+    # 6. AI suggestion (optional)
+    if not no_ai:
+        typer.echo("\nGenerating AI suggestions...")
+        ai = optimizer_service.ai_suggestion(model=model)
+        typer.echo(ai)
+
+
+@opt_app.command()
+def top_queries(
+    ctx: typer.Context,
+    days: int = typer.Option(7, help="Number of days of query history"),
+    cost_type: str = typer.Option("credits", help="Sort query history by: credits, bytes"),
+    limit: int = typer.Option(10, help="Number of top queries to analyze"),
+    refresh_state: bool = typer.Option(False, help="Refresh state from Snowflake"),
+    analyze: bool = typer.Option(False, help="Run optimizer analysis on each query"),
+):
+    """
+    List top expensive queries, optionally with optimization analysis.
+    """
+    context = ctx.obj
+    query_service = QueryService(context, days)
+    output = query_service.inspect_query_history(
+        refresh_state=refresh_state,
+        cost_type=cost_type,
+        limit=limit,
+    )
+    cli.print_table(output, title=f"Most expensive queries by: {cost_type}")
+
+    if analyze:
+        for query_id in output["query_id"]:
+            typer.echo(f"\n{'═' * 60}")
+            typer.echo(f"Analyzing: {query_id}")
+            typer.echo(f"{'═' * 60}")
+
+            optimizer_service = QueryOptimizerService(context)
+            try:
+                optimizer_service.collect_query_profile(query_id)
+                optimizer_service.analyze_query()
+                opt_result = optimizer_service.suggestions()
+                typer.echo(cli.format_optimizer_suggestions(query_id, opt_result.suggestions))
+            except Exception as e:
+                typer.secho(f"  Could not analyze: {e}", fg=typer.colors.YELLOW)