Add WithAdditionalCheckConfigs option to check additional check con…

…figs for unused plugins warning

private/buf/cmd/buf/command/breaking/breaking.go

@@ -24,6 +24,7 @@ import (
 	"github.com/bufbuild/buf/private/buf/buffetch"
 	"github.com/bufbuild/buf/private/bufpkg/bufanalysis"
 	"github.com/bufbuild/buf/private/bufpkg/bufcheck"
+	"github.com/bufbuild/buf/private/bufpkg/bufconfig"
 	"github.com/bufbuild/buf/private/bufpkg/bufimage"
 	"github.com/bufbuild/buf/private/pkg/app/appcmd"
 	"github.com/bufbuild/buf/private/pkg/app/appext"
@@ -216,6 +217,12 @@ func run(
 	defer func() {
 		retErr = errors.Join(retErr, wasmRuntime.Close(ctx))
 	}()
+	allCheckConfigs := slicesext.Map(
+		imageWithConfigs,
+		func(imageWithConfig bufctl.ImageWithConfig) bufconfig.CheckConfig {
+			return imageWithConfig.BreakingConfig()
+		},
+	)
 	var allFileAnnotations []bufanalysis.FileAnnotation
 	for i, imageWithConfig := range imageWithConfigs {
 		client, err := bufcheck.NewClient(
@@ -228,6 +235,7 @@ func run(
 		}
 		breakingOptions := []bufcheck.BreakingOption{
 			bufcheck.WithPluginConfigs(imageWithConfig.PluginConfigs()...),
+			bufcheck.WithAdditionalCheckConfigs(allCheckConfigs...),
 		}
 		if flags.ExcludeImports {
 			breakingOptions = append(breakingOptions, bufcheck.BreakingWithExcludeImports())

private/buf/cmd/buf/command/config/internal/internal.go

@@ -206,6 +206,10 @@ func lsRun(
 	var rules []bufcheck.Rule
 	if flags.ConfiguredOnly {
 		moduleConfigs := bufYAMLFile.ModuleConfigs()
+		allCheckConfigs := append(
+			slicesext.Map(moduleConfigs, func(moduleConfig bufconfig.ModuleConfig) bufconfig.CheckConfig { return moduleConfig.LintConfig() }),
+			slicesext.Map(moduleConfigs, func(moduleConfig bufconfig.ModuleConfig) bufconfig.CheckConfig { return moduleConfig.BreakingConfig() })...,
+		)
 		var moduleConfig bufconfig.ModuleConfig
 		switch fileVersion := bufYAMLFile.FileVersion(); fileVersion {
 		case bufconfig.FileVersionV1Beta1, bufconfig.FileVersionV1:
@@ -242,6 +246,7 @@ func lsRun(
 		}
 		configuredRuleOptions := []bufcheck.ConfiguredRulesOption{
 			bufcheck.WithPluginConfigs(bufYAMLFile.PluginConfigs()...),
+			bufcheck.WithAdditionalCheckConfigs(allCheckConfigs...),
 		}
 		rules, err = client.ConfiguredRules(
 			ctx,

private/buf/cmd/buf/command/lint/lint.go

@@ -23,8 +23,10 @@ import (
 	"github.com/bufbuild/buf/private/buf/bufctl"
 	"github.com/bufbuild/buf/private/bufpkg/bufanalysis"
 	"github.com/bufbuild/buf/private/bufpkg/bufcheck"
+	"github.com/bufbuild/buf/private/bufpkg/bufconfig"
 	"github.com/bufbuild/buf/private/pkg/app/appcmd"
 	"github.com/bufbuild/buf/private/pkg/app/appext"
+	"github.com/bufbuild/buf/private/pkg/slicesext"
 	"github.com/bufbuild/buf/private/pkg/stringutil"
 	"github.com/bufbuild/buf/private/pkg/wasm"
 	"github.com/spf13/pflag"
@@ -142,6 +144,12 @@ func run(
 		retErr = errors.Join(retErr, wasmRuntime.Close(ctx))
 	}()
 	var allFileAnnotations []bufanalysis.FileAnnotation
+	allCheckConfigs := slicesext.Map(
+		imageWithConfigs,
+		func(imageWithConfig bufctl.ImageWithConfig) bufconfig.CheckConfig {
+			return imageWithConfig.LintConfig()
+		},
+	)
 	for _, imageWithConfig := range imageWithConfigs {
 		client, err := bufcheck.NewClient(
 			container.Logger(),
@@ -153,6 +161,7 @@ func run(
 		}
 		lintOptions := []bufcheck.LintOption{
 			bufcheck.WithPluginConfigs(imageWithConfig.PluginConfigs()...),
+			bufcheck.WithAdditionalCheckConfigs(allCheckConfigs...),
 		}
 		if err := client.Lint(
 			ctx,

private/bufpkg/bufcheck/bufcheck.go

@@ -126,6 +126,24 @@ type ConfiguredRulesOption interface {
 	applyToConfiguredRules(*configuredRulesOptions)
 }
 
+// LintBreakingAndConfiguredRulesOption is an option for Lint, Breaking, and ConfiguredRules.
+type LintBreakingAndConfiguredRulesOption interface {
+	LintOption
+	BreakingOption
+	ConfiguredRulesOption
+}
+
+// WithAdditionalCheckConfigs returns a new LintBreakingAndConfiguredRulesOption that allows
+// the caller to provide additional check configs that are being run. This allows the client
+// to check for unused plugins across additional check configs and provide users with a warning.
+//
+// The default is to only check the configs provided to the client for Lint, Breaking, or ConfiguredRules.
+func WithAdditionalCheckConfigs(additionalCheckConfigs ...bufconfig.CheckConfig) LintBreakingAndConfiguredRulesOption {
+	return &additionalCheckConfigsOption{
+		additionalCheckConfigs: additionalCheckConfigs,
+	}
+}
+
 // AllRulesOption is an option for AllRules.
 type AllRulesOption interface {
 	applyToAllRules(*allRulesOptions)

private/bufpkg/bufcheck/client.go

@@ -104,7 +104,7 @@ func (c *client) Lint(
 	if err != nil {
 		return err
 	}
-	config, err := configForLintConfig(lintConfig, allRules, allCategories)
+	config, err := configForLintConfig(lintConfig, allRules, allCategories, lintOptions.additionalCheckConfigs)
 	if err != nil {
 		return err
 	}
@@ -168,6 +168,7 @@ func (c *client) Breaking(
 		allRules,
 		allCategories,
 		breakingOptions.excludeImports,
+		breakingOptions.additionalCheckConfigs,
 	)
 	if err != nil {
 		return err
@@ -229,7 +230,7 @@ func (c *client) ConfiguredRules(
 	if err != nil {
 		return nil, err
 	}
-	rulesConfig, err := rulesConfigForCheckConfig(checkConfig, allRules, allCategories, ruleType)
+	rulesConfig, err := rulesConfigForCheckConfig(checkConfig, allRules, allCategories, ruleType, configuredRulesOptions.additionalCheckConfigs)
 	if err != nil {
 		return nil, err
 	}
@@ -476,24 +477,27 @@ func checkCommentLineForCheckIgnore(
 }
 
 type lintOptions struct {
-	pluginConfigs []bufconfig.PluginConfig
+	pluginConfigs          []bufconfig.PluginConfig
+	additionalCheckConfigs []bufconfig.CheckConfig
 }
 
 func newLintOptions() *lintOptions {
 	return &lintOptions{}
 }
 
 type breakingOptions struct {
-	pluginConfigs  []bufconfig.PluginConfig
-	excludeImports bool
+	pluginConfigs          []bufconfig.PluginConfig
+	excludeImports         bool
+	additionalCheckConfigs []bufconfig.CheckConfig
 }
 
 func newBreakingOptions() *breakingOptions {
 	return &breakingOptions{}
 }
 
 type configuredRulesOptions struct {
-	pluginConfigs []bufconfig.PluginConfig
+	pluginConfigs          []bufconfig.PluginConfig
+	additionalCheckConfigs []bufconfig.CheckConfig
 }
 
 func newConfiguredRulesOptions() *configuredRulesOptions {
@@ -553,3 +557,19 @@ func (p *pluginConfigsOption) applyToAllRules(allRulesOptions *allRulesOptions)
 func (p *pluginConfigsOption) applyToAllCategories(allCategoriesOptions *allCategoriesOptions) {
 	allCategoriesOptions.pluginConfigs = append(allCategoriesOptions.pluginConfigs, p.pluginConfigs...)
 }
+
+type additionalCheckConfigsOption struct {
+	additionalCheckConfigs []bufconfig.CheckConfig
+}
+
+func (a *additionalCheckConfigsOption) applyToLint(lintOptions *lintOptions) {
+	lintOptions.additionalCheckConfigs = append(lintOptions.additionalCheckConfigs, a.additionalCheckConfigs...)
+}
+
+func (a *additionalCheckConfigsOption) applyToBreaking(breakingOptions *breakingOptions) {
+	breakingOptions.additionalCheckConfigs = append(breakingOptions.additionalCheckConfigs, a.additionalCheckConfigs...)
+}
+
+func (a *additionalCheckConfigsOption) applyToConfiguredRules(configuredRulesOptions *configuredRulesOptions) {
+	configuredRulesOptions.additionalCheckConfigs = append(configuredRulesOptions.additionalCheckConfigs, a.additionalCheckConfigs...)
+}

private/bufpkg/bufcheck/config.go

@@ -28,8 +28,9 @@ func configForLintConfig(
 	lintConfig bufconfig.LintConfig,
 	allRules []Rule,
 	allCategories []Category,
+	additionalCheckConfigs []bufconfig.CheckConfig,
 ) (*config, error) {
-	rulesConfig, err := rulesConfigForCheckConfig(lintConfig, allRules, allCategories, check.RuleTypeLint)
+	rulesConfig, err := rulesConfigForCheckConfig(lintConfig, allRules, allCategories, check.RuleTypeLint, additionalCheckConfigs)
 	if err != nil {
 		return nil, err
 	}
@@ -48,8 +49,9 @@ func configForBreakingConfig(
 	allRules []Rule,
 	allCategories []Category,
 	excludeImports bool,
+	additionalCheckConfigs []bufconfig.CheckConfig,
 ) (*config, error) {
-	rulesConfig, err := rulesConfigForCheckConfig(breakingConfig, allRules, allCategories, check.RuleTypeBreaking)
+	rulesConfig, err := rulesConfigForCheckConfig(breakingConfig, allRules, allCategories, check.RuleTypeBreaking, additionalCheckConfigs)
 	if err != nil {
 		return nil, err
 	}

private/bufpkg/bufcheck/rules_config.go

@@ -33,6 +33,7 @@ func rulesConfigForCheckConfig(
 	allRules []Rule,
 	allCategories []Category,
 	ruleType check.RuleType,
+	additionalCheckConfigs []bufconfig.CheckConfig,
 ) (*rulesConfig, error) {
 	return newRulesConfig(
 		checkConfig.UseIDsAndCategories(),
@@ -42,6 +43,7 @@ func rulesConfigForCheckConfig(
 		allRules,
 		allCategories,
 		ruleType,
+		additionalCheckConfigs,
 	)
 }
 
@@ -102,6 +104,10 @@ type rulesConfig struct {
 	// Rules, we don't warn for this plugin, as it may have had rules configured in breaking that
 	// we haven't accounted for.
 	//
+	// The caller can provider additional check configs to check if the plugin has rules configured.
+	// If the plugin has rules configured in any of the additional check configs provided, then
+	// we don't warn.
+	//
 	// The Rule IDs will be sorted.
 	// This will only contain RuleIDs of the given RuleType.
 	// There will be no empty key for plugin name (which means the Rule is builtin), that is
@@ -124,6 +130,7 @@ func newRulesConfig(
 	allRules []Rule,
 	allCategories []Category,
 	ruleType check.RuleType,
+	additionalCheckConfigs []bufconfig.CheckConfig,
 ) (*rulesConfig, error) {
 	allRulesForType := rulesForType(allRules, ruleType)
 	if len(allRulesForType) == 0 {
@@ -312,6 +319,24 @@ func newRulesConfig(
 			delete(unusedPluginNameToRuleIDs, pluginName)
 		}
 	}
+	// We check additional check configs. If rules
+	for _, checkConfig := range additionalCheckConfigs {
+		checkConfigUseRuleIDs, err := transformRuleOrCategoryIDsToRuleIDs(
+			checkConfig.UseIDsAndCategories(),
+			ruleIDToCategoryIDs,
+			categoryIDToRuleIDs,
+		)
+		if err != nil {
+			return nil, err
+		}
+		for _, checkConfigRuleID := range checkConfigUseRuleIDs {
+			// We do not validate the additional check config rules here, only check for those
+			// that are found.
+			if rule, ok := ruleIDToRule[checkConfigRuleID]; ok {
+				delete(unusedPluginNameToRuleIDs, rule.PluginName())
+			}
+		}
+	}
 
 	return &rulesConfig{
 		RuleType:                ruleType,