add toolset default to make configuration easier

Author: tonytrg

README.md

@@ -359,7 +359,9 @@ docker run -i --rm \
   ghcr.io/github/github-mcp-server
 ```
 
-### The "all" Toolset
+### Special toolsets
+
+#### "all" toolset
 
 The special toolset `all` can be provided to enable all available toolsets regardless of any other configuration:
 
@@ -373,6 +375,19 @@ Or using the environment variable:
 GITHUB_TOOLSETS="all" ./github-mcp-server
 ```
 
+#### "default" toolset
+
+The default toolset `default` is the configuration that gets passed to the server if no toolsets are specified.
+
+It consists of:
+- ...
+
+To keep the default configuration and add additional toolsets, just specify "default, <additional-toolset>"
+
+```bash
+GITHUB_TOOLSETS="default,stargazers" ./github-mcp-server
+```
+
 ### Available Toolsets
 
 The following sets of tools are available (all are on by default):

cmd/github-mcp-server/main.go

@@ -45,8 +45,9 @@ var (
 				return fmt.Errorf("failed to unmarshal toolsets: %w", err)
 			}
 
+			// No passed toolsets configuration means we enable the default toolset
 			if len(enabledToolsets) == 0 {
-				enabledToolsets = github.GetDefaultToolsetIDs()
+				enabledToolsets = []string{github.ToolsetMetadataDefault.ID}
 			}
 
 			stdioServerConfig := ghmcp.StdioServerConfig{

internal/ghmcp/server.go

@@ -111,12 +111,14 @@ func NewMCPServer(cfg MCPServerConfig) (*server.MCPServer, error) {
 		// filter "all" from the enabled toolsets
 		enabledToolsets = make([]string, 0, len(cfg.EnabledToolsets))
 		for _, toolset := range cfg.EnabledToolsets {
-			if toolset != "all" {
+			if toolset != github.ToolsetMetadataAll.ID {
 				enabledToolsets = append(enabledToolsets, toolset)
 			}
 		}
 	}
 
+	enabledToolsets = transformDefault(enabledToolsets)
+
 	// Generate instructions based on enabled toolsets
 	instructions := github.GenerateInstructions(enabledToolsets)
 
@@ -470,3 +472,34 @@ func (t *bearerAuthTransport) RoundTrip(req *http.Request) (*http.Response, erro
 	req.Header.Set("Authorization", "Bearer "+t.token)
 	return t.transport.RoundTrip(req)
 }
+
+// transformDefault replaces "default" in the enabled toolsets with the actual default toolset IDs.
+// If "default" is present, it removes it and adds the default toolset IDs from GetDefaultToolsetIDs().
+// Duplicates are removed from the final result.
+func transformDefault(enabledToolsets []string) []string {
+	hasDefault := false
+	result := make([]string, 0, len(enabledToolsets))
+	seen := make(map[string]bool)
+
+	// First pass: check if "default" exists and collect non-default toolsets
+	for _, toolset := range enabledToolsets {
+		if toolset == github.ToolsetMetadataDefault.ID {
+			hasDefault = true
+		} else if !seen[toolset] {
+			result = append(result, toolset)
+			seen[toolset] = true
+		}
+	}
+
+	// If "default" was found, add the default toolset IDs
+	if hasDefault {
+		for _, defaultToolset := range github.GetDefaultToolsetIDs() {
+			if !seen[defaultToolset] {
+				result = append(result, defaultToolset)
+				seen[defaultToolset] = true
+			}
+		}
+	}
+
+	return result
+}

internal/ghmcp/server_test.go

@@ -0,0 +1,156 @@
+package ghmcp
+
+import (
+	"testing"
+
+	"github.com/github/github-mcp-server/pkg/github"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestTransformDefault(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    []string
+		expected []string
+	}{
+		{
+			name:     "empty slice",
+			input:    []string{},
+			expected: []string{},
+		},
+		{
+			name:  "default only",
+			input: []string{"default"},
+			expected: []string{
+				"context",
+				"repos",
+				"issues",
+				"pull_requests",
+				"users",
+			},
+		},
+		{
+			name:  "default with additional toolsets",
+			input: []string{"default", "actions", "gists"},
+			expected: []string{
+				"actions",
+				"gists",
+				"context",
+				"repos",
+				"issues",
+				"pull_requests",
+				"users",
+			},
+		},
+		{
+			name:  "default with overlapping toolsets",
+			input: []string{"default", "issues", "actions"},
+			expected: []string{
+				"issues",
+				"actions",
+				"context",
+				"repos",
+				"pull_requests",
+				"users",
+			},
+		},
+		{
+			name:     "no default present",
+			input:    []string{"actions", "gists", "notifications"},
+			expected: []string{"actions", "gists", "notifications"},
+		},
+		{
+			name:     "duplicate toolsets without default",
+			input:    []string{"actions", "gists", "actions"},
+			expected: []string{"actions", "gists"},
+		},
+		{
+			name:  "duplicate toolsets with default",
+			input: []string{"actions", "default", "actions", "issues"},
+			expected: []string{
+				"actions",
+				"issues",
+				"context",
+				"repos",
+				"pull_requests",
+				"users",
+			},
+		},
+		{
+			name:  "multiple defaults (edge case)",
+			input: []string{"default", "actions", "default"},
+			expected: []string{
+				"actions",
+				"context",
+				"repos",
+				"issues",
+				"pull_requests",
+				"users",
+			},
+		},
+		{
+			name:  "all default toolsets already present with default",
+			input: []string{"context", "repos", "issues", "pull_requests", "users", "default"},
+			expected: []string{
+				"context",
+				"repos",
+				"issues",
+				"pull_requests",
+				"users",
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := transformDefault(tt.input)
+
+			// Check that the result has the correct length
+			require.Len(t, result, len(tt.expected), "result length should match expected length")
+
+			// Create a map for easier comparison since order might vary
+			resultMap := make(map[string]bool)
+			for _, toolset := range result {
+				resultMap[toolset] = true
+			}
+
+			expectedMap := make(map[string]bool)
+			for _, toolset := range tt.expected {
+				expectedMap[toolset] = true
+			}
+
+			// Check that both maps contain the same toolsets
+			assert.Equal(t, expectedMap, resultMap, "result should contain all expected toolsets without duplicates")
+
+			// Verify no duplicates in result
+			assert.Len(t, resultMap, len(result), "result should not contain duplicates")
+
+			// Verify "default" is not in the result
+			assert.False(t, resultMap["default"], "result should not contain 'default'")
+		})
+	}
+}
+
+func TestTransformDefaultWithActualDefaults(t *testing.T) {
+	// This test verifies that the function uses the actual default toolsets from GetDefaultToolsetIDs()
+	input := []string{"default"}
+	result := transformDefault(input)
+
+	defaultToolsets := github.GetDefaultToolsetIDs()
+
+	// Check that result contains all default toolsets
+	require.Len(t, result, len(defaultToolsets), "result should contain all default toolsets")
+
+	resultMap := make(map[string]bool)
+	for _, toolset := range result {
+		resultMap[toolset] = true
+	}
+
+	for _, defaultToolset := range defaultToolsets {
+		assert.True(t, resultMap[defaultToolset], "result should contain default toolset: %s", defaultToolset)
+	}
+
+	// Verify "default" is not in the result
+	assert.False(t, resultMap["default"], "result should not contain 'default'")
+}

pkg/github/tools.go

@@ -23,6 +23,14 @@ type ToolsetMetadata struct {
 }
 
 var (
+	ToolsetMetadataAll = ToolsetMetadata{
+		ID:          "all",
+		Description: "Special toolset that enables all available toolsets",
+	}
+	ToolsetMetadataDefault = ToolsetMetadata{
+		ID:          "default",
+		Description: "Special toolset that enables the default toolset configuration. When no toolsets are specified, this is the set that is enabled",
+	}
 	ToolsetMetadataContext = ToolsetMetadata{
 		ID:          "context",
 		Description: "Tools that provide context about the current user and GitHub context you are operating in",