kctl-sentry 0.6.3__py3-none-any.whl

kctl_sentry/__init__.py

@@ -0,0 +1,3 @@
+"""kctl-sentry: Sentry error tracking management."""
+
+__version__ = "0.6.3"

kctl_sentry/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as python -m kctl_sentry."""
+
+from kctl_sentry.cli import _run
+
+_run()

kctl_sentry/cli.py

@@ -0,0 +1,136 @@
+"""Main CLI entry point for kctl-sentry."""
+
+from __future__ import annotations
+
+
+from typing import Annotated
+
+import typer
+from kctl_lib import KctlError, handle_cli_error
+
+from kctl_sentry import __version__
+from kctl_sentry.commands.alerts import app as alerts_app
+from kctl_sentry.commands.config_cmd import app as config_app
+from kctl_sentry.commands.dashboard import app as dashboard_app
+from kctl_sentry.commands.environments import app as environments_app
+from kctl_sentry.commands.health import app as health_app
+from kctl_sentry.commands.issues import app as issues_app
+from kctl_sentry.commands.projects import app as projects_app
+from kctl_sentry.commands.releases import app as releases_app
+from kctl_sentry.commands.stats import app as stats_app
+from kctl_sentry.commands.teams import app as teams_app
+from kctl_sentry.core.callbacks import AppContext
+from kctl_sentry.core.plugins import discover_and_load_plugins
+from kctl_sentry.commands.skill_cmd import app as skill_app
+from kctl_sentry.commands.doctor_cmd import app as doctor_app
+from kctl_lib.self_update import notify_if_outdated
+from kctl_lib.tui import add_tui_command
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"kctl-sentry {__version__}")
+        raise typer.Exit()
+
+
+app = typer.Typer(
+    name="kctl-sentry",
+    help="Kodemeio Sentry CLI — error triage, release tracking, and project management.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+    pretty_exceptions_enable=False,
+)
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    json_output: Annotated[bool, typer.Option("--json", help="Output as JSON")] = False,
+    quiet: Annotated[bool, typer.Option("--quiet", "-q", help="Suppress info messages")] = False,
+    profile: Annotated[str | None, typer.Option("--profile", "-p", help="Config profile name")] = None,
+    format: Annotated[str, typer.Option("--format", "-f", help="Output format: pretty, json, csv, yaml")] = "pretty",
+    no_header: Annotated[bool, typer.Option("--no-header", help="Omit header row in CSV output")] = False,
+    auth_token: Annotated[str | None, typer.Option("--auth-token", help="Auth token override")] = None,
+    version: Annotated[
+        bool, typer.Option("--version", "-V", callback=version_callback, is_eager=True, help="Show version")
+    ] = False,
+) -> None:
+    """Kodemeio Sentry CLI."""
+    ctx.ensure_object(dict)
+    ctx.obj = AppContext(
+        json_mode=json_output,
+        quiet=quiet,
+        profile=profile,
+        format=format,
+        no_header=no_header,
+        auth_token_override=auth_token,
+    )
+    notify_if_outdated(ctx.obj.output, "kctl-sentry", __version__)
+
+
+app.add_typer(config_app, name="config")
+app.add_typer(health_app, name="health")
+app.add_typer(dashboard_app, name="dashboard")
+app.add_typer(issues_app, name="issues")
+app.add_typer(projects_app, name="projects")
+app.add_typer(releases_app, name="releases")
+app.add_typer(alerts_app, name="alerts")
+app.add_typer(stats_app, name="stats")
+app.add_typer(teams_app, name="teams")
+app.add_typer(environments_app, name="environments")
+app.add_typer(skill_app, name="skill", hidden=True)
+app.add_typer(doctor_app, name="doctor")
+
+# Load third-party plugins via entry points
+discover_and_load_plugins(app)
+add_tui_command(app, service_key="sentry", version=__version__)
+
+
+@app.command("self-update")
+def self_update_cmd(ctx: typer.Context) -> None:
+    """Check for updates and upgrade kctl-sentry."""
+    actx = ctx.obj
+    out = actx.output
+
+    from kctl_lib.self_update import check_update
+    from kctl_lib.self_update import update as do_update
+
+    latest = check_update("kctl-sentry", __version__)
+    if latest:
+        out.info(f"Updating to {latest}...")
+        do_update("kctl-sentry")
+        out.success(f"Updated to {latest}")
+    else:
+        out.success("Already up to date")
+
+
+@app.command()
+def completions(
+    shell: Annotated[str, typer.Argument(help="Shell type: zsh, bash, fish")] = "zsh",
+    install: Annotated[bool, typer.Option("--install", help="Install completions")] = False,
+) -> None:
+    """Generate or install shell completions."""
+    from kctl_lib.completions import get_completion_script, install_completions
+
+    if install:
+        path = install_completions("kctl-sentry", shell)
+        if path:
+            typer.echo(f"Completions installed to {path}")
+        else:
+            typer.echo(f"Could not install completions for {shell}", err=True)
+            raise typer.Exit(code=1)
+    else:
+        script = get_completion_script("kctl-sentry", shell)
+        typer.echo(script)
+
+
+def _run() -> None:
+    """Entry point with error handling."""
+    try:
+        app()
+    except KctlError as e:
+        handle_cli_error(e)
+
+
+if __name__ == "__main__":
+    _run()

kctl_sentry/commands/alerts.py

@@ -0,0 +1,176 @@
+"""Alert rule management commands."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from kctl_sentry.core.callbacks import AppContext
+from kctl_sentry.core.exceptions import KctlError
+
+app = typer.Typer(help="Manage alert rules.")
+
+
+@app.command("list")
+def list_(
+    ctx: typer.Context,
+    project: Annotated[str | None, typer.Option("--project", "-p", help="Filter by project slug")] = None,
+) -> None:
+    """List alert rules."""
+    c: AppContext = ctx.obj
+    out = c.output
+
+    try:
+        rules = c.client.project_get(project, "/rules/") if project else c.client.org_get("/alert-rules/")
+        if not isinstance(rules, list):
+            rules = []
+
+        rows: list[list[str]] = []
+        for rule in rules:
+            rule_id = str(rule.get("id", ""))
+            name = (rule.get("name", "") or "")[:50]
+            # Project-scoped rules have 'projects', org-scoped have 'project'
+            proj_info = ""
+            if isinstance(rule.get("projects"), list):
+                proj_info = ", ".join(rule["projects"])
+            elif isinstance(rule.get("project"), dict):
+                proj_info = rule["project"].get("slug", "")
+
+            status_val = rule.get("status", "active")
+            owner = ""
+            if isinstance(rule.get("owner"), dict):
+                owner = rule["owner"].get("name", "")
+            elif isinstance(rule.get("owner"), str):
+                owner = rule["owner"]
+
+            rows.append([rule_id, name, proj_info, status_val, owner])
+
+        out.table(
+            "Alert Rules",
+            [
+                ("ID", "cyan"),
+                ("Name", ""),
+                ("Project", ""),
+                ("Status", "green"),
+                ("Owner", "dim"),
+            ],
+            rows,
+            data_for_json=rules,
+        )
+    except KctlError as e:
+        out.error(f"Failed to list alerts: {e}")
+        raise typer.Exit(1) from e
+
+
+@app.command("show")
+def show(
+    ctx: typer.Context,
+    rule_id: Annotated[str, typer.Argument(help="Alert rule ID")],
+    project: Annotated[str, typer.Option("--project", "-p", help="Project slug")],
+) -> None:
+    """Show alert rule details and trigger history."""
+    c: AppContext = ctx.obj
+    out = c.output
+
+    try:
+        rule = c.client.project_get(project, f"/rules/{rule_id}/")
+        if not isinstance(rule, dict):
+            rule = {}
+
+        # Parse conditions
+        conditions = rule.get("conditions", [])
+        condition_strs: list[tuple[str, str]] = []
+        for cond in conditions if isinstance(conditions, list) else []:
+            if isinstance(cond, dict):
+                condition_strs.append(("Condition", cond.get("name", str(cond.get("id", "")))))
+
+        # Parse actions
+        actions = rule.get("actions", [])
+        action_strs: list[tuple[str, str]] = []
+        for act in actions if isinstance(actions, list) else []:
+            if isinstance(act, dict):
+                action_strs.append(("Action", act.get("name", str(act.get("id", "")))))
+
+        sections = [
+            (
+                "Alert Rule",
+                [
+                    ("ID", str(rule.get("id", ""))),
+                    ("Name", rule.get("name", "")),
+                    ("Status", rule.get("status", "")),
+                    ("Frequency", f"{rule.get('frequency', '')} seconds"),
+                    ("Date created", (rule.get("dateCreated", "") or "")[:19]),
+                ],
+            ),
+        ]
+
+        if condition_strs:
+            sections.append(("Conditions", condition_strs))
+        if action_strs:
+            sections.append(("Actions", action_strs))
+
+        out.detail(
+            f"Alert Rule: {rule.get('name', rule_id)}",
+            sections,
+            data_for_json=rule,
+        )
+    except KctlError as e:
+        out.error(f"Failed to show alert: {e}")
+        raise typer.Exit(1) from e
+
+
+@app.command("create")
+def create(
+    ctx: typer.Context,
+    project: Annotated[str, typer.Option("--project", "-p", help="Project slug")],
+    name: Annotated[str, typer.Option("--name", "-n", help="Alert rule name")],
+    metric: Annotated[str, typer.Option("--metric", help="Metric: events, users")] = "events",
+    threshold: Annotated[int, typer.Option("--threshold", help="Threshold value")] = 100,
+    time_window: Annotated[int, typer.Option("--time-window", help="Time window in minutes")] = 60,
+) -> None:
+    """Create a new metric alert rule."""
+    c: AppContext = ctx.obj
+    out = c.output
+
+    try:
+        # Map metric to Sentry's aggregate format
+        aggregate_map = {
+            "events": "count()",
+            "users": "count_unique(user)",
+        }
+        aggregate = aggregate_map.get(metric, "count()")
+
+        payload = {
+            "name": name,
+            "aggregate": aggregate,
+            "timeWindow": time_window,
+            "dataset": "events",
+            "query": "",
+            "thresholdType": 0,  # Above threshold
+            "resolveThreshold": None,
+            "triggers": [
+                {
+                    "label": "critical",
+                    "alertThreshold": threshold,
+                    "actions": [],
+                }
+            ],
+            "projects": [project],
+            "owner": None,
+        }
+
+        result = c.client.org_post("/alert-rules/", json=payload)
+        if not isinstance(result, dict):
+            result = {}
+
+        if out.json_mode:
+            out.raw_json(result)
+        else:
+            out.success(f"Alert rule created: {result.get('name', name)}")
+            out.kv("ID", str(result.get("id", "")))
+            out.kv("Metric", aggregate)
+            out.kv("Threshold", str(threshold))
+    except KctlError as e:
+        out.error(f"Failed to create alert: {e}")
+        raise typer.Exit(1) from e