feat: partition tools by product/feature

Author: SamMorrowDrums

Diff for: README.md

@@ -96,6 +96,79 @@ If you don't have Docker, you can use `go` to build the binary in the
 command with the `GITHUB_PERSONAL_ACCESS_TOKEN` environment variable set to
 your token.
 
+## Tool Configuration
+
+The GitHub MCP Server supports enabling or disabling specific groups of functionalities via the `--toolsets` flag. This allows you to control which GitHub API capabilities are available to your AI tools.
+
+### Available Toolsets
+
+The following sets of tools are available:
+
+| Toolset                 | Description                                                   | Default Status |
+| ----------------------- | ------------------------------------------------------------- | -------------- |
+| `repos`                 | Repository-related tools (file operations, branches, commits) | Enabled        |
+| `issues`                | Issue-related tools (create, read, update, comment)           | Enabled        |
+| `search`                | Search functionality (code, repositories, users)              | Enabled        |
+| `pull_requests`         | Pull request operations (create, merge, review)               | Enabled        |
+| `context`         | Tools providing context about current user and GitHub context | Enabled        |
+| `dynamic`         | Tool discovery and dynamic enablement of GitHub MCP tools     | Enabled        |
+| `code_security`         | Code scanning alerts and security features                    | Disabled       |
+| `experiments`           | Experimental features (not considered stable)                 | Disabled       |
+| `all`                   | Special flag to enable all features                           | Disabled       |
+
+### Specifying Toolsets
+
+You can enable specific features in two ways:
+
+1. **Using Command Line Argument**:
+
+   ```bash
+   github-mcp-server --toolsets repos,issues,pull_requests,code_security
+   ```
+
+2. **Using Environment Variable**:
+   ```bash
+   GITHUB_TOOLSETS="repos,issues,pull_requests,code_security" ./github-mcp-server
+   ```
+
+The environment variable `GITHUB_TOOLSETS` takes precedence over the command line argument if both are provided.
+
+### Default Enabled Toolsets
+
+By default, the following toolsets are enabled:
+
+- `repos`
+- `issues`
+- `pull_requests`
+- `search`
+- `context-_ools`
+- `dynamic_tools`
+
+### Using With Docker
+
+When using Docker, you can pass the toolsets as environment variables:
+
+```bash
+docker run -i --rm \
+  -e GITHUB_PERSONAL_ACCESS_TOKEN=<your-token> \
+  -e GITHUB_TOOLSETS="repos,issues,pull_requests,code_security,experiments" \
+  ghcr.io/github/github-mcp-server
+```
+
+### The "everything" Toolset
+
+The special toolset `everything` can be provided to enable all available features regardless of any other toolsets passed:
+
+```bash
+./github-mcp-server --toolsets everything
+```
+
+Or using the environment variable:
+
+```bash
+GITHUB_TOOLSETS="everything" ./github-mcp-server
+```
+
 ## GitHub Enterprise Server
 
 The flag `--gh-host` and the environment variable `GH_HOST` can be used to set

Diff for: cmd/github-mcp-server/main.go

@@ -7,6 +7,7 @@ import (
 	stdlog "log"
 	"os"
 	"os/signal"
+	"strings"
 	"syscall"
 
 	"github.com/github/github-mcp-server/pkg/github"
@@ -43,12 +44,25 @@ var (
 			if err != nil {
 				stdlog.Fatal("Failed to initialize logger:", err)
 			}
+
+			enabledToolsets := viper.GetStringSlice("toolsets")
+
+			// Env gets precedence over command line flags
+			if envToolsets := os.Getenv("GITHUB_TOOLSETS"); envToolsets != "" {
+				enabledToolsets = []string{}
+				// Split envFeats by comma, trim whitespace, and add to the slice
+				for _, toolset := range strings.Split(envToolsets, ",") {
+					enabledToolsets = append(enabledToolsets, strings.TrimSpace(toolset))
+				}
+			}
+
 			logCommands := viper.GetBool("enable-command-logging")
 			cfg := runConfig{
 				readOnly:           readOnly,
 				logger:             logger,
 				logCommands:        logCommands,
 				exportTranslations: exportTranslations,
+				enabledToolsets:    enabledToolsets,
 			}
 			if err := runStdioServer(cfg); err != nil {
 				stdlog.Fatal("failed to run stdio server:", err)
@@ -61,13 +75,15 @@ func init() {
 	cobra.OnInitialize(initConfig)
 
 	// Add global flags that will be shared by all commands
+	rootCmd.PersistentFlags().StringSlice("toolsets", github.DefaultTools, "A comma separated list of groups of tools to enable, defaults to issues/repos/search")
 	rootCmd.PersistentFlags().Bool("read-only", false, "Restrict the server to read-only operations")
 	rootCmd.PersistentFlags().String("log-file", "", "Path to log file")
 	rootCmd.PersistentFlags().Bool("enable-command-logging", false, "When enabled, the server will log all command requests and responses to the log file")
 	rootCmd.PersistentFlags().Bool("export-translations", false, "Save translations to a JSON file")
 	rootCmd.PersistentFlags().String("gh-host", "", "Specify the GitHub hostname (for GitHub Enterprise etc.)")
 
 	// Bind flag to viper
+	_ = viper.BindPFlag("toolsets", rootCmd.PersistentFlags().Lookup("toolsets"))
 	_ = viper.BindPFlag("read-only", rootCmd.PersistentFlags().Lookup("read-only"))
 	_ = viper.BindPFlag("log-file", rootCmd.PersistentFlags().Lookup("log-file"))
 	_ = viper.BindPFlag("enable-command-logging", rootCmd.PersistentFlags().Lookup("enable-command-logging"))
@@ -106,6 +122,7 @@ type runConfig struct {
 	logger             *log.Logger
 	logCommands        bool
 	exportTranslations bool
+	enabledToolsets    []string
 }
 
 func runStdioServer(cfg runConfig) error {
@@ -140,8 +157,18 @@ func runStdioServer(cfg runConfig) error {
 	getClient := func(_ context.Context) (*gogithub.Client, error) {
 		return ghClient, nil // closing over client
 	}
-	// Create
-	ghServer := github.NewServer(getClient, version, cfg.readOnly, t)
+
+	// Create server
+	ghServer := github.NewServer(version)
+
+	// Create toolsets
+	toolsets, err := github.InitToolsets(ghServer, cfg.enabledToolsets, cfg.readOnly, getClient, t)
+	if err != nil {
+		stdlog.Fatal("Failed to initialize toolsets:", err)
+	}
+	// Register the tools with the server
+	toolsets.RegisterTools(ghServer)
+
 	stdioServer := server.NewStdioServer(ghServer)
 
 	stdLogger := stdlog.New(cfg.logger.Writer(), "stdioserver", 0)

Diff for: pkg/github/context_tools.go

@@ -0,0 +1,49 @@
+package github
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+
+	"github.com/github/github-mcp-server/pkg/translations"
+	"github.com/mark3labs/mcp-go/mcp"
+	"github.com/mark3labs/mcp-go/server"
+)
+
+// GetMe creates a tool to get details of the authenticated user.
+func GetMe(getClient GetClientFn, t translations.TranslationHelperFunc) (tool mcp.Tool, handler server.ToolHandlerFunc) {
+	return mcp.NewTool("get_me",
+			mcp.WithDescription(t("TOOL_GET_ME_DESCRIPTION", "Get details of the authenticated GitHub user. Use this when a request include \"me\", \"my\"...")),
+			mcp.WithString("reason",
+				mcp.Description("Optional: reason the session was created"),
+			),
+		),
+		func(ctx context.Context, _ mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+			client, err := getClient(ctx)
+			if err != nil {
+				return nil, fmt.Errorf("failed to get GitHub client: %w", err)
+			}
+			user, resp, err := client.Users.Get(ctx, "")
+			if err != nil {
+				return nil, fmt.Errorf("failed to get user: %w", err)
+			}
+			defer func() { _ = resp.Body.Close() }()
+
+			if resp.StatusCode != http.StatusOK {
+				body, err := io.ReadAll(resp.Body)
+				if err != nil {
+					return nil, fmt.Errorf("failed to read response body: %w", err)
+				}
+				return mcp.NewToolResultError(fmt.Sprintf("failed to get user: %s", string(body))), nil
+			}
+
+			r, err := json.Marshal(user)
+			if err != nil {
+				return nil, fmt.Errorf("failed to marshal user: %w", err)
+			}
+
+			return mcp.NewToolResultText(string(r)), nil
+		}
+}

Diff for: pkg/github/context_tools_test.go

@@ -0,0 +1,132 @@
+package github
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"testing"
+	"time"
+
+	"github.com/github/github-mcp-server/pkg/translations"
+	"github.com/google/go-github/v69/github"
+	"github.com/migueleliasweb/go-github-mock/src/mock"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_GetMe(t *testing.T) {
+	// Verify tool definition
+	mockClient := github.NewClient(nil)
+	tool, _ := GetMe(stubGetClientFn(mockClient), translations.NullTranslationHelper)
+
+	assert.Equal(t, "get_me", tool.Name)
+	assert.NotEmpty(t, tool.Description)
+	assert.Contains(t, tool.InputSchema.Properties, "reason")
+	assert.Empty(t, tool.InputSchema.Required) // No required parameters
+
+	// Setup mock user response
+	mockUser := &github.User{
+		Login:     github.Ptr("testuser"),
+		Name:      github.Ptr("Test User"),
+		Email:     github.Ptr("[email protected]"),
+		Bio:       github.Ptr("GitHub user for testing"),
+		Company:   github.Ptr("Test Company"),
+		Location:  github.Ptr("Test Location"),
+		HTMLURL:   github.Ptr("https://github.com/testuser"),
+		CreatedAt: &github.Timestamp{Time: time.Now().Add(-365 * 24 * time.Hour)},
+		Type:      github.Ptr("User"),
+		Plan: &github.Plan{
+			Name: github.Ptr("pro"),
+		},
+	}
+
+	tests := []struct {
+		name           string
+		mockedClient   *http.Client
+		requestArgs    map[string]interface{}
+		expectError    bool
+		expectedUser   *github.User
+		expectedErrMsg string
+	}{
+		{
+			name: "successful get user",
+			mockedClient: mock.NewMockedHTTPClient(
+				mock.WithRequestMatch(
+					mock.GetUser,
+					mockUser,
+				),
+			),
+			requestArgs:  map[string]interface{}{},
+			expectError:  false,
+			expectedUser: mockUser,
+		},
+		{
+			name: "successful get user with reason",
+			mockedClient: mock.NewMockedHTTPClient(
+				mock.WithRequestMatch(
+					mock.GetUser,
+					mockUser,
+				),
+			),
+			requestArgs: map[string]interface{}{
+				"reason": "Testing API",
+			},
+			expectError:  false,
+			expectedUser: mockUser,
+		},
+		{
+			name: "get user fails",
+			mockedClient: mock.NewMockedHTTPClient(
+				mock.WithRequestMatchHandler(
+					mock.GetUser,
+					http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+						w.WriteHeader(http.StatusUnauthorized)
+						_, _ = w.Write([]byte(`{"message": "Unauthorized"}`))
+					}),
+				),
+			),
+			requestArgs:    map[string]interface{}{},
+			expectError:    true,
+			expectedErrMsg: "failed to get user",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			// Setup client with mock
+			client := github.NewClient(tc.mockedClient)
+			_, handler := GetMe(stubGetClientFn(client), translations.NullTranslationHelper)
+
+			// Create call request
+			request := createMCPRequest(tc.requestArgs)
+
+			// Call handler
+			result, err := handler(context.Background(), request)
+
+			// Verify results
+			if tc.expectError {
+				require.Error(t, err)
+				assert.Contains(t, err.Error(), tc.expectedErrMsg)
+				return
+			}
+
+			require.NoError(t, err)
+
+			// Parse result and get text content if no error
+			textContent := getTextResult(t, result)
+
+			// Unmarshal and verify the result
+			var returnedUser github.User
+			err = json.Unmarshal([]byte(textContent.Text), &returnedUser)
+			require.NoError(t, err)
+
+			// Verify user details
+			assert.Equal(t, *tc.expectedUser.Login, *returnedUser.Login)
+			assert.Equal(t, *tc.expectedUser.Name, *returnedUser.Name)
+			assert.Equal(t, *tc.expectedUser.Email, *returnedUser.Email)
+			assert.Equal(t, *tc.expectedUser.Bio, *returnedUser.Bio)
+			assert.Equal(t, *tc.expectedUser.HTMLURL, *returnedUser.HTMLURL)
+			assert.Equal(t, *tc.expectedUser.Type, *returnedUser.Type)
+		})
+	}
+}