Merge branch 'main' into issues-196

Author: aryasoni98

README.md

@@ -147,10 +147,24 @@ More about using MCP server tools in VS Code's [agent mode documentation](https:
 
 ### Build from source
 
-If you don't have Docker, you can use `go` to build the binary in the
-`cmd/github-mcp-server` directory, and use the `github-mcp-server stdio`
-command with the `GITHUB_PERSONAL_ACCESS_TOKEN` environment variable set to
-your token.
+If you don't have Docker, you can use `go build` to build the binary in the
+`cmd/github-mcp-server` directory, and use the `github-mcp-server stdio` command with the `GITHUB_PERSONAL_ACCESS_TOKEN` environment variable set to your token. To specify the output location of the build, use the `-o` flag. You should configure your server to use the built executable as its `command`. For example:
+
+```JSON
+{
+  "mcp": {
+    "servers": {
+      "github": {
+        "command": "/path/to/github-mcp-server",
+        "args": ["stdio"],
+        "env": {
+          "GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_TOKEN>"
+        }
+      }
+    }
+  }
+}
+```
 
 ## GitHub Enterprise Server
 
@@ -471,6 +485,7 @@ export GITHUB_MCP_TOOL_ADD_ISSUE_COMMENT_DESCRIPTION="an alternative description
   - `ref`: Git reference (string, optional)
   - `state`: Alert state (string, optional)
   - `severity`: Alert severity (string, optional)
+  - `tool_name`: The name of the tool used for code scanning (string, optional)
 
 ## Resources
 

cmd/github-mcp-server/main.go

@@ -29,7 +29,7 @@ var (
 		Use:     "server",
 		Short:   "GitHub MCP Server",
 		Long:    `A GitHub MCP server that handles various tools and resources.`,
-		Version: fmt.Sprintf("%s (%s) %s", version, commit, date),
+		Version: fmt.Sprintf("Version: %s\nCommit: %s\nBuild Date: %s", version, commit, date),
 	}
 
 	stdioCmd = &cobra.Command{
@@ -44,12 +44,16 @@ var (
 			if err != nil {
 				stdlog.Fatal("Failed to initialize logger:", err)
 			}
+
+			enabledToolsets := viper.GetStringSlice("toolsets")
+
 			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,27 +65,33 @@ var (
 func init() {
 	cobra.OnInitialize(initConfig)
 
+	rootCmd.SetVersionTemplate("{{.Short}}\n{{.Version}}\n")
+
 	// Add global flags that will be shared by all commands
+	rootCmd.PersistentFlags().StringSlice("toolsets", github.DefaultTools, "An optional comma separated list of groups of tools to allow, defaults to enabling all")
+	rootCmd.PersistentFlags().Bool("dynamic-toolsets", false, "Enable dynamic toolsets")
 	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("dynamic_toolsets", rootCmd.PersistentFlags().Lookup("dynamic-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"))
 	_ = viper.BindPFlag("export-translations", rootCmd.PersistentFlags().Lookup("export-translations"))
-	_ = viper.BindPFlag("gh-host", rootCmd.PersistentFlags().Lookup("gh-host"))
+	_ = viper.BindPFlag("host", rootCmd.PersistentFlags().Lookup("gh-host"))
 
 	// Add subcommands
 	rootCmd.AddCommand(stdioCmd)
 }
 
 func initConfig() {
 	// Initialize Viper configuration
-	viper.SetEnvPrefix("APP")
+	viper.SetEnvPrefix("github")
 	viper.AutomaticEnv()
 }
 
@@ -107,6 +117,7 @@ type runConfig struct {
 	logger             *log.Logger
 	logCommands        bool
 	exportTranslations bool
+	enabledToolsets    []string
 }
 
 func runStdioServer(cfg runConfig) error {
@@ -115,18 +126,14 @@ func runStdioServer(cfg runConfig) error {
 	defer stop()
 
 	// Create GH client
-	token := os.Getenv("GITHUB_PERSONAL_ACCESS_TOKEN")
+	token := viper.GetString("personal_access_token")
 	if token == "" {
 		cfg.logger.Fatal("GITHUB_PERSONAL_ACCESS_TOKEN not set")
 	}
 	ghClient := gogithub.NewClient(nil).WithAuthToken(token)
 	ghClient.UserAgent = fmt.Sprintf("github-mcp-server/%s", version)
 
-	// Check GH_HOST env var first, then fall back to viper config
-	host := os.Getenv("GH_HOST")
-	if host == "" {
-		host = viper.GetString("gh-host")
-	}
+	host := viper.GetString("host")
 
 	if host != "" {
 		var err error
@@ -149,8 +156,40 @@ func runStdioServer(cfg runConfig) error {
 	hooks := &server.Hooks{
 		OnBeforeInitialize: []server.OnBeforeInitializeFunc{beforeInit},
 	}
-	// Create
-	ghServer := github.NewServer(getClient, version, cfg.readOnly, t, server.WithHooks(hooks))
+	// Create server
+	ghServer := github.NewServer(version, server.WithHooks(hooks))
+
+	enabled := cfg.enabledToolsets
+	dynamic := viper.GetBool("dynamic_toolsets")
+	if dynamic {
+		// filter "all" from the enabled toolsets
+		enabled = make([]string, 0, len(cfg.enabledToolsets))
+		for _, toolset := range cfg.enabledToolsets {
+			if toolset != "all" {
+				enabled = append(enabled, toolset)
+			}
+		}
+	}
+
+	// Create default toolsets
+	toolsets, err := github.InitToolsets(enabled, cfg.readOnly, getClient, t)
+	context := github.InitContextToolset(getClient, t)
+
+	if err != nil {
+		stdlog.Fatal("Failed to initialize toolsets:", err)
+	}
+
+	// Register resources with the server
+	github.RegisterResources(ghServer, getClient, t)
+	// Register the tools with the server
+	toolsets.RegisterTools(ghServer)
+	context.RegisterTools(ghServer)
+
+	if dynamic {
+		dynamic := github.InitDynamicToolset(ghServer, toolsets, t)
+		dynamic.RegisterTools(ghServer)
+	}
+
 	stdioServer := server.NewStdioServer(ghServer)
 
 	stdLogger := stdlog.New(cfg.logger.Writer(), "stdioserver", 0)

go.mod

@@ -6,7 +6,7 @@ require (
 	github.com/docker/docker v28.0.4+incompatible
 	github.com/google/go-cmp v0.7.0
 	github.com/google/go-github/v69 v69.2.0
-	github.com/mark3labs/mcp-go v0.18.0
+	github.com/mark3labs/mcp-go v0.20.1
 	github.com/migueleliasweb/go-github-mock v1.1.0
 	github.com/sirupsen/logrus v1.9.3
 	github.com/spf13/cobra v1.9.1

go.sum

@@ -57,8 +57,8 @@ github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/mark3labs/mcp-go v0.18.0 h1:YuhgIVjNlTG2ZOwmrkORWyPTp0dz1opPEqvsPtySXao=
-github.com/mark3labs/mcp-go v0.18.0/go.mod h1:KmJndYv7GIgcPVwEKJjNcbhVQ+hJGJhrCCB/9xITzpE=
+github.com/mark3labs/mcp-go v0.20.1 h1:E1Bbx9K8d8kQmDZ1QHblM38c7UU2evQ2LlkANk1U/zw=
+github.com/mark3labs/mcp-go v0.20.1/go.mod h1:KmJndYv7GIgcPVwEKJjNcbhVQ+hJGJhrCCB/9xITzpE=
 github.com/migueleliasweb/go-github-mock v1.1.0 h1:GKaOBPsrPGkAKgtfuWY8MclS1xR6MInkx1SexJucMwE=
 github.com/migueleliasweb/go-github-mock v1.1.0/go.mod h1:pYe/XlGs4BGMfRY4vmeixVsODHnVDDhJ9zoi0qzSMHc=
 github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0=

pkg/github/code_scanning.go

@@ -86,11 +86,16 @@ func ListCodeScanningAlerts(getClient GetClientFn, t translations.TranslationHel
 				mcp.Description("The Git reference for the results you want to list."),
 			),
 			mcp.WithString("state",
-				mcp.Description("State of the code scanning alerts to list. Set to closed to list only closed code scanning alerts. Default: open"),
+				mcp.Description("Filter code scanning alerts by state. Defaults to open"),
 				mcp.DefaultString("open"),
+				mcp.Enum("open", "closed", "dismissed", "fixed"),
 			),
 			mcp.WithString("severity",
-				mcp.Description("Only code scanning alerts with this severity will be returned. Possible values are: critical, high, medium, low, warning, note, error."),
+				mcp.Description("Filter code scanning alerts by severity"),
+				mcp.Enum("critical", "high", "medium", "low", "warning", "note", "error"),
+			),
+			mcp.WithString("tool_name",
+				mcp.Description("The name of the tool used for code scanning."),
 			),
 		),
 		func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
@@ -114,12 +119,16 @@ func ListCodeScanningAlerts(getClient GetClientFn, t translations.TranslationHel
 			if err != nil {
 				return mcp.NewToolResultError(err.Error()), nil
 			}
+			toolName, err := OptionalParam[string](request, "tool_name")
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
 
 			client, err := getClient(ctx)
 			if err != nil {
 				return nil, fmt.Errorf("failed to get GitHub client: %w", err)
 			}
-			alerts, resp, err := client.CodeScanning.ListAlertsForRepo(ctx, owner, repo, &github.AlertListOptions{Ref: ref, State: state, Severity: severity})
+			alerts, resp, err := client.CodeScanning.ListAlertsForRepo(ctx, owner, repo, &github.AlertListOptions{Ref: ref, State: state, Severity: severity, ToolName: toolName})
 			if err != nil {
 				return nil, fmt.Errorf("failed to list alerts: %w", err)
 			}

pkg/github/code_scanning_test.go

@@ -127,6 +127,7 @@ func Test_ListCodeScanningAlerts(t *testing.T) {
 	assert.Contains(t, tool.InputSchema.Properties, "ref")
 	assert.Contains(t, tool.InputSchema.Properties, "state")
 	assert.Contains(t, tool.InputSchema.Properties, "severity")
+	assert.Contains(t, tool.InputSchema.Properties, "tool_name")
 	assert.ElementsMatch(t, tool.InputSchema.Required, []string{"owner", "repo"})
 
 	// Setup mock alerts for success case
@@ -159,20 +160,22 @@ func Test_ListCodeScanningAlerts(t *testing.T) {
 				mock.WithRequestMatchHandler(
 					mock.GetReposCodeScanningAlertsByOwnerByRepo,
 					expectQueryParams(t, map[string]string{
-						"ref":      "main",
-						"state":    "open",
-						"severity": "high",
+						"ref":       "main",
+						"state":     "open",
+						"severity":  "high",
+						"tool_name": "codeql",
 					}).andThen(
 						mockResponse(t, http.StatusOK, mockAlerts),
 					),
 				),
 			),
 			requestArgs: map[string]interface{}{
-				"owner":    "owner",
-				"repo":     "repo",
-				"ref":      "main",
-				"state":    "open",
-				"severity": "high",
+				"owner":     "owner",
+				"repo":      "repo",
+				"ref":       "main",
+				"state":     "open",
+				"severity":  "high",
+				"tool_name": "codeql",
 			},
 			expectError:    false,
 			expectedAlerts: mockAlerts,

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
+		}
+}