refactor: add NewStandardBuilder for consistent inventory building

Add github.NewStandardBuilder() with InventoryConfig to provide a single
canonical way to build inventories with all standard filters:
- DeprecatedAliases
- ReadOnly
- Toolsets
- Tools
- FeatureChecker

This replaces scattered manual builder chains across:
- cmd/github-mcp-server/main.go (OAuth scope computation)
- cmd/github-mcp-server/list_scopes.go (CLI command)
- internal/ghmcp/server.go (server initialization)

Benefits:
- Single point to add new filters (no scattered updates)
- main.go was missing WithDeprecatedAliases - now fixed
- list_scopes.go was missing features flag support - now fixed
- Consistent behavior across all inventory usage

Author: SamMorrowDrums

cmd/github-mcp-server/list_scopes.go

@@ -101,27 +101,28 @@ func runListScopes() error {
 		}
 	}
 
+	// Get enabled features (similar to toolsets)
+	var enabledFeatures []string
+	if viper.IsSet("features") {
+		if err := viper.UnmarshalKey("features", &enabledFeatures); err != nil {
+			return fmt.Errorf("failed to unmarshal features: %w", err)
+		}
+	}
+
 	readOnly := viper.GetBool("read-only")
 	outputFormat := viper.GetString("list-scopes-output")
 
 	// Create translation helper
 	t, _ := translations.TranslationHelper()
 
-	// Build inventory using the same logic as the stdio server
-	inventoryBuilder := github.NewInventory(t).
-		WithReadOnly(readOnly)
-
-	// Configure toolsets (same as stdio)
-	if enabledToolsets != nil {
-		inventoryBuilder = inventoryBuilder.WithToolsets(enabledToolsets)
-	}
-
-	// Configure specific tools
-	if len(enabledTools) > 0 {
-		inventoryBuilder = inventoryBuilder.WithTools(enabledTools)
-	}
-
-	inv, err := inventoryBuilder.Build()
+	// Build inventory using the shared builder for consistency
+	inv, err := github.NewStandardBuilder(github.InventoryConfig{
+		Translator:      t,
+		ReadOnly:        readOnly,
+		Toolsets:        enabledToolsets,
+		Tools:           enabledTools,
+		EnabledFeatures: enabledFeatures,
+	}).Build()
 	if err != nil {
 		return fmt.Errorf("failed to build inventory: %w", err)
 	}

cmd/github-mcp-server/main.go

@@ -230,11 +230,13 @@ func getOAuthScopes(enabledToolsets, enabledTools, enabledFeatures []string, t t
 	// Build inventory with the same configuration that will be used at runtime
 	// This allows us to determine which tools will actually be available
 	// and avoids building the inventory twice
-	inventoryBuilder := github.NewInventory(t).
-		WithReadOnly(viper.GetBool("read-only")).
-		WithToolsets(enabledToolsets).
-		WithTools(enabledTools).
-		WithFeatureChecker(inventory.NewSliceFeatureChecker(enabledFeatures))
+	inventoryBuilder := github.NewStandardBuilder(github.InventoryConfig{
+		Translator:      t,
+		ReadOnly:        viper.GetBool("read-only"),
+		Toolsets:        enabledToolsets,
+		Tools:           enabledTools,
+		EnabledFeatures: enabledFeatures,
+	})
 
 	inv, err := inventoryBuilder.Build()
 	if err != nil {

internal/ghmcp/server.go

@@ -258,13 +258,13 @@ func NewMCPServer(cfg MCPServerConfig) (*mcp.Server, error) {
 		// Prebuilt inventory from OAuth scope computation doesn't have scope filter yet
 		if cfg.TokenScopes != nil {
 			// Need to rebuild with scope filter
-			inventoryBuilder := github.NewInventory(cfg.Translator).
-				WithDeprecatedAliases(github.DeprecatedToolAliases).
-				WithReadOnly(cfg.ReadOnly).
-				WithToolsets(enabledToolsets).
-				WithTools(cfg.EnabledTools).
-				WithFeatureChecker(featureChecker).
-				WithFilter(github.CreateToolScopeFilter(cfg.TokenScopes))
+			inventoryBuilder := github.NewStandardBuilder(github.InventoryConfig{
+				Translator:      cfg.Translator,
+				ReadOnly:        cfg.ReadOnly,
+				Toolsets:        enabledToolsets,
+				Tools:           cfg.EnabledTools,
+				EnabledFeatures: cfg.EnabledFeatures,
+			}).WithFilter(github.CreateToolScopeFilter(cfg.TokenScopes))
 
 			var err error
 			inv, err = inventoryBuilder.Build()
@@ -274,12 +274,13 @@ func NewMCPServer(cfg MCPServerConfig) (*mcp.Server, error) {
 		}
 	} else {
 		// Build inventory from scratch
-		inventoryBuilder := github.NewInventory(cfg.Translator).
-			WithDeprecatedAliases(github.DeprecatedToolAliases).
-			WithReadOnly(cfg.ReadOnly).
-			WithToolsets(enabledToolsets).
-			WithTools(cfg.EnabledTools).
-			WithFeatureChecker(featureChecker)
+		inventoryBuilder := github.NewStandardBuilder(github.InventoryConfig{
+			Translator:      cfg.Translator,
+			ReadOnly:        cfg.ReadOnly,
+			Toolsets:        enabledToolsets,
+			Tools:           cfg.EnabledTools,
+			EnabledFeatures: cfg.EnabledFeatures,
+		})
 
 		// Apply token scope filtering if scopes are known (for PAT filtering)
 		if cfg.TokenScopes != nil {

pkg/github/inventory.go

@@ -16,3 +16,28 @@ func NewInventory(t translations.TranslationHelperFunc) *inventory.Builder {
 		SetResources(AllResources(t)).
 		SetPrompts(AllPrompts(t))
 }
+
+// InventoryConfig holds configuration for building an inventory with standard filters.
+// This struct enables consistent inventory building across the codebase.
+type InventoryConfig struct {
+	Translator      translations.TranslationHelperFunc
+	ReadOnly        bool
+	Toolsets        []string // nil = use defaults, empty = none
+	Tools           []string // additional specific tools
+	EnabledFeatures []string // feature flags
+}
+
+// NewStandardBuilder creates an inventory builder with all standard filters applied.
+// This is the canonical way to create an inventory builder, ensuring consistency
+// between OAuth scope computation, server initialization, and CLI tools.
+//
+// The returned builder can be further customized (e.g., WithFilter for scope filtering)
+// before calling Build().
+func NewStandardBuilder(cfg InventoryConfig) *inventory.Builder {
+	return NewInventory(cfg.Translator).
+		WithDeprecatedAliases(DeprecatedToolAliases).
+		WithReadOnly(cfg.ReadOnly).
+		WithToolsets(cfg.Toolsets).
+		WithTools(cfg.Tools).
+		WithFeatureChecker(inventory.NewSliceFeatureChecker(cfg.EnabledFeatures))
+}