chore: refactor source filter validation

Signed-off-by: Alessio Pragliola <seth.pro@gmail.com>

Author: Al-Pragliola

catalog/internal/catalog/loader.go

@@ -194,7 +194,8 @@ func (l *Loader) updateSources(path string, config *sourceConfig) error {
 			return fmt.Errorf("invalid source: duplicate id %s", id)
 		}
 
-		if _, err := NewModelFilterFromSource(&source, nil, nil); err != nil {
+		// Validate includedModels/excludedModels patterns early
+		if err := ValidateSourceFilters(&source); err != nil {
 			return fmt.Errorf("invalid source %s: %w", id, err)
 		}
 

catalog/internal/catalog/model_filter.go

@@ -136,6 +136,31 @@ func (f *ModelFilter) Allows(name string) bool {
 	return true
 }
 
+// ValidateSourceFilters checks that the includedModels and excludedModels patterns
+// in a source are valid (non-empty, compilable, non-conflicting) without constructing
+// the full ModelFilter. This is useful for early validation at configuration load time.
+func ValidateSourceFilters(source *Source) error {
+	if source == nil {
+		return fmt.Errorf("source cannot be nil")
+	}
+
+	// Check for conflicting patterns
+	if err := detectConflictingPatterns(source.IncludedModels, source.ExcludedModels); err != nil {
+		return fmt.Errorf("source %s: %w", source.Id, err)
+	}
+
+	// Validate that all patterns compile successfully
+	if _, err := compilePatterns("includedModels", source.IncludedModels); err != nil {
+		return fmt.Errorf("source %s: %w", source.Id, err)
+	}
+
+	if _, err := compilePatterns("excludedModels", source.ExcludedModels); err != nil {
+		return fmt.Errorf("source %s: %w", source.Id, err)
+	}
+
+	return nil
+}
+
 // NewModelFilterFromSource composes a ModelFilter using the source-level configuration and any legacy additions.
 func NewModelFilterFromSource(source *Source, extraIncluded, extraExcluded []string) (*ModelFilter, error) {
 	if source == nil {

catalog/internal/catalog/model_filter_test.go

@@ -58,12 +58,87 @@ func TestModelFilterWithWildcardInMiddle(t *testing.T) {
 	assert.False(t, filter.Allows("DeepSeek/empty-old-v1"))
 	assert.False(t, filter.Allows("Foo/old"))
 	assert.False(t, filter.Allows("Bar/deprecated"))
-	
+
 	// Test that */pattern* requires the pattern immediately after /
 	filter2, err := NewModelFilter(nil, []string{"*/deprecated", "*/old*"})
 	require.NoError(t, err)
-	
+
 	assert.True(t, filter2.Allows("Mistral/empty-deprecated")) // doesn't match */deprecated (no immediate match after /)
-	assert.False(t, filter2.Allows("Foo/deprecated")) // matches */deprecated
-	assert.False(t, filter2.Allows("Bar/old-model")) // matches */old*
+	assert.False(t, filter2.Allows("Foo/deprecated"))          // matches */deprecated
+	assert.False(t, filter2.Allows("Bar/old-model"))           // matches */old*
+}
+
+func TestValidateSourceFilters(t *testing.T) {
+	t.Run("valid source with no filters", func(t *testing.T) {
+		source := &Source{
+			CatalogSource: apimodels.CatalogSource{
+				Id:   "test",
+				Name: "Test source",
+			},
+		}
+		err := ValidateSourceFilters(source)
+		assert.NoError(t, err)
+	})
+
+	t.Run("valid source with patterns", func(t *testing.T) {
+		source := &Source{
+			CatalogSource: apimodels.CatalogSource{
+				Id:             "test",
+				Name:           "Test source",
+				IncludedModels: []string{"Granite/*", "Meta/*"},
+				ExcludedModels: []string{"*-beta"},
+			},
+		}
+		err := ValidateSourceFilters(source)
+		assert.NoError(t, err)
+	})
+
+	t.Run("conflicting patterns", func(t *testing.T) {
+		source := &Source{
+			CatalogSource: apimodels.CatalogSource{
+				Id:             "test",
+				Name:           "Test source",
+				IncludedModels: []string{"Granite/*"},
+				ExcludedModels: []string{"Granite/*"},
+			},
+		}
+		err := ValidateSourceFilters(source)
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "source test")
+		assert.Contains(t, err.Error(), "Granite/*")
+	})
+
+	t.Run("empty pattern in includedModels", func(t *testing.T) {
+		source := &Source{
+			CatalogSource: apimodels.CatalogSource{
+				Id:             "test",
+				Name:           "Test source",
+				IncludedModels: []string{"Granite/*", ""},
+			},
+		}
+		err := ValidateSourceFilters(source)
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "source test")
+		assert.Contains(t, err.Error(), "pattern cannot be empty")
+	})
+
+	t.Run("invalid regex pattern", func(t *testing.T) {
+		// This shouldn't happen with our glob-to-regex conversion,
+		// but validates the error path exists
+		source := &Source{
+			CatalogSource: apimodels.CatalogSource{
+				Id:             "test",
+				Name:           "Test source",
+				IncludedModels: []string{"valid/*"},
+			},
+		}
+		err := ValidateSourceFilters(source)
+		assert.NoError(t, err) // Our conversion always produces valid regex
+	})
+
+	t.Run("nil source", func(t *testing.T) {
+		err := ValidateSourceFilters(nil)
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "source cannot be nil")
+	})
 }