feat(cli): --integration filter on alert list and alert-event list (#131)

* docs(skills): status-page card — confirm gate + rollback reporting for public-page structure mutations

* feat(cli): --integration filter on alert list and alert-event list

Both /alert/list and /alert-event/list accept an integration_ids filter
server-side, and the pinned SDK already carries IntegrationIDs []int64
on AlertListRequest and AlertEventGlobalListRequest. The hand-curated
alert list and alert-event list commands never wired it, so filtering
by integration required piping through jq client-side.

Add --integration (comma-separated integration IDs) to both commands,
mirroring the existing --channel pattern end-to-end. On alert-event
list this is distinct from the existing --integration-type flag, which
filters by plugin key rather than numeric ID; help text calls out the
distinction.

* docs(skills): regenerate alert card for --integration

Regenerate the GENERATED:alert fence in skills/flashduty/reference/alert.md via make gen-cards to pick up the new --integration flag on alert list.

Author: ysyneu

internal/cli/alert.go

@@ -24,7 +24,7 @@ func newAlertCmd() *cobra.Command {
 }
 
 func newAlertListCmd() *cobra.Command {
-	var severity, channel, since, until, fields string
+	var severity, channel, integration, since, until, fields string
 	var active, recovered, muted bool
 	var limit, page int
 
@@ -75,6 +75,14 @@ func newAlertListCmd() *cobra.Command {
 					req.ChannelIDs = channelIDs
 				}
 
+				if integration != "" {
+					integrationIDs, err := parseIntSlice(integration)
+					if err != nil {
+						return fmt.Errorf("invalid --integration: %w", err)
+					}
+					req.IntegrationIDs = integrationIDs
+				}
+
 				result, _, err := ctx.Client.Alerts.ReadList(cmdContext(ctx.Cmd), req)
 				if err != nil {
 					return err
@@ -108,6 +116,7 @@ func newAlertListCmd() *cobra.Command {
 	registerEnumFlag(cmd, "severity", severityEnum...)
 	cmd.Flags().BoolVar(&recovered, "recovered", false, "Show recovered only")
 	cmd.Flags().StringVar(&channel, "channel", "", "Comma-separated channel IDs")
+	cmd.Flags().StringVar(&integration, "integration", "", "Comma-separated integration IDs")
 	cmd.Flags().BoolVar(&muted, "muted", false, "Show ever-muted only")
 	cmd.Flags().StringVar(&since, "since", "24h", "Start time")
 	cmd.Flags().StringVar(&until, "until", "now", "End time")

internal/cli/alert_event.go

@@ -18,7 +18,7 @@ func newAlertEventCmd() *cobra.Command {
 }
 
 func newAlertEventListCmd() *cobra.Command {
-	var severity, channel, integrationType, since, until, fields string
+	var severity, channel, integration, integrationType, since, until, fields string
 	var limit, page int
 
 	cmd := &cobra.Command{
@@ -60,6 +60,14 @@ func newAlertEventListCmd() *cobra.Command {
 					input.ChannelIDs = channelIDs
 				}
 
+				if integration != "" {
+					integrationIDs, err := parseIntSlice(integration)
+					if err != nil {
+						return fmt.Errorf("invalid --integration: %w", err)
+					}
+					input.IntegrationIDs = integrationIDs
+				}
+
 				if integrationType != "" {
 					input.IntegrationTypes = parseStringSlice(integrationType)
 				}
@@ -101,7 +109,8 @@ func newAlertEventListCmd() *cobra.Command {
 	cmd.Flags().StringVar(&severity, "severity", "", "Filter: Critical,Warning,Info (comma-separated)")
 	cmd.Flags().StringVar(&channel, "channel", "", "Comma-separated channel IDs")
 	registerEnumFlag(cmd, "severity", severityEnum...)
-	cmd.Flags().StringVar(&integrationType, "integration-type", "", "Comma-separated integration types")
+	cmd.Flags().StringVar(&integration, "integration", "", "Comma-separated integration IDs")
+	cmd.Flags().StringVar(&integrationType, "integration-type", "", "Comma-separated integration types (plugin keys, e.g. AliCloud,Prometheus) — not integration IDs; use --integration for that")
 	cmd.Flags().StringVar(&since, "since", "1h", "Start time")
 	cmd.Flags().StringVar(&until, "until", "now", "End time")
 	cmd.Flags().IntVar(&limit, "limit", 20, "Max results")

internal/cli/alert_test.go

@@ -1,6 +1,7 @@
 package cli
 
 import (
+	"fmt"
 	"strings"
 	"testing"
 )
@@ -62,6 +63,63 @@ func TestCommandAlertListNoStatusFilterOmitsIsActive(t *testing.T) {
 	}
 }
 
+// TestCommandAlertListIntegrationFlagReachesWire guards --integration on
+// `alert list`: a comma-separated value must parse via the shared
+// parseIntSlice helper (same as --channel) and forward as integration_ids on
+// /alert/list.
+func TestCommandAlertListIntegrationFlagReachesWire(t *testing.T) {
+	saveAndResetGlobals(t)
+	stub := newGFStub(t)
+
+	if _, err := execCommand("alert", "list", "--integration", "10001,10002"); err != nil {
+		t.Fatalf("execCommand: %v", err)
+	}
+	if stub.lastPath != "/alert/list" {
+		t.Fatalf("expected /alert/list, got %q", stub.lastPath)
+	}
+	if got, want := fmt.Sprint(stub.lastBody["integration_ids"]), "[10001 10002]"; got != want {
+		t.Fatalf("expected integration_ids %q, got %q", want, got)
+	}
+}
+
+// TestCommandAlertListIntegrationFlagInvalidValue guards the error path: a
+// non-numeric --integration value must fail with a named error instead of
+// silently dropping the filter.
+func TestCommandAlertListIntegrationFlagInvalidValue(t *testing.T) {
+	saveAndResetGlobals(t)
+	newGFStub(t)
+
+	_, err := execCommand("alert", "list", "--integration", "abc")
+	if err == nil {
+		t.Fatal("expected an error, got nil")
+	}
+	if !strings.Contains(err.Error(), "invalid --integration") {
+		t.Fatalf("expected an \"invalid --integration\" error, got: %v", err)
+	}
+}
+
+// TestCommandAlertEventListIntegrationFlagReachesWire guards --integration on
+// `alert-event list`: it must forward as integration_ids on /alert-event/list,
+// distinct from --integration-type which forwards as integration_types.
+func TestCommandAlertEventListIntegrationFlagReachesWire(t *testing.T) {
+	saveAndResetGlobals(t)
+	stub := newGFStub(t)
+
+	if _, err := execCommand("alert-event", "list",
+		"--integration", "10001,10002", "--integration-type", "AliCloud"); err != nil {
+		t.Fatalf("execCommand: %v", err)
+	}
+	if stub.lastPath != "/alert-event/list" {
+		t.Fatalf("expected /alert-event/list, got %q", stub.lastPath)
+	}
+	if got, want := fmt.Sprint(stub.lastBody["integration_ids"]), "[10001 10002]"; got != want {
+		t.Fatalf("expected integration_ids %q, got %q", want, got)
+	}
+	if got, want := fmt.Sprint(stub.lastBody["integration_types"]), "[AliCloud]"; got != want {
+		t.Fatalf("expected integration_types %q, got %q", want, got)
+	}
+}
+
 // TestCommandAlertMergeCommentFileReachesWireByteForByte guards the same
 // shell-interpolation fix applied to incident comment (see
 // TestCommandIncidentCommentPreservesShellMetacharactersByteForByte): alert

skills/flashduty/reference/alert.md

@@ -90,6 +90,7 @@ List alerts
 - `--active` bool
 - `--channel` string
 - `--fields` string
+- `--integration` string
 - `--limit` int
 - `--muted` bool
 - `--page` int