snowglobe-cli 0.1.0__py3-none-any.whl

snowglobe/cli/prompts.py

@@ -0,0 +1,161 @@
+__all__ = [
+    "resolve_access_inputs"
+]
+
+import sys
+import typer
+from prompt_toolkit import PromptSession
+from prompt_toolkit.completion import WordCompleter, FuzzyCompleter
+from snowglobe.models.privilege import Privilege, privileges_for_object_type
+from snowglobe.models.access import ObjectType
+
+
+def is_interactive() -> bool:
+    """Return True if stdin is a TTY (interactive terminal)."""
+    return sys.stdin.isatty()
+
+
+def prompt(label: str, session: PromptSession, items: list[str], strict: bool = False, output: bool = False):
+    word = WordCompleter(items, ignore_case=True, sentence=True)
+    fuzzy = FuzzyCompleter(word)
+
+    def get_value(text):
+        value = session.prompt(
+            label,
+            completer=text,
+            complete_while_typing=True,
+        ).strip()
+        return value
+
+    value = get_value(fuzzy)
+    if not value and strict:
+        typer.secho("Field required!", fg=typer.colors.YELLOW)
+        value = get_value(fuzzy)
+    elif value not in items and strict:
+        typer.secho(f"{label} not found!", fg=typer.colors.YELLOW)
+        value = get_value(fuzzy)
+
+    if output:
+        typer.secho(f"{label} {value}", fg=typer.colors.GREEN)
+    return value
+
+
+def resolve_access_inputs(
+    *,
+    username,
+    role,
+    object_type,
+    object_name,
+    privilege,
+    user_graph,
+    role_graph,
+    grants,
+    object_index=None,
+) -> dict:
+    """
+    Resolve access query inputs. If all required args are provided, returns
+    immediately (headless-safe). If args are missing and stdin is a TTY,
+    prompts interactively. If args are missing and stdin is NOT a TTY,
+    raises an error with a clear message.
+    """
+
+    # Inspect type: user or role
+    if username and not role:
+        inspect_type = "user"
+    elif role and not username:
+        inspect_type = "role"
+    else:
+        inspect_type = None
+
+    # Inputs
+    resolved_inputs = {
+        "inspect_type": inspect_type,
+        "username": username if username else None,
+        "role": role if role else None,
+        "object_type": object_type if object_type else None,
+        "object_name": object_name.upper() if object_name else None,
+        "database": object_name.split(".", 1)[0] if object_name else None,
+        "privilege": privilege if privilege else None
+    }
+
+    # Return resolved inputs if all provided (headless-safe path)
+    if all([username or role, object_type, object_name, privilege]):
+        return resolved_inputs
+
+    # In headless mode, fail fast with a clear error
+    if not is_interactive():
+        missing = []
+        if not (username or role):
+            missing.append("--username or --role")
+        if not object_type:
+            missing.append("--object-type")
+        if not object_name:
+            missing.append("--object-name")
+        if not privilege:
+            missing.append("--privilege")
+        typer.secho(
+            f"Error: Missing required arguments: {', '.join(missing)}. "
+            "All arguments must be provided in non-interactive (headless) mode.",
+            fg=typer.colors.RED
+        )
+        raise typer.Exit(1)
+
+    # Interactive prompts for missing inputs
+    session = PromptSession()
+    if not inspect_type:
+        choice = prompt("Inspect type (User or Role): ", session, ["User", "Role"])
+        if choice.lower().startswith("u"):
+            inspect_type = "user"
+            resolved_inputs["inspect_type"] = "user"
+        elif choice.lower().startswith("r"):
+            inspect_type = "role"
+            resolved_inputs["inspect_type"] = "role"
+        else:
+            typer.secho("Please choose 'User' or 'Role'. Exiting.", fg=typer.colors.RED)
+            raise typer.Exit(1)
+
+    if inspect_type == "user" and not username:
+        items = list(user_graph.assigned_roles.keys())
+        username = prompt("User: ", session, items, strict=True)
+        resolved_inputs["username"] = username
+
+    elif inspect_type == "role" and not role:
+        items = list(role_graph.roles.keys())
+        role = prompt("Role: ", session, items, strict=True)
+        resolved_inputs["role"] = role
+
+    if not object_type:
+        items = [ot.value for ot in ObjectType]
+        object_type = prompt("Select object type ", session, items, strict=True)
+        typer.secho(f"Object type: {object_type}", fg=typer.colors.GREEN)
+        resolved_inputs['object_type'] = object_type
+
+    if not object_name:
+        # Use object_index for completions if available, fall back to grants
+        if object_index and object_type in object_index:
+            items = object_index[object_type]
+        elif object_index and object_type.upper() in object_index:
+            items = object_index[object_type.upper()]
+        else:
+            items = sorted(set(g.object.name for g in grants if g.object.object_type.value == object_type))
+        object_name = prompt("Object name (FQN): ", session, items, strict=False)
+        if not object_name or not object_name.strip():
+            typer.secho("Object name is required.", fg=typer.colors.RED)
+            raise typer.Exit(1)
+        resolved_inputs['object_name'] = object_name.upper()
+        resolved_inputs["database"] = object_name.split(".", 1)[0]
+
+    if not privilege:
+        items = _privileges_for_object_type(object_type)
+        privilege = prompt("Privilege to inspect : ", session, items, strict=False)
+        if not privilege or not privilege.strip():
+            typer.secho("Privilege is required.", fg=typer.colors.RED)
+            raise typer.Exit(1)
+        resolved_inputs['privilege'] = privilege.upper()
+
+    return resolved_inputs
+
+
+# Privilege suggestions per object type now live in snowglobe.models.privilege
+# (used by both the CLI and the TUI). Imported above as `privileges_for_object_type`.
+_privileges_for_object_type = privileges_for_object_type

snowglobe/cli/report.py

@@ -0,0 +1,91 @@
+import typer
+from datetime import date
+
+report_app = typer.Typer(
+    help="Generate summarized reports — cost, AI, storage, queries",
+    no_args_is_help=True,
+)
+
+
+def _default_output_path() -> str:
+    return f"snowglobe_report_{date.today().isoformat()}.md"
+
+
+@report_app.command()
+def full(
+    ctx: typer.Context,
+    days: int = typer.Option(30, help="Number of days to cover"),
+    top: int = typer.Option(10, help="Number of top queries to include"),
+    output: str = typer.Option(None, "--output", "-o", help="Output file path (default: snowglobe_report_DATE.md)"),
+):
+    """Generate a full report: cost summary, AI costs, storage, top queries."""
+    from snowglobe.core.report_service import ReportService
+
+    output_path = output or _default_output_path()
+    context = ctx.obj
+
+    typer.echo(f"\nGenerating full report ({days} days)...")
+    service = ReportService(context)
+    _, data = service.generate_and_save(output_path, days=days, top_n=top)
+
+    # Print terminal summary
+    typer.echo(service.terminal_summary(data))
+    typer.secho(f"  Report saved: {output_path}", fg=typer.colors.GREEN, bold=True)
+    typer.echo("")
+
+
+@report_app.command()
+def cost(
+    ctx: typer.Context,
+    days: int = typer.Option(30, help="Number of days to cover"),
+    output: str = typer.Option(None, "--output", "-o", help="Output file path"),
+):
+    """Generate a cost-focused report: summary, AI, storage."""
+    from snowglobe.core.report_service import ReportService
+
+    output_path = output or f"snowglobe_cost_{date.today().isoformat()}.md"
+    context = ctx.obj
+
+    typer.echo(f"\nGenerating cost report ({days} days)...")
+    service = ReportService(context)
+    data = service.generate_full_report(days=days, top_n=0)
+    # Clear queries for cost-only report
+    data["top_queries"] = []
+    markdown = service.render_markdown(data)
+
+    from pathlib import Path
+    Path(output_path).write_text(markdown)
+
+    typer.echo(service.terminal_summary(data))
+    typer.secho(f"  Report saved: {output_path}", fg=typer.colors.GREEN, bold=True)
+    typer.echo("")
+
+
+@report_app.command()
+def queries(
+    ctx: typer.Context,
+    days: int = typer.Option(7, help="Number of days to cover"),
+    top: int = typer.Option(10, help="Number of queries to include"),
+    output: str = typer.Option(None, "--output", "-o", help="Output file path"),
+):
+    """Generate a top-queries report with optimization details."""
+    from snowglobe.core.cost_service import CostService
+    from snowglobe.output import cli
+
+    context = ctx.obj
+    cost_service = CostService(context)
+
+    typer.echo(f"\nFetching top {top} queries ({days} days)...")
+    df, _, _ = cost_service.get_top_queries(days=days, limit=top)
+
+    if df.empty:
+        typer.echo("  No query data found.")
+        return
+
+    # Terminal output
+    cli.print_table(df, title=f"Top {top} Expensive Queries ({days} days)")
+
+    # Save to file if requested
+    if output:
+        df.to_csv(output, index=False)
+        typer.secho(f"\n  Exported to: {output}", fg=typer.colors.GREEN)