add filter option to list command

Signed-off-by: olalekan odukoya <odukoyaonline@gmail.com>

Author: olamilekan000

cmd/limactl/list.go

@@ -6,6 +6,7 @@ package main
 import (
 	"bufio"
 	"bytes"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"reflect"
@@ -57,6 +58,14 @@ The output can be presented in one of several formats, using the --format <forma
   --format yaml  - Output in YAML format
   --format table - Output in table format
   --format '{{ <go template> }}' - If the format begins and ends with '{{ }}', then it is used as a go template.
+
+Filtering instances:
+  --filter EXPR  - Filter instances using yq expression (this is equivalent to --yq 'select(EXPR)')
+                   Can be specified multiple times and it works with all output formats.
+                   Examples:
+                     --filter '.status == "Running"'
+                     --filter '.vmType == "vz"'
+                     --filter '.status == "Running"' --filter '.vmType == "vz"'
 ` + store.FormatHelp + `
 The following legacy flags continue to function:
   --json - equal to '--format json'`,
@@ -72,6 +81,7 @@ The following legacy flags continue to function:
 	listCommand.Flags().BoolP("quiet", "q", false, "Only show names")
 	listCommand.Flags().Bool("all-fields", false, "Show all fields")
 	listCommand.Flags().StringArray("yq", nil, "Apply yq expression to each instance")
+	listCommand.Flags().StringArray("filter", nil, "Filter instances using yq expression (equivalent to --yq 'select(EXPR)')")
 
 	return listCommand
 }
@@ -121,6 +131,10 @@ func listAction(cmd *cobra.Command, args []string) error {
 	if err != nil {
 		return err
 	}
+	filter, err := cmd.Flags().GetStringArray("filter")
+	if err != nil {
+		return err
+	}
 
 	if jsonFormat {
 		format = "json"
@@ -141,6 +155,14 @@ func listAction(cmd *cobra.Command, args []string) error {
 			return errors.New("option --list-fields conflicts with option --yq")
 		}
 	}
+	if len(filter) != 0 {
+		if listFields {
+			return errors.New("option --list-fields conflicts with option --filter")
+		}
+		if len(yq) != 0 {
+			return errors.New("option --filter conflicts with option --yq")
+		}
+	}
 
 	if quiet && format != "table" {
 		return errors.New("option --quiet can only be used with '--format table'")
@@ -220,15 +242,36 @@ func listAction(cmd *cobra.Command, args []string) error {
 			options.TerminalWidth = w
 		}
 	}
+	if len(filter) != 0 {
+		for _, f := range filter {
+			yq = append(yq, "select("+f+")")
+		}
+	}
+
 	// --yq implies --format json unless --format yaml has been explicitly specified
-	if len(yq) != 0 && !cmd.Flags().Changed("format") {
+	// But --filter should preserve the original format
+	if len(yq) != 0 && !cmd.Flags().Changed("format") && len(filter) == 0 {
 		format = "json"
 	}
 	// Always pipe JSON and YAML through yq to colorize it if isTTY
 	if len(yq) == 0 && (format == "json" || format == "yaml") {
 		yq = append(yq, ".")
 	}
 
+	// handle --filter with table and go-template formats
+	tmpl := strings.HasPrefix(format, "{{") && strings.HasSuffix(format, "}}")
+	if len(filter) != 0 && (format == "table" || tmpl) {
+		filteredInstances, err := filterInstances(instances, filter)
+		if err != nil {
+			return err
+		}
+		err = store.PrintInstances(cmd.OutOrStdout(), filteredInstances, format, &options)
+		if err == nil && unmatchedInstances {
+			return unmatchedInstancesError{}
+		}
+		return err
+	}
+
 	if len(yq) == 0 {
 		err = store.PrintInstances(cmd.OutOrStdout(), instances, format, &options)
 		if err == nil && unmatchedInstances {
@@ -320,3 +363,43 @@ func listAction(cmd *cobra.Command, args []string) error {
 func listBashComplete(cmd *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {
 	return bashCompleteInstanceNames(cmd)
 }
+
+// filterInstances applies yq filter expressions to instances and returns the filtered results.
+func filterInstances(instances []*limatype.Instance, filters []string) ([]*limatype.Instance, error) {
+	if len(filters) == 0 {
+		return instances, nil
+	}
+
+	var jsonLines []string
+	for _, instance := range instances {
+		jsonBytes, err := json.Marshal(instance)
+		if err != nil {
+			return nil, fmt.Errorf("failed to marshal instance %s: %w", instance.Name, err)
+		}
+		jsonLines = append(jsonLines, string(jsonBytes))
+	}
+
+	var yqExprs []string
+	for _, filter := range filters {
+		yqExprs = append(yqExprs, "select("+filter+")")
+	}
+	yqExpr := strings.Join(yqExprs, " | ")
+
+	var filteredInstances []*limatype.Instance
+	for _, jsonLine := range jsonLines {
+		result, err := yqutil.EvaluateExpression(yqExpr, []byte(jsonLine))
+		if err != nil {
+			return nil, fmt.Errorf("failed to apply filter %s: %w", yqExpr, err)
+		}
+
+		if len(result) > 0 && string(result) != "null" {
+			var instance limatype.Instance
+			if err := json.Unmarshal(result, &instance); err != nil {
+				return nil, fmt.Errorf("failed to unmarshal filtered instance: %w", err)
+			}
+			filteredInstances = append(filteredInstances, &instance)
+		}
+	}
+
+	return filteredInstances, nil
+}

hack/bats/tests/list.bats

@@ -264,3 +264,26 @@ local_setup() {
     run -0 limactl ls --quiet --yq 'select(.name == "foo")'
     assert_output "foo"
 }
+
+@test '--filter option filters instances' {
+    run -0 limactl ls --filter '.name == "foo"'
+    assert_line --index 0 --regexp '^NAME'
+    assert_line --index 1 --regexp '^foo'
+    assert_output_lines_count 2
+}
+
+@test '--filter option works with all output formats' {
+    run -0 limactl ls --filter '.name == "foo"'
+    assert_line --index 1 --regexp '^foo'
+    
+    run -0 limactl ls --filter '.name == "foo"' --format json
+    assert_line --index 0 --regexp '^\{"name":"foo",'
+    
+    run -0 limactl ls --filter '.name == "foo"' --format '{{.Name}}'
+    assert_output "foo"
+}
+
+@test '--filter option is incompatible with --yq' {
+    run_e -1 limactl ls --filter '.name == "foo"' --yq '.name'
+    assert_fatal "option --filter conflicts with option --yq"
+}