uses:docker/metadata-action@96383f45573cb7f253c731d3b3ab81c87ef81934# v5.0.0

with:

images:${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}

tags:|

-name:Go Build Cache for Docker

uses:actions/cache@v4

-"v*"

permissions:

contents:write

id-token:write

attestations:write

jobs:

release:

workdir:.

env:

GITHUB_TOKEN:${{ secrets.GITHUB_TOKEN }}

-name:Generate signed build provenance attestations for workflow artifacts

uses:actions/attest-build-provenance@v2

with:

subject-path:|

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

-`draft`: Create as draft PR (boolean, optional)

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

-**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

-`prNumber`: Pull request number (string, required)

-`path`: File or directory path (string, optional)

The exported Go API of this module should currently be considered unstable, and subject to breaking changes. In the future, we may offer stability; please file an issue if there is a use case where this would be valuable.

This project is licensed under the terms of the MIT open source license. Please refer to[MIT](./LICENSE) for the full terms.

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)

}()

create_repository Create a new GitHub repositoryin your account

fork_repository Fork a GitHub repository to your account or specified organization

get_file_contents Get the contents of a file or directory from a GitHub repository

get_issue Get details of a specific issuein a GitHub repository.

get_issue Get details of a specific issuein a GitHub repository

get_issue_comments Get commentsfor a GitHub issue

list_commits Get list of commits of a branchin a GitHub repository

list_issues List issuesin a GitHub repository with filtering options

% ./mcpcurl --stdio-server-cmd"docker run -i --rm -e GITHUB_PERSONAL_ACCESS_TOKEN mcp/github" tools get_issue --help

Get details of a specific issuein a GitHub repository.

Get details of a specific issuein a GitHub repository

Usage:

mcpcurl tools get_issue [flags]

)

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",

iferr!=nil {

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

}

alertNumber,err:=requiredInt(request,"alertNumber")

alertNumber,err:=RequiredInt(request,"alertNumber")

iferr!=nil {

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",

iferr!=nil {

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

}

ref,err:=optionalParam[string](request,"ref")

ref,err:=OptionalParam[string](request,"ref")

iferr!=nil {

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

}

state,err:=optionalParam[string](request,"state")

state,err:=OptionalParam[string](request,"state")

iferr!=nil {

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

}

severity,err:=optionalParam[string](request,"severity")

severity,err:=OptionalParam[string](request,"severity")

iferr!=nil {

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)