refactor(search): make --min-ram and --arch shared flags

Move --min-ram and --arch from CPU-dedicated flags to shared flags
so they are available on all search subcommands (gpu, cpu, and parent).

Author: theFong

pkg/cmd/gpucreate/gpucreate.go

@@ -314,8 +314,8 @@ func searchInstances(s GPUCreateStore, filters *searchFilterFlags) ([]gpusearch.
 	}
 
 	instances := gpusearch.ProcessInstances(response.Items)
-	filtered := gpusearch.FilterInstances(instances, filters.gpuName, filters.provider, filters.minVRAM,
-		minTotalVRAM, minCapability, minDisk, 0, maxBootTime, filters.stoppable, filters.rebootable, filters.flexPorts, true)
+	filtered := gpusearch.FilterInstances(instances, filters.gpuName, filters.provider, "", filters.minVRAM,
+		minTotalVRAM, minCapability, 0, minDisk, 0, maxBootTime, filters.stoppable, filters.rebootable, filters.flexPorts, true)
 	gpusearch.SortInstances(filtered, sortBy, filters.descending)
 
 	return filtered, minDisk, nil

pkg/cmd/gpusearch/gpusearch.go

@@ -154,7 +154,9 @@ Features column shows instance capabilities:
 // sharedFlags holds flags shared between gpu and cpu subcommands
 type sharedFlags struct {
 	provider    string
+	arch        string
 	minVCPU     int
+	minRAM      float64
 	minDisk     float64
 	maxBootTime int
 	stoppable   bool
@@ -168,7 +170,9 @@ type sharedFlags struct {
 // addSharedFlags adds common flags to a command
 func addSharedFlags(cmd *cobra.Command, f *sharedFlags) {
 	cmd.Flags().StringVarP(&f.provider, "provider", "p", "", "Filter by provider/cloud (case-insensitive, partial match)")
+	cmd.Flags().StringVar(&f.arch, "arch", "", "Filter by architecture (e.g., x86_64, arm64)")
 	cmd.Flags().IntVar(&f.minVCPU, "min-vcpu", 0, "Minimum number of vCPUs")
+	cmd.Flags().Float64Var(&f.minRAM, "min-ram", 0, "Minimum RAM in GB")
 	cmd.Flags().Float64Var(&f.minDisk, "min-disk", 0, "Minimum disk size in GB")
 	cmd.Flags().IntVar(&f.maxBootTime, "max-boot-time", 0, "Maximum boot time in minutes")
 	cmd.Flags().BoolVar(&f.stoppable, "stoppable", false, "Only show instances that can be stopped and restarted")
@@ -199,7 +203,7 @@ func NewCmdGPUSearch(t *terminal.Terminal, store GPUSearchStore) *cobra.Command
 		Example:               gpuExample,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			// Default behavior: GPU search
-			return RunGPUSearch(t, store, gpuName, shared.provider, minVRAM, minTotalVRAM, minCapability, shared.minDisk, shared.minVCPU, shared.maxBootTime, shared.stoppable, shared.rebootable, shared.flexPorts, shared.sortBy, shared.descending, shared.jsonOutput, wide)
+			return RunGPUSearch(t, store, gpuName, shared.provider, shared.arch, minVRAM, minTotalVRAM, minCapability, shared.minRAM, shared.minDisk, shared.minVCPU, shared.maxBootTime, shared.stoppable, shared.rebootable, shared.flexPorts, shared.sortBy, shared.descending, shared.jsonOutput, wide)
 		},
 	}
 
@@ -233,7 +237,7 @@ func newCmdGPUSubcommand(t *terminal.Terminal, store GPUSearchStore) *cobra.Comm
 		Short:                 "Search GPU instance types",
 		Example:               gpuExample,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return RunGPUSearch(t, store, gpuName, shared.provider, minVRAM, minTotalVRAM, minCapability, shared.minDisk, shared.minVCPU, shared.maxBootTime, shared.stoppable, shared.rebootable, shared.flexPorts, shared.sortBy, shared.descending, shared.jsonOutput, wide)
+			return RunGPUSearch(t, store, gpuName, shared.provider, shared.arch, minVRAM, minTotalVRAM, minCapability, shared.minRAM, shared.minDisk, shared.minVCPU, shared.maxBootTime, shared.stoppable, shared.rebootable, shared.flexPorts, shared.sortBy, shared.descending, shared.jsonOutput, wide)
 		},
 	}
 
@@ -249,8 +253,6 @@ func newCmdGPUSubcommand(t *terminal.Terminal, store GPUSearchStore) *cobra.Comm
 
 // newCmdCPUSubcommand creates the 'cpu' subcommand
 func newCmdCPUSubcommand(t *terminal.Terminal, store GPUSearchStore) *cobra.Command {
-	var minRAM float64
-	var arch string
 	var shared sharedFlags
 
 	cmd := &cobra.Command{
@@ -259,12 +261,10 @@ func newCmdCPUSubcommand(t *terminal.Terminal, store GPUSearchStore) *cobra.Comm
 		Short:                 "Search CPU-only instance types",
 		Example:               cpuExample,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return RunCPUSearch(t, store, shared.provider, arch, minRAM, shared.minDisk, shared.minVCPU, shared.maxBootTime, shared.stoppable, shared.rebootable, shared.flexPorts, shared.sortBy, shared.descending, shared.jsonOutput)
+			return RunCPUSearch(t, store, shared.provider, shared.arch, shared.minRAM, shared.minDisk, shared.minVCPU, shared.maxBootTime, shared.stoppable, shared.rebootable, shared.flexPorts, shared.sortBy, shared.descending, shared.jsonOutput)
 		},
 	}
 
-	cmd.Flags().Float64Var(&minRAM, "min-ram", 0, "Minimum RAM in GB")
-	cmd.Flags().StringVar(&arch, "arch", "", "Filter by architecture (e.g., x86_64, arm64)")
 	addSharedFlags(cmd, &shared)
 
 	return cmd
@@ -303,7 +303,7 @@ func IsStdoutPiped() bool {
 }
 
 // RunGPUSearch executes the GPU search with filters and sorting
-func RunGPUSearch(t *terminal.Terminal, store GPUSearchStore, gpuName, provider string, minVRAM, minTotalVRAM, minCapability, minDisk float64, minVCPU, maxBootTime int, stoppable, rebootable, flexPorts bool, sortBy string, descending, jsonOutput, wide bool) error {
+func RunGPUSearch(t *terminal.Terminal, store GPUSearchStore, gpuName, provider, arch string, minVRAM, minTotalVRAM, minCapability, minRAM, minDisk float64, minVCPU, maxBootTime int, stoppable, rebootable, flexPorts bool, sortBy string, descending, jsonOutput, wide bool) error {
 	if err := validateSortOption(sortBy); err != nil {
 		return err
 	}
@@ -322,7 +322,7 @@ func RunGPUSearch(t *terminal.Terminal, store GPUSearchStore, gpuName, provider
 	instances := ProcessInstances(response.Items)
 
 	// Filter to GPU-only instances
-	filtered := FilterInstances(instances, gpuName, provider, minVRAM, minTotalVRAM, minCapability, minDisk, minVCPU, maxBootTime, stoppable, rebootable, flexPorts, false)
+	filtered := FilterInstances(instances, gpuName, provider, arch, minVRAM, minTotalVRAM, minCapability, minRAM, minDisk, minVCPU, maxBootTime, stoppable, rebootable, flexPorts, false)
 
 	if len(filtered) == 0 {
 		return displayEmptyResults(t, "No GPU instances match the specified filters", jsonOutput, piped)
@@ -792,13 +792,15 @@ func ProcessInstances(items []InstanceType) []GPUInstanceInfo {
 	return instances
 }
 
-// FilterOptions holds all filter criteria for GPU instances
+// FilterOptions holds all filter criteria for instances
 type FilterOptions struct {
 	GPUName       string
 	Provider      string
+	Arch          string
 	MinVRAM       float64
 	MinTotalVRAM  float64
 	MinCapability float64
+	MinRAM        float64
 	MinDisk       float64
 	MinVCPU       int
 	MaxBootTime   int // in minutes
@@ -821,6 +823,10 @@ func (f *FilterOptions) matchesStringFilters(inst GPUInstanceInfo) bool {
 	if f.Provider != "" && !strings.Contains(strings.ToLower(inst.Provider), strings.ToLower(f.Provider)) {
 		return false
 	}
+	// Filter by architecture (case-insensitive partial match)
+	if f.Arch != "" && !strings.Contains(strings.ToLower(inst.Arch), strings.ToLower(f.Arch)) {
+		return false
+	}
 	return true
 }
 
@@ -829,6 +835,9 @@ func (f *FilterOptions) matchesNumericFilters(inst GPUInstanceInfo) bool {
 	if f.MinVCPU > 0 && inst.VCPUs < f.MinVCPU {
 		return false
 	}
+	if f.MinRAM > 0 && inst.RAMInGB < f.MinRAM {
+		return false
+	}
 	if f.MinVRAM > 0 && inst.VRAMPerGPU < f.MinVRAM {
 		return false
 	}
@@ -870,13 +879,15 @@ func (f *FilterOptions) matchesFilter(inst GPUInstanceInfo) bool {
 }
 
 // FilterInstances applies all filters to the instance list. When gpuOnly is true, CPU-only instances are excluded.
-func FilterInstances(instances []GPUInstanceInfo, gpuName, provider string, minVRAM, minTotalVRAM, minCapability, minDisk float64, minVCPU, maxBootTime int, stoppable, rebootable, flexPorts, gpuOnly bool) []GPUInstanceInfo {
+func FilterInstances(instances []GPUInstanceInfo, gpuName, provider, arch string, minVRAM, minTotalVRAM, minCapability, minRAM, minDisk float64, minVCPU, maxBootTime int, stoppable, rebootable, flexPorts, gpuOnly bool) []GPUInstanceInfo {
 	opts := &FilterOptions{
 		GPUName:       gpuName,
 		Provider:      provider,
+		Arch:          arch,
 		MinVRAM:       minVRAM,
 		MinTotalVRAM:  minTotalVRAM,
 		MinCapability: minCapability,
+		MinRAM:        minRAM,
 		MinDisk:       minDisk,
 		MinVCPU:       minVCPU,
 		MaxBootTime:   maxBootTime,
@@ -897,51 +908,16 @@ func FilterInstances(instances []GPUInstanceInfo, gpuName, provider string, minV
 	return filtered
 }
 
-// FilterCPUInstances filters to CPU-only instances and applies CPU-specific filters
+// FilterCPUInstances filters to CPU-only instances using shared filter logic
 func FilterCPUInstances(instances []GPUInstanceInfo, provider, arch string, minRAM, minDisk float64, minVCPU, maxBootTime int, stoppable, rebootable, flexPorts bool) []GPUInstanceInfo {
-	var filtered []GPUInstanceInfo
+	// Filter out GPU instances first, then apply shared filters
+	var cpuOnly []GPUInstanceInfo
 	for _, inst := range instances {
-		// CPU-only: skip GPU instances
-		if inst.Manufacturer != "cpu" {
-			continue
+		if inst.Manufacturer == "cpu" {
+			cpuOnly = append(cpuOnly, inst)
 		}
-		// Provider filter
-		if provider != "" && !strings.Contains(strings.ToLower(inst.Provider), strings.ToLower(provider)) {
-			continue
-		}
-		// Arch filter
-		if arch != "" && !strings.Contains(strings.ToLower(inst.Arch), strings.ToLower(arch)) {
-			continue
-		}
-		// Min vCPU filter
-		if minVCPU > 0 && inst.VCPUs < minVCPU {
-			continue
-		}
-		// Min RAM filter
-		if minRAM > 0 && inst.RAMInGB < minRAM {
-			continue
-		}
-		// Min disk filter
-		if minDisk > 0 && inst.DiskMax < minDisk {
-			continue
-		}
-		// Max boot time filter
-		if maxBootTime > 0 && (inst.BootTime == 0 || inst.BootTime > maxBootTime*60) {
-			continue
-		}
-		// Feature filters
-		if stoppable && !inst.Stoppable {
-			continue
-		}
-		if rebootable && !inst.Rebootable {
-			continue
-		}
-		if flexPorts && !inst.FlexPorts {
-			continue
-		}
-		filtered = append(filtered, inst)
 	}
-	return filtered
+	return FilterInstances(cpuOnly, "", provider, arch, 0, 0, 0, minRAM, minDisk, minVCPU, maxBootTime, stoppable, rebootable, flexPorts, false)
 }
 
 // SortInstances sorts the instance list by the specified column

pkg/cmd/gpusearch/gpusearch_test.go

@@ -168,19 +168,19 @@ func TestFilterInstancesByGPUName(t *testing.T) {
 	instances := ProcessInstances(response.Items)
 
 	// Filter by A10G
-	filtered := FilterInstances(instances, "A10G", "", 0, 0, 0, 0, 0, 0, false, false, false, true)
+	filtered := FilterInstances(instances, "A10G", "", "", 0, 0, 0, 0, 0, 0, 0, false, false, false, true)
 	assert.Len(t, filtered, 2, "Should have 2 A10G instances")
 
 	// Filter by V100
-	filtered = FilterInstances(instances, "V100", "", 0, 0, 0, 0, 0, 0, false, false, false, true)
+	filtered = FilterInstances(instances, "V100", "", "", 0, 0, 0, 0, 0, 0, 0, false, false, false, true)
 	assert.Len(t, filtered, 2, "Should have 2 V100 instances")
 
 	// Filter by lowercase (case-insensitive)
-	filtered = FilterInstances(instances, "v100", "", 0, 0, 0, 0, 0, 0, false, false, false, true)
+	filtered = FilterInstances(instances, "v100", "", "", 0, 0, 0, 0, 0, 0, 0, false, false, false, true)
 	assert.Len(t, filtered, 2, "Should have 2 V100 instances (case-insensitive)")
 
 	// Filter by partial match
-	filtered = FilterInstances(instances, "A1", "", 0, 0, 0, 0, 0, 0, false, false, false, true)
+	filtered = FilterInstances(instances, "A1", "", "", 0, 0, 0, 0, 0, 0, 0, false, false, false, true)
 	assert.Len(t, filtered, 3, "Should have 3 instances matching 'A1' (A10G and A100)")
 }
 
@@ -189,11 +189,11 @@ func TestFilterInstancesByMinVRAM(t *testing.T) {
 	instances := ProcessInstances(response.Items)
 
 	// Filter by min VRAM 24GB
-	filtered := FilterInstances(instances, "", "", 24, 0, 0, 0, 0, 0, false, false, false, true)
+	filtered := FilterInstances(instances, "", "", "", 24, 0, 0, 0, 0, 0, 0, false, false, false, true)
 	assert.Len(t, filtered, 4, "Should have 4 instances with >= 24GB VRAM")
 
 	// Filter by min VRAM 40GB
-	filtered = FilterInstances(instances, "", "", 40, 0, 0, 0, 0, 0, false, false, false, true)
+	filtered = FilterInstances(instances, "", "", "", 40, 0, 0, 0, 0, 0, 0, false, false, false, true)
 	assert.Len(t, filtered, 1, "Should have 1 instance with >= 40GB VRAM")
 	assert.Equal(t, "A100", filtered[0].GPUName)
 }
@@ -203,11 +203,11 @@ func TestFilterInstancesByMinTotalVRAM(t *testing.T) {
 	instances := ProcessInstances(response.Items)
 
 	// Filter by min total VRAM 60GB
-	filtered := FilterInstances(instances, "", "", 0, 60, 0, 0, 0, 0, false, false, false, true)
+	filtered := FilterInstances(instances, "", "", "", 0, 60, 0, 0, 0, 0, 0, false, false, false, true)
 	assert.Len(t, filtered, 2, "Should have 2 instances with >= 60GB total VRAM")
 
 	// Filter by min total VRAM 300GB
-	filtered = FilterInstances(instances, "", "", 0, 300, 0, 0, 0, 0, false, false, false, true)
+	filtered = FilterInstances(instances, "", "", "", 0, 300, 0, 0, 0, 0, 0, false, false, false, true)
 	assert.Len(t, filtered, 1, "Should have 1 instance with >= 300GB total VRAM")
 	assert.Equal(t, "p4d.24xlarge", filtered[0].Type)
 }
@@ -217,11 +217,11 @@ func TestFilterInstancesByMinCapability(t *testing.T) {
 	instances := ProcessInstances(response.Items)
 
 	// Filter by capability >= 8.0
-	filtered := FilterInstances(instances, "", "", 0, 0, 8.0, 0, 0, 0, false, false, false, true)
+	filtered := FilterInstances(instances, "", "", "", 0, 0, 8.0, 0, 0, 0, 0, false, false, false, true)
 	assert.Len(t, filtered, 4, "Should have 4 instances with capability >= 8.0")
 
 	// Filter by capability >= 8.5
-	filtered = FilterInstances(instances, "", "", 0, 0, 8.5, 0, 0, 0, false, false, false, true)
+	filtered = FilterInstances(instances, "", "", "", 0, 0, 8.5, 0, 0, 0, 0, false, false, false, true)
 	assert.Len(t, filtered, 3, "Should have 3 instances with capability >= 8.5")
 }
 
@@ -230,11 +230,11 @@ func TestFilterInstancesCombined(t *testing.T) {
 	instances := ProcessInstances(response.Items)
 
 	// Filter by GPU name and min VRAM
-	filtered := FilterInstances(instances, "A10G", "", 24, 0, 0, 0, 0, 0, false, false, false, true)
+	filtered := FilterInstances(instances, "A10G", "", "", 24, 0, 0, 0, 0, 0, 0, false, false, false, true)
 	assert.Len(t, filtered, 2, "Should have 2 A10G instances with >= 24GB VRAM")
 
 	// Filter by GPU name, min VRAM, and capability
-	filtered = FilterInstances(instances, "", "", 24, 0, 8.5, 0, 0, 0, false, false, false, true)
+	filtered = FilterInstances(instances, "", "", "", 24, 0, 8.5, 0, 0, 0, 0, false, false, false, true)
 	assert.Len(t, filtered, 3, "Should have 3 instances with >= 24GB VRAM and capability >= 8.5")
 }
 
@@ -336,7 +336,7 @@ func TestEmptyInstanceTypes(t *testing.T) {
 
 	assert.Len(t, instances, 0, "Should have 0 instances")
 
-	filtered := FilterInstances(instances, "A100", "", 0, 0, 0, 0, 0, 0, false, false, false, true)
+	filtered := FilterInstances(instances, "A100", "", "", 0, 0, 0, 0, 0, 0, 0, false, false, false, true)
 	assert.Len(t, filtered, 0, "Filtered should also be empty")
 }
 
@@ -395,12 +395,12 @@ func TestNonGPUInstancesFilteredByDefault(t *testing.T) {
 	instances := ProcessInstances(response.Items)
 
 	// gpuOnly=true should filter out CPU instances
-	filtered := FilterInstances(instances, "", "", 0, 0, 0, 0, 0, 0, false, false, false, true)
+	filtered := FilterInstances(instances, "", "", "", 0, 0, 0, 0, 0, 0, 0, false, false, false, true)
 	assert.Len(t, filtered, 1, "gpuOnly should exclude CPU instances")
 	assert.Equal(t, "g5.xlarge", filtered[0].Type)
 
 	// gpuOnly=false should keep CPU instances
-	filtered = FilterInstances(instances, "", "", 0, 0, 0, 0, 0, 0, false, false, false, false)
+	filtered = FilterInstances(instances, "", "", "", 0, 0, 0, 0, 0, 0, 0, false, false, false, false)
 	assert.Len(t, filtered, 2, "Without gpuOnly, both CPU and GPU instances pass")
 }
 
@@ -464,7 +464,7 @@ func TestFilterByMaxBootTimeExcludesUnknown(t *testing.T) {
 	assert.Len(t, instances, 3, "Should have 3 instances before filtering")
 
 	// Filter by max boot time of 10 minutes - should exclude unknown and slow-boot
-	filtered := FilterInstances(instances, "", "", 0, 0, 0, 0, 0, 10, false, false, false, true)
+	filtered := FilterInstances(instances, "", "", "", 0, 0, 0, 0, 0, 0, 10, false, false, false, true)
 	assert.Len(t, filtered, 1, "Should have 1 instance with boot time <= 10 minutes")
 	assert.Equal(t, "fast-boot", filtered[0].Type, "Only fast-boot should match")
 
@@ -475,7 +475,7 @@ func TestFilterByMaxBootTimeExcludesUnknown(t *testing.T) {
 	}
 
 	// Without filter, all instances should be included
-	noFilter := FilterInstances(instances, "", "", 0, 0, 0, 0, 0, 0, false, false, false, true)
+	noFilter := FilterInstances(instances, "", "", "", 0, 0, 0, 0, 0, 0, 0, false, false, false, true)
 	assert.Len(t, noFilter, 3, "Without filter, all 3 instances should be included")
 }