From 2704d8a954a087576a8dd94bbffdc83e6335dac6 Mon Sep 17 00:00:00 2001 From: JennyMink Date: Wed, 30 Sep 2026 21:32:42 -0700 Subject: [PATCH] fix(list): union repeated --status/--state/--id; refuse repeated --type/--assignee (#5739) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * fix(list): union repeated --status/--state/--id; refuse repeated --type/--assignee bd list's filter flags were plain pflag strings, so a repeated flag silently kept only the last value: `--status open --status closed --status pinned` filtered to pinned alone. A 477-issue census answered over 3 rows and nothing in the output distinguished the narrowed answer from a correct one — worse for scripts than humans, since a script pipes the clean-looking count onward. The --status help text already warned about this, but a doc note does not reach a script that already ran. The fix follows what each filter's downstream shape permits: - --status, --state, --id feed comma-separated OR sets, so repeats now union into exactly the comma form: `--status open --status closed` builds "open,closed". Single values and the comma form parse byte-identically to before. - --type and --assignee are single-valued all the way down. Joining --type would surface as "invalid issue type: bug,epic" (loud but misdirected); joining --assignee would exact-match nobody and return an empty result that reads as a clean answer — the same defect in a new spelling. A repeat of either now refuses at parse time, naming the flag. Two invariants shape the value types. Setting the empty string fully resets them, because `bd children` borrows listCmd's status flag with Set("all") and a deferred Set(""). And gatherListInput clears them after copying values out, because pflag values persist across in-process Execute() calls (the cmd/bd test binary, library embedders) and an accumulating value would otherwise leak one command's filter into the next. Tests cover the union, the refusal (long and shorthand spellings), the unchanged single/comma forms, the empty-string reset, and the cross-parse isolation. All four repeated-flag tests fail against the previous flag registrations. Co-Authored-By: Claude Fable 5 * fix(list): dedupe repeated filter values; lower Changed on reset (review follow-ups for #5739) Two nits from review, both on cmd/bd/list_filter_flags.go: - unionStringFlag.Set now dedupes per token, so `--status open --status open` and `--status open --status open,closed --status closed` both build "open,closed" instead of "open,open,closed,closed". Harmless inside the IN (...) either way, but the joined value is what --json callers and error messages echo back. - resetListFilterFlags now lowers pflag's Changed bit on the five flags as well as clearing the values, so it is a full reset rather than a half one; the test helper that cleared Changed by hand is gone. The reset takes the flag set as an argument instead of reading listCmd, because listCmd's initializer reaches it via runListCore -> gatherListInput and referring back would be an initialization cycle. Tests: TestListRepeatedStatusDedupes and TestResetListFilterFlagsLowersChanged cover the two changes; the existing eight are unchanged. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_01BDokjpuq569c49NYTwcBPY * fix(bazel): enumerate list_filter_flags{,_test}.go in cmd/bd srcs This PR adds cmd/bd/list_filter_flags.go and cmd/bd/list_filter_flags_test.go, but cmd/bd/BUILD.bazel carries explicit go_library/go_test srcs lists rather than globs. That file is absent at this branch's merge base and was added on main during the 177-commit advance, so the contributor's history never had it to update. Without the two entries, `bazel build --config=pure //cmd/bd:bd //cmd/bd:bd_test` fails to compile bd_for_tests.a with six undefined symbols: list.go:409,410,413,414,422 for the five list*Flag vars and list_input.go:48 for resetListFilterFlags. Regenerated with `make bazel-sync` (gazelle): +2 srcs lines, no deps churn, and a second sync is a no-op. `make bazel-sync-check` cannot see this class -- tools/bazel/go_srcs.py --check validates only the go_srcs filegroup globs -- but bazel.yml's sync step diffs the full `make bazel-sync` output and would report the tree out of sync. Validated: `bazel build --config=pure //cmd/bd:bd //cmd/bd:bd_test` exits 0 (exits 1 without this change), and //cmd/bd:bd_test runs the PR's 10 new tests green (test.xml: 10 testcases, 0 failures, 0 errors). Co-Authored-By: Claude Opus 5 * review: pin the three unpinned flag arms; correct the CHANGELOG claims Maintainer review fixes for #5739 (review-loop iteration 1). The synthesis was `approve` with zero blockers and zero majors, so every item here is non-gating; applied because each is confined to this PR's own files, cheap, and carries no behaviour change. A new commit rather than an amend: the existing maintainer commit `21d287f4df` is the pre-review lane's BUILD.bazel drift repair, not a review fixup. Test Evidence Quality (minor): three reachable arms of the new registration had no coverage. Added `TestListStateAndStatusArms` with a subtest each for the hidden `--state` alias unioning like `--status`; a union containing `all` being refused downstream rather than narrowed; and `--status` outranking `--state` when both are given, which is `gatherListInput`'s documented fallback order. Mutation-proved by making `unionStringFlag.Set` last-wins (the pre-PR behaviour): the existing `TestListRepeatedStatusUnions` control and the first two new subtests all red, while `--status outranks --state` stays green because it pins the fallback order rather than the union - orthogonal, not vacuous. The `all` arm is the interesting one: under last-wins the repeat kept only `open`, so the `status "all" cannot be combined` guard was never reachable. Release Safety (nit): the CHANGELOG's equivalence claim was one-directional and omitted that third arm. Softened to "accumulate (duplicates collapse) instead of overwriting" and added the clause that `--status all --status open` is refused rather than narrowed. Debuggability (nit), CHANGELOG arm: the quoted refusal was the inner error only. pflag wraps it, so users actually see `invalid argument "epic" for "-t, --type" flag: --type given more than once (already "bug"); pass a single value`, which is now what the entry quotes - probed from a real `ParseFlags` call, not inferred. Took this arm rather than dropping the `--%s` prefix from the inner error, since that one changes a user-visible message and the reviewer offered it as the alternative. Architectural Consistency (nit): replaced the hand-rolled `slicesContains` with stdlib `slices.Contains` and deleted the helper; `slices` is already used elsewhere in this package. Deliberately not done: the Change Impact minor's sibling-surface sweep, which the finding itself scopes as "no change in this PR" plus a follow-up bead. --------- Co-authored-by: Claude Fable 5 Co-authored-by: jwe Co-authored-by: Gas City Adopt-PR --- CHANGELOG.md | 17 +++ cmd/bd/BUILD.bazel | 2 + cmd/bd/list.go | 10 +- cmd/bd/list_filter_flags.go | 101 +++++++++++++ cmd/bd/list_filter_flags_test.go | 237 +++++++++++++++++++++++++++++++ cmd/bd/list_input.go | 4 + 6 files changed, 366 insertions(+), 5 deletions(-) create mode 100644 cmd/bd/list_filter_flags.go create mode 100644 cmd/bd/list_filter_flags_test.go diff --git a/CHANGELOG.md b/CHANGELOG.md index 7884595fb..b6ddad044 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,6 +9,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Fixed +- **`bd list` no longer silently drops all but the last repeated filter flag.** + `--status`, `--state`, and `--id` were plain string flags, so + `bd list --status open --status closed --status pinned` kept only `pinned` — + a census over 477 issues quietly answered over 3, with nothing in the output + to distinguish the narrowed answer from a correct one. Repeats of those three + flags now accumulate (duplicates collapse) instead of overwriting, so + `--status open --status closed` selects the same set as + `--status open,closed`. The one repeat that does not simply accumulate is one + involving `--status all`: `all` cannot be combined with other statuses, so + `--status all --status open` is now refused rather than narrowed to `open`. + `--type` and `--assignee` are single-valued all the way down — unioning would + fail type validation or exact-match nobody — so a repeat of either now refuses + loudly instead of silently keeping the last value: + `invalid argument "epic" for "-t, --type" flag: --type given more than once + (already "bug"); pass a single value`. + Single-flag and comma-form spellings behave exactly as before. + - **`bd init --force` can no longer silently recreate a missing server-side database as empty** (be-5up5). `--force` is an alias for `--reinit-local`, which skips the existing-data guard entirely, and the reinit path's own typed diff --git a/cmd/bd/BUILD.bazel b/cmd/bd/BUILD.bazel index 38feed9b0..23e12fe5a 100644 --- a/cmd/bd/BUILD.bazel +++ b/cmd/bd/BUILD.bazel @@ -179,6 +179,7 @@ go_library( "lint.go", "lint_proxied_server.go", "list.go", + "list_filter_flags.go", "list_format.go", "list_input.go", "list_output.go", @@ -849,6 +850,7 @@ go_test( "list_comments_embedded_test.go", "list_comments_proxied_integration_test.go", "list_embedded_test.go", + "list_filter_flags_test.go", "list_footer_counts_test.go", "list_format_json_test.go", "list_helpers_test.go", diff --git a/cmd/bd/list.go b/cmd/bd/list.go index 3c54c3e71..7c247ee97 100644 --- a/cmd/bd/list.go +++ b/cmd/bd/list.go @@ -406,12 +406,12 @@ func runListCore(cmd *cobra.Command, _ []string) error { } func init() { - listCmd.Flags().StringP("status", "s", "", "Filter by stored status (open, in_progress, blocked, deferred, closed). Comma-separated for multiple: --status open,in_progress. Note: repeating -s/--status silently overwrites the previous value — always use the comma-separated form for multi-status filters.") - listCmd.Flags().String("state", "", "Alias for --status") + listCmd.Flags().VarP(&listStatusFlag, "status", "s", "Filter by stored status (open, in_progress, blocked, deferred, closed). Comma-separated or repeated for multiple: --status open,in_progress") + listCmd.Flags().Var(&listStateFlag, "state", "Alias for --status") _ = listCmd.Flags().MarkHidden("state") registerPriorityFlag(listCmd, "") - listCmd.Flags().StringP("assignee", "a", "", "Filter by assignee") - listCmd.Flags().StringP("type", "t", "", "Filter by type (bug, feature, task, epic, chore, decision, merge-request, molecule, gate, convoy). Aliases: mr→merge-request, feat→feature, mol→molecule, dec/adr→decision") + listCmd.Flags().VarP(&listAssigneeFlag, "assignee", "a", "Filter by assignee") + listCmd.Flags().VarP(&listTypeFlag, "type", "t", "Filter by type (bug, feature, task, epic, chore, decision, merge-request, molecule, gate, convoy). Aliases: mr→merge-request, feat→feature, mol→molecule, dec/adr→decision") listCmd.Flags().StringSliceP("label", "l", []string{}, "Filter by labels (AND: must have ALL). Can combine with --label-any") listCmd.Flags().StringSlice("label-any", []string{}, "Filter by labels (OR: must have AT LEAST ONE). Can combine with --label") listCmd.Flags().StringSlice("exclude-label", []string{}, "Exclude issues that have ANY of these labels") @@ -419,7 +419,7 @@ func init() { listCmd.Flags().String("label-regex", "", "Filter by label regex pattern (e.g., 'tech-(debt|legacy)')") listCmd.Flags().String("title", "", "Filter by title text (case-insensitive substring match)") listCmd.Flags().String("spec", "", "Filter by spec_id prefix") - listCmd.Flags().String("id", "", "Filter by specific issue IDs (comma-separated, e.g., bd-1,bd-5,bd-10)") + listCmd.Flags().Var(&listIDFlag, "id", "Filter by specific issue IDs (comma-separated or repeated, e.g., bd-1,bd-5,bd-10)") listCmd.Flags().IntP("limit", "n", workapi.DefaultListLimit, "Limit results (an explicit --limit always wins, 0 meaning unlimited; otherwise --all is unlimited; otherwise a configured list.limit applies; otherwise unlimited when piped, else 20 in agent mode at a terminal, else 50)") listCmd.Flags().Int("offset", 0, "Skip the first N matching results (0-based). Only supported under --proxied-server.") listCmd.Flags().String("format", "", "Export the dependency graph of the listed issues: 'digraph' (edge list for golang.org/x/tools/cmd/digraph), 'dot' (Graphviz), or a Go template rendered once per edge over .IssueID, .DependsOnID, .Type, .Issue, .Dependency. 'json' is the exception and does not export the graph: it is equivalent to --json, which also wins when both flags are given. 'digraph' and templates print nothing when no listed issue depends on another; 'dot' still prints the nodes") diff --git a/cmd/bd/list_filter_flags.go b/cmd/bd/list_filter_flags.go new file mode 100644 index 000000000..7a4e33184 --- /dev/null +++ b/cmd/bd/list_filter_flags.go @@ -0,0 +1,101 @@ +package main + +import ( + "fmt" + "slices" + "strings" + + "github.com/spf13/pflag" +) + +// unionStringFlag accumulates repeated flag occurrences into a comma-joined +// set: `--status open --status closed` means the same union as +// `--status open,closed`. Setting the empty string clears it — `bd children` +// resets listCmd's flags that way after borrowing them, and gatherListInput +// resets after each read so in-process callers that Execute() more than once +// do not inherit the previous command's filter. +type unionStringFlag struct { + value string +} + +func (f *unionStringFlag) Set(s string) error { + switch { + case s == "": + f.value = "" + case f.value == "": + f.value = s + default: + for _, tok := range strings.Split(s, ",") { + if !slices.Contains(strings.Split(f.value, ","), tok) { + f.value += "," + tok + } + } + } + return nil +} + +func (f *unionStringFlag) String() string { return f.value } + +// Type reports "string" so cmd.Flags().GetString keeps working on flags +// registered with this value. +func (f *unionStringFlag) Type() string { return "string" } + +// onceStringFlag refuses a repeated occurrence outright. It belongs on +// filters that are single-valued all the way down (--type, --assignee), +// where comma-joining would either fail type validation on the joined value +// or exact-match nothing and return an empty result that reads as a clean +// answer. Empty-string reset semantics match unionStringFlag. +type onceStringFlag struct { + name string + value string + set bool +} + +func (f *onceStringFlag) Set(s string) error { + if s == "" { + f.value = "" + f.set = false + return nil + } + if f.set { + return fmt.Errorf("--%s given more than once (already %q); pass a single value", f.name, f.value) + } + f.set = true + f.value = s + return nil +} + +func (f *onceStringFlag) String() string { return f.value } + +func (f *onceStringFlag) Type() string { return "string" } + +var ( + listStatusFlag unionStringFlag + listStateFlag unionStringFlag + listIDFlag unionStringFlag + listTypeFlag = onceStringFlag{name: "type"} + listAssigneeFlag = onceStringFlag{name: "assignee"} +) + +// resetListFilterFlags returns listCmd's five filter flags to their unparsed +// state: the values are cleared AND pflag's Changed bit is lowered on the +// given flag set, so an in-process caller that Execute()s listCmd twice sees +// neither the previous filter nor a stale "the user passed --status" signal. +// It takes the flag set as an argument rather than reading listCmd so that +// listCmd's initializer (via runListCore -> gatherListInput) does not refer +// back to itself. +func resetListFilterFlags(flags *pflag.FlagSet) { + _ = listStatusFlag.Set("") + _ = listStateFlag.Set("") + _ = listIDFlag.Set("") + _ = listTypeFlag.Set("") + _ = listAssigneeFlag.Set("") + if flags == nil { + return + } + for _, name := range []string{"status", "state", "type", "assignee", "id"} { + if fl := flags.Lookup(name); fl != nil { + fl.Changed = false + } + } +} diff --git a/cmd/bd/list_filter_flags_test.go b/cmd/bd/list_filter_flags_test.go new file mode 100644 index 000000000..93015503e --- /dev/null +++ b/cmd/bd/list_filter_flags_test.go @@ -0,0 +1,237 @@ +package main + +import ( + "strings" + "testing" + + "github.com/steveyegge/beads/internal/workapi" +) + +// resetListFilterFlagState restores listCmd's filter flags to their unparsed +// state so these tests leave nothing behind for the rest of the package. +func resetListFilterFlagState(t *testing.T) { + t.Helper() + t.Cleanup(func() { resetListFilterFlags(listCmd.Flags()) }) +} + +func TestListRepeatedStatusUnions(t *testing.T) { + resetListFilterFlagState(t) + + if err := listCmd.ParseFlags([]string{"--status", "open", "--status", "closed", "-s", "pinned"}); err != nil { + t.Fatalf("ParseFlags: %v", err) + } + got, err := listCmd.Flags().GetString("status") + if err != nil { + t.Fatalf("GetString(status): %v", err) + } + if got != "open,closed,pinned" { + t.Fatalf("repeated --status = %q, want union %q", got, "open,closed,pinned") + } +} + +func TestListSingleAndCommaStatusUnchanged(t *testing.T) { + resetListFilterFlagState(t) + + if err := listCmd.ParseFlags([]string{"--status", "open"}); err != nil { + t.Fatalf("ParseFlags: %v", err) + } + if got, _ := listCmd.Flags().GetString("status"); got != "open" { + t.Fatalf("single --status = %q, want %q", got, "open") + } + + resetListFilterFlags(listCmd.Flags()) + if err := listCmd.ParseFlags([]string{"--status", "open,in_progress"}); err != nil { + t.Fatalf("ParseFlags: %v", err) + } + if got, _ := listCmd.Flags().GetString("status"); got != "open,in_progress" { + t.Fatalf("comma --status = %q, want %q", got, "open,in_progress") + } +} + +func TestListRepeatedIDUnions(t *testing.T) { + resetListFilterFlagState(t) + + if err := listCmd.ParseFlags([]string{"--id", "bd-1", "--id", "bd-2,bd-3"}); err != nil { + t.Fatalf("ParseFlags: %v", err) + } + if got, _ := listCmd.Flags().GetString("id"); got != "bd-1,bd-2,bd-3" { + t.Fatalf("repeated --id = %q, want %q", got, "bd-1,bd-2,bd-3") + } +} + +func TestListRepeatedTypeRefused(t *testing.T) { + resetListFilterFlagState(t) + + for _, args := range [][]string{ + {"--type", "bug", "--type", "epic"}, + {"-t", "bug", "-t", "epic"}, + } { + resetListFilterFlags(listCmd.Flags()) + err := listCmd.ParseFlags(args) + if err == nil { + t.Fatalf("ParseFlags(%v) accepted a repeated --type", args) + } + if !strings.Contains(err.Error(), "type") || !strings.Contains(err.Error(), "more than once") { + t.Fatalf("ParseFlags(%v) error %q does not name the repeated flag", args, err) + } + } +} + +func TestListRepeatedAssigneeRefused(t *testing.T) { + resetListFilterFlagState(t) + + err := listCmd.ParseFlags([]string{"--assignee", "alice", "--assignee", "bob"}) + if err == nil { + t.Fatal("ParseFlags accepted a repeated --assignee") + } + if !strings.Contains(err.Error(), "assignee") || !strings.Contains(err.Error(), "more than once") { + t.Fatalf("error %q does not name the repeated flag", err) + } +} + +func TestListSingleTypeAndAssigneeUnchanged(t *testing.T) { + resetListFilterFlagState(t) + + if err := listCmd.ParseFlags([]string{"--type", "bug", "--assignee", "alice"}); err != nil { + t.Fatalf("ParseFlags: %v", err) + } + if got, _ := listCmd.Flags().GetString("type"); got != "bug" { + t.Fatalf("single --type = %q, want %q", got, "bug") + } + if got, _ := listCmd.Flags().GetString("assignee"); got != "alice" { + t.Fatalf("single --assignee = %q, want %q", got, "alice") + } +} + +// bd children borrows listCmd's status flag with Set("all") and a deferred +// Set(""); an empty Set must fully reset both value kinds. +func TestEmptySetResetsFilterFlags(t *testing.T) { + resetListFilterFlagState(t) + + fl := listCmd.Flags() + _ = fl.Set("status", "all") + _ = fl.Set("status", "") + _ = fl.Set("status", "open") + if got, _ := fl.GetString("status"); got != "open" { + t.Fatalf("status after reset = %q, want %q", got, "open") + } + + _ = fl.Set("type", "bug") + _ = fl.Set("type", "") + if err := fl.Set("type", "epic"); err != nil { + t.Fatalf("Set(type) after reset refused: %v", err) + } + if got, _ := fl.GetString("type"); got != "epic" { + t.Fatalf("type after reset = %q, want %q", got, "epic") + } +} + +// Two parses in one process must not bleed into each other once +// resetListFilterFlags has run between them, the way gatherListInput does. +func TestFilterFlagsDoNotLeakAcrossParses(t *testing.T) { + resetListFilterFlagState(t) + + if err := listCmd.ParseFlags([]string{"--status", "open", "--status", "closed"}); err != nil { + t.Fatalf("ParseFlags: %v", err) + } + resetListFilterFlags(listCmd.Flags()) + if err := listCmd.ParseFlags([]string{"--status", "pinned"}); err != nil { + t.Fatalf("ParseFlags: %v", err) + } + if got, _ := listCmd.Flags().GetString("status"); got != "pinned" { + t.Fatalf("status after second parse = %q, want %q (leaked prior parse)", got, "pinned") + } +} + +func TestListRepeatedStatusDedupes(t *testing.T) { + resetListFilterFlagState(t) + + if err := listCmd.ParseFlags([]string{"--status", "open", "--status", "open,closed", "--status", "closed"}); err != nil { + t.Fatalf("ParseFlags: %v", err) + } + got, err := listCmd.Flags().GetString("status") + if err != nil { + t.Fatalf("GetString(status): %v", err) + } + if got != "open,closed" { + t.Fatalf("repeated --status with duplicates = %q, want %q", got, "open,closed") + } +} + +func TestResetListFilterFlagsLowersChanged(t *testing.T) { + resetListFilterFlagState(t) + + if err := listCmd.ParseFlags([]string{"--status", "open", "--type", "bug"}); err != nil { + t.Fatalf("ParseFlags: %v", err) + } + for _, name := range []string{"status", "type"} { + if !listCmd.Flags().Changed(name) { + t.Fatalf("precondition: --%s should read as Changed after parse", name) + } + } + resetListFilterFlags(listCmd.Flags()) + for _, name := range []string{"status", "state", "type", "assignee", "id"} { + if listCmd.Flags().Changed(name) { + t.Fatalf("--%s still reads as Changed after resetListFilterFlags", name) + } + } +} + +// TestListStateAndStatusArms pins the three reachable arms of the new flag +// registration that the existing cases do not reach: the hidden --state alias +// unions like --status, a union that includes "all" is refused downstream +// rather than silently narrowing, and --status wins over --state when both are +// given (gatherListInput only consults --state when --status is empty). +func TestListStateAndStatusArms(t *testing.T) { + t.Run("repeated --state unions", func(t *testing.T) { + resetListFilterFlagState(t) + + if err := listCmd.ParseFlags([]string{"--state", "open", "--state", "closed"}); err != nil { + t.Fatalf("ParseFlags: %v", err) + } + got, err := listCmd.Flags().GetString("state") + if err != nil { + t.Fatalf("GetString(state): %v", err) + } + if got != "open,closed" { + t.Fatalf("repeated --state = %q, want union %q", got, "open,closed") + } + }) + + t.Run("union including all is refused, not narrowed", func(t *testing.T) { + resetListFilterFlagState(t) + + if err := listCmd.ParseFlags([]string{"--status", "all", "--status", "open"}); err != nil { + t.Fatalf("ParseFlags: %v", err) + } + in, err := gatherListInput(listCmd) + if err != nil { + t.Fatalf("gatherListInput: %v", err) + } + if in.Status != "all,open" { + t.Fatalf("unioned status = %q, want %q", in.Status, "all,open") + } + // The union is what makes this reachable: before this PR the repeat + // kept only "open" and the combination never reached the guard. + if _, err := workapi.BuildListFilter(in.ListRequest, workapi.ListConfig{}); err == nil { + t.Fatal("BuildListFilter accepted a union containing \"all\", want a refusal") + } else if !strings.Contains(err.Error(), "cannot be combined") { + t.Fatalf("BuildListFilter error = %v, want a \"cannot be combined\" refusal", err) + } + }) + + t.Run("--status outranks --state", func(t *testing.T) { + resetListFilterFlagState(t) + + if err := listCmd.ParseFlags([]string{"--status", "open", "--state", "closed"}); err != nil { + t.Fatalf("ParseFlags: %v", err) + } + in, err := gatherListInput(listCmd) + if err != nil { + t.Fatalf("gatherListInput: %v", err) + } + if in.Status != "open" { + t.Fatalf("in.Status = %q, want %q (--state must not merge into a non-empty --status)", in.Status, "open") + } + }) +} diff --git a/cmd/bd/list_input.go b/cmd/bd/list_input.go index fa867ce88..45f102994 100644 --- a/cmd/bd/list_input.go +++ b/cmd/bd/list_input.go @@ -43,6 +43,10 @@ type listInput struct { func gatherListInput(cmd *cobra.Command) (listInput, error) { in := listInput{} + // The custom filter values persist across in-process Execute() calls; + // clear them once this read has copied them out. + defer resetListFilterFlags(cmd.Flags()) + in.Status, _ = cmd.Flags().GetString("status") if in.Status == "" { in.Status, _ = cmd.Flags().GetString("state")