1. To run the server in a container, you will need to have[Docker](https://www.docker.com/) installed.

2.[Create a GitHub Personal Access Token](https://github.com/settings/personal-access-tokens/new).

2. Once Docker is installed, you will also need to ensure Docker is running.

3. Lastly you will need to[Create a GitHub Personal Access Token](https://github.com/settings/personal-access-tokens/new).

The MCP server can use many of the GitHub APIs, so enable the permissions that you feel comfortable granting your AI tools (to learn more about access tokens, please check out the[documentation](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens)).

-`comment_id`: The unique identifier of the comment to reply to (number, required)

-`body`: The text of the reply comment (string, required)

-**update_pull_request** - Update an existing pull request in a GitHub repository

-`owner`: Repository owner (string, required)

-`repo`: Repository name (string, required)

-`pullNumber`: Pull request number to update (number, required)

-`title`: New title (string, optional)

-`body`: New description (string, optional)

-`state`: New state ('open' or 'closed') (string, optional)

-`base`: New base branch name (string, optional)

-`maintainer_can_modify`: Allow maintainer edits (boolean, optional)

-**create_or_update_file** - Create or update a single file in a repository

-`branch`: New branch name (string, required)

-`sha`: SHA to create branch from (string, required)

-**list_commits** -Gets commits of a branch in a repository

-**list_commits** -Get a list of commits of a branch in a repository

-`owner`: Repository owner (string, required)

-`repo`: Repository name (string, required)

-`sha`: Branch name, tag, or commit SHA (string, optional)

-`path`: Only commits containing this file path (string, optional)

-`page`: Page number (number, optional)

-`perPage`: Results per page (number, optional)

-**get_commit** - Get details for a commit from a repository

-`owner`: Repository owner (string, required)

-`repo`: Repository name (string, required)

-`sha`: Commit SHA, branch name, or tag name (string, required)

-`page`: Page number, for files in the commit (number, optional)

-`perPage`: Results per page, for files in the commit (number, optional)

-**search_code** - Search for code across GitHub repositories

package main

import (

stdlog"log"

logFile:=viper.GetString("log-file")

readOnly:=viper.GetBool("read-only")

exportTranslations:=viper.GetBool("export-translations")

prettyPrintJSON:=viper.GetBool("pretty-print-json")

logger,err:=initLogger(logFile)

iferr!=nil {

stdlog.Fatal("Failed to initialize logger:",err)

logger:logger,

logCommands:logCommands,

exportTranslations:exportTranslations,

prettyPrintJSON:prettyPrintJSON,

}

iferr:=runStdioServer(cfg);err!=nil {

stdlog.Fatal("failed to run stdio server:",err)

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.)")

rootCmd.PersistentFlags().Bool("pretty-print-json",false,"Pretty print JSON output")

_=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("pretty-print-json",rootCmd.PersistentFlags().Lookup("pretty-print-json"))

rootCmd.AddCommand(stdioCmd)

logger*log.Logger

}

typeJSONPrettyPrintWriterstruct {

writer io.Writer

}

func (jJSONPrettyPrintWriter)Write(p []byte) (nint,errerror) {

varprettyJSON bytes.Buffer

iferr:=json.Indent(&prettyJSON,p,"","\t");err!=nil {

return0,err

}

returnj.writer.Write(prettyJSON.Bytes())

}

funcrunStdioServer(cfgrunConfig)error {

t,dumpTranslations:=translations.TranslationHelper()

getClient:=func(_ context.Context) (*gogithub.Client,error) {

returnghClient,nil// closing over client

}

ghServer:=github.NewServer(ghClient,version,cfg.readOnly,t)

ghServer:=github.NewServer(getClient,version,cfg.readOnly,t)

stdioServer:=server.NewStdioServer(ghServer)

stdLogger:=stdlog.New(cfg.logger.Writer(),"stdioserver",0)

in,out=loggedIO,loggedIO

}

ifcfg.prettyPrintJSON {

out=JSONPrettyPrintWriter{writer:out}

}

errC<-stdioServer.Listen(ctx,in,out)

}()

)

funcGetCodeScanningAlert(client*github.Client,t translations.TranslationHelperFunc) (tool mcp.Tool,handler server.ToolHandlerFunc) {

funcGetCodeScanningAlert(getClientGetClientFn,t translations.TranslationHelperFunc) (tool mcp.Tool,handler server.ToolHandlerFunc) {

returnmcp.NewTool("get_code_scanning_alert",

mcp.WithDescription(t("TOOL_GET_CODE_SCANNING_ALERT_DESCRIPTION","Get details of a specific code scanning alert in a GitHub repository.")),

mcp.WithString("owner",

returnmcp.NewToolResultError(err.Error()),nil

}

client,err:=getClient(ctx)

iferr!=nil {

returnnil,fmt.Errorf("failed to get GitHub client: %w",err)

}

alert,resp,err:=client.CodeScanning.GetAlert(ctx,owner,repo,int64(alertNumber))

iferr!=nil {

returnnil,fmt.Errorf("failed to get alert: %w",err)

}

}

funcListCodeScanningAlerts(client*github.Client,t translations.TranslationHelperFunc) (tool mcp.Tool,handler server.ToolHandlerFunc) {

funcListCodeScanningAlerts(getClientGetClientFn,t translations.TranslationHelperFunc) (tool mcp.Tool,handler server.ToolHandlerFunc) {

returnmcp.NewTool("list_code_scanning_alerts",

mcp.WithDescription(t("TOOL_LIST_CODE_SCANNING_ALERTS_DESCRIPTION","List code scanning alerts in a GitHub repository.")),

mcp.WithString("owner",

returnmcp.NewToolResultError(err.Error()),nil

}

client,err:=getClient(ctx)

iferr!=nil {

returnnil,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})

iferr!=nil {

returnnil,fmt.Errorf("failed to list alerts: %w",err)

funcTest_GetCodeScanningAlert(t*testing.T) {

mockClient:=github.NewClient(nil)

tool,_:=GetCodeScanningAlert(mockClient,translations.NullTranslationHelper)

tool,_:=GetCodeScanningAlert(stubGetClientFn(mockClient),translations.NullTranslationHelper)

assert.Equal(t,"get_code_scanning_alert",tool.Name)

assert.NotEmpty(t,tool.Description)

t.Run(tc.name,func(t*testing.T) {

client:=github.NewClient(tc.mockedClient)

_,handler:=GetCodeScanningAlert(client,translations.NullTranslationHelper)

_,handler:=GetCodeScanningAlert(stubGetClientFn(client),translations.NullTranslationHelper)

request:=createMCPRequest(tc.requestArgs)

funcTest_ListCodeScanningAlerts(t*testing.T) {

mockClient:=github.NewClient(nil)

tool,_:=ListCodeScanningAlerts(mockClient,translations.NullTranslationHelper)

tool,_:=ListCodeScanningAlerts(stubGetClientFn(mockClient),translations.NullTranslationHelper)

assert.Equal(t,"list_code_scanning_alerts",tool.Name)

assert.NotEmpty(t,tool.Description)

t.Run(tc.name,func(t*testing.T) {

client:=github.NewClient(tc.mockedClient)

_,handler:=ListCodeScanningAlerts(client,translations.NullTranslationHelper)

_,handler:=ListCodeScanningAlerts(stubGetClientFn(client),translations.NullTranslationHelper)

request:=createMCPRequest(tc.requestArgs)

assert.Equal(t,"text",textContent.Type)

}

funcTestOptionalParamOK(t*testing.T) {

tests:= []struct {

argsmap[string]interface{}

expectedValinterface{}

}{

{

name:"present and correct type (string)",

args:map[string]interface{}{"myParam":"hello"},

paramName:"myParam",

expectedVal:"hello",

expectedOk:true,

expectError:false,

},

{

name:"present and correct type (bool)",

args:map[string]interface{}{"myParam":true},

paramName:"myParam",

expectedVal:true,

expectedOk:true,

expectError:false,

},

{

name:"present and correct type (number)",

args:map[string]interface{}{"myParam":float64(123)},

paramName:"myParam",

expectedVal:float64(123),

expectedOk:true,

expectError:false,

},

{

name:"present but wrong type (string expected, got bool)",

args:map[string]interface{}{"myParam":true},

paramName:"myParam",

expectedVal:"",// Zero value for string

expectedOk:true,// ok is true because param exists

expectError:true,

errorMsg:"parameter myParam is not of type string, is bool",

},

{

name:"present but wrong type (bool expected, got string)",

args:map[string]interface{}{"myParam":"true"},

paramName:"myParam",

expectedVal:false,// Zero value for bool

expectedOk:true,// ok is true because param exists

expectError:true,

errorMsg:"parameter myParam is not of type bool, is string",

},

{

name:"parameter not present",

args:map[string]interface{}{"anotherParam":"value"},

paramName:"myParam",

expectedVal:"",// Zero value for string

expectedOk:false,

expectError:false,

},

}

for_,tc:=rangetests {

t.Run(tc.name,func(t*testing.T) {

request:=createMCPRequest(tc.args)

if_,isString:=tc.expectedVal.(string);isString||tc.errorMsg=="parameter myParam is not of type string, is bool" {

val,ok,err:=OptionalParamOK[string](request,tc.paramName)

iftc.expectError {

require.Error(t,err)

assert.Contains(t,err.Error(),tc.errorMsg)

assert.Equal(t,tc.expectedOk,ok)// Check ok even on error

assert.Equal(t,tc.expectedVal,val)// Check zero value on error

}else {

require.NoError(t,err)

assert.Equal(t,tc.expectedOk,ok)

assert.Equal(t,tc.expectedVal,val)

}

}

if_,isBool:=tc.expectedVal.(bool);isBool||tc.errorMsg=="parameter myParam is not of type bool, is string" {

val,ok,err:=OptionalParamOK[bool](request,tc.paramName)

iftc.expectError {

require.Error(t,err)

assert.Contains(t,err.Error(),tc.errorMsg)

assert.Equal(t,tc.expectedOk,ok)// Check ok even on error

assert.Equal(t,tc.expectedVal,val)// Check zero value on error

}else {

require.NoError(t,err)

assert.Equal(t,tc.expectedOk,ok)

assert.Equal(t,tc.expectedVal,val)

}

}

if_,isFloat:=tc.expectedVal.(float64);isFloat {

val,ok,err:=OptionalParamOK[float64](request,tc.paramName)

iftc.expectError {

require.Fail(t,"Unexpected error case for float64")

}else {

require.NoError(t,err)

assert.Equal(t,tc.expectedOk,ok)

assert.Equal(t,tc.expectedVal,val)

}

}

})

}

}