fix(cli): accept required body fields from flags

internal/cli/args.go

@@ -24,23 +24,37 @@ func requireArgs(argNames ...string) cobra.PositionalArgs {
 	}
 }
 
-// requireExactArg returns a positional argument validator that requires exactly
-// one argument named name, producing friendly messages that match requireArgs style:
-//
-//   - zero args: "missing <name>. Usage: ..."
-//   - >1 args:   "expects exactly one <name>. Usage: ..."
-func requireExactArg(name string) cobra.PositionalArgs {
+// requireBodyFieldOrArgs validates a required variadic positional that folds
+// into a request-body field. The same field can also come from --data or from
+// its typed flag, so zero positional args are valid when either source is set.
+func requireBodyFieldOrArgs(name, flagName string) cobra.PositionalArgs {
+	return func(cmd *cobra.Command, args []string) error {
+		if len(args) > 0 || bodyFieldSourceSet(cmd, flagName) {
+			return nil
+		}
+		return fmt.Errorf("missing %s. Usage: %s", name, cmd.UseLine())
+	}
+}
+
+// requireBodyFieldOrExactArg validates a required scalar positional that folds
+// into a request-body field. The value may instead come from --data or from the
+// typed flag, but extra positionals are still rejected.
+func requireBodyFieldOrExactArg(name, flagName string) cobra.PositionalArgs {
 	return func(cmd *cobra.Command, args []string) error {
-		switch {
-		case len(args) == 0:
-			return fmt.Errorf("missing %s. Usage: %s", name, cmd.UseLine())
-		case len(args) > 1:
+		if len(args) > 1 {
 			return fmt.Errorf("expects exactly one %s. Usage: %s", name, cmd.UseLine())
 		}
-		return nil
+		if len(args) == 1 || bodyFieldSourceSet(cmd, flagName) {
+			return nil
+		}
+		return fmt.Errorf("missing %s. Usage: %s", name, cmd.UseLine())
 	}
 }
 
+func bodyFieldSourceSet(cmd *cobra.Command, flagName string) bool {
+	return cmd.Flags().Changed("data") || cmd.Flags().Changed(flagName)
+}
+
 // optionalArg returns a positional argument validator that accepts zero or one
 // argument named name. It backs generated commands whose positional folds into
 // an OPTIONAL body field because the operation also accepts an alternative

internal/cli/gen_positional_test.go

@@ -99,6 +99,20 @@ func TestGenPositionalSliceRuntime(t *testing.T) {
 	if got, want := fmt.Sprint(stub.bodyStrings("alert_ids")), "[a1 a2 a3]"; got != want {
 		t.Errorf("alert_ids = %q, want %q", got, want)
 	}
+
+	if _, err := execCommand("alert", "list-by-ids", "--alert-ids", "b1,b2"); err != nil {
+		t.Fatalf("execCommand alert list-by-ids --alert-ids: %v", err)
+	}
+	if got, want := fmt.Sprint(stub.bodyStrings("alert_ids")), "[b1 b2]"; got != want {
+		t.Errorf("alert_ids from flag = %q, want %q", got, want)
+	}
+
+	if _, err := execCommand("alert", "list-by-ids", "--data", `{"alert_ids":["c1","c2"]}`); err != nil {
+		t.Fatalf("execCommand alert list-by-ids --data: %v", err)
+	}
+	if got, want := fmt.Sprint(stub.bodyStrings("alert_ids")), "[c1 c2]"; got != want {
+		t.Errorf("alert_ids from data = %q, want %q", got, want)
+	}
 }
 
 // TestGenPositionalIntSliceRuntime invokes a GENERATED-ONLY int-slice command
@@ -164,6 +178,34 @@ func TestGenPositionalFlagOverridesPositional(t *testing.T) {
 	}
 }
 
+func TestGenChannelEscalateRuleListArgumentSources(t *testing.T) {
+	saveAndResetGlobals(t)
+	stub := newGFStub(t)
+
+	tests := []struct {
+		name string
+		args []string
+		want float64
+	}{
+		{name: "positional", args: []string{"channel", "escalate-rule-list", "42"}, want: 42},
+		{name: "typed flag", args: []string{"channel", "escalate-rule-list", "--channel-id", "43"}, want: 43},
+		{name: "data", args: []string{"channel", "escalate-rule-list", "--data", `{"channel_id":44}`}, want: 44},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if _, err := execCommand(tt.args...); err != nil {
+				t.Fatalf("execCommand: %v", err)
+			}
+			if stub.lastPath != "/channel/escalate/rule/list" {
+				t.Fatalf("path = %q, want /channel/escalate/rule/list", stub.lastPath)
+			}
+			if got := stub.lastBody["channel_id"]; got != tt.want {
+				t.Errorf("channel_id = %#v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
 // TestGenFoldPositional unit-tests the runtime helper across all three kinds.
 func TestGenFoldPositional(t *testing.T) {
 	// string scalar → args[0]