package github

import (

"context"

"encoding/json"

"fmt"

"io"

"net/http"

"slices"

"github.com/go-viper/mapstructure/v2"

"github.com/google/go-github/v92/github"

"github.com/google/jsonschema-go/jsonschema"

"github.com/modelcontextprotocol/go-sdk/mcp"

"github.com/shurcooL/githubv4"

ghErrors "github.com/github/github-mcp-server/v2/pkg/errors"

"github.com/github/github-mcp-server/v2/pkg/ifc"

"github.com/github/github-mcp-server/v2/pkg/inventory"

"github.com/github/github-mcp-server/v2/pkg/octicons"

"github.com/github/github-mcp-server/v2/pkg/scopes"

"github.com/github/github-mcp-server/v2/pkg/translations"

"github.com/github/github-mcp-server/v2/pkg/utils"

)

// PullRequestRead creates a tool to get details of a specific pull request.

func PullRequestRead(t translations.TranslationHelperFunc) inventory.ServerTool {

schema := &jsonschema.Schema{

Type: "object",

Properties: map[string]*jsonschema.Schema{

"method": {

Type: "string",

Description: `Action to specify what pull request data needs to be retrieved from GitHub.

Possible options:

1. get - Get details of a specific pull request.

2. get_diff - Get the diff of a pull request.

3. get_status - Get combined commit status of a head commit in a pull request.

4. get_files - Get the list of files changed in a pull request. Use with pagination parameters to control the number of results returned.

5. get_commits - Get the list of commits on a pull request. Use with pagination parameters to control the number of results returned.

6. get_review_comments - Get review threads on a pull request. Each thread contains logically grouped review comments made on the same code location during pull request reviews. Returns thread metadata and comments with nullable current and original line-range coordinates (line, start_line, original_line, original_start_line). Current coordinates are omitted when unavailable, such as for outdated comments. Use cursor-based pagination (perPage, after) to control results.

7. get_reviews - Get the reviews on a pull request. When asked for review comments, use get_review_comments method. Use with pagination parameters to control the number of results returned.

8. get_comments - Get comments on a pull request. Use this if user doesn't specifically want review comments. Use with pagination parameters to control the number of results returned.

9. get_check_runs - Get check runs for the head commit of a pull request. Check runs are the individual CI/CD jobs and checks that run on the PR.

`,

Enum: []any{"get", "get_diff", "get_status", "get_files", "get_commits", "get_review_comments", "get_reviews", "get_comments", "get_check_runs"},

},

"owner": {

Type: "string",

Description: "Repository owner",

},

"repo": {

Type: "string",

Description: "Repository name",

},

"pullNumber": {

Type: "number",

Description: "Pull request number",

},

},

Required: []string{"method", "owner", "repo", "pullNumber"},

}

WithPagination(schema)

// get_review_comments uses GraphQL cursor-based pagination and accepts the

// `after` cursor. Other methods rely on the `page`/`perPage` parameters

// added by WithPagination and ignore `after`.

schema.Properties["after"] = &jsonschema.Schema{

Type: "string",

Description: "Cursor for pagination, used only by the get_review_comments method. Pass the endCursor from the previous page's PageInfo to fetch the next page.",

}

return NewTool[PullRequestReadInput, *PullRequestReadOutput](

ToolsetMetadataPullRequests,

mcp.Tool{

Name: "pull_request_read",

OutputSchema: pullRequestReadOutputSchema(),

Description: t("TOOL_PULL_REQUEST_READ_DESCRIPTION", "Get information on a specific pull request in GitHub repository."),

Annotations: &mcp.ToolAnnotations{

Title: t("TOOL_GET_PULL_REQUEST_USER_TITLE", "Get details for a single pull request"),

ReadOnlyHint: true,

},

InputSchema: schema,

},

scopes.PublicRead(scopes.Repo),

func(ctx context.Context, deps ToolDependencies, _ *mcp.CallToolRequest, input PullRequestReadInput) (*mcp.CallToolResult, *PullRequestReadOutput, error) {

args, err := discussionNotificationArguments(input)

if err != nil {

return nil, nil, err

}

method, err := RequiredParam[string](args, "method")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

owner, err := RequiredParam[string](args, "owner")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

repo, err := RequiredParam[string](args, "repo")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

pullNumber, err := RequiredInt(args, "pullNumber")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

pagination, err := OptionalPaginationParams(args)

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

client, err := deps.GetClient(ctx)

if err != nil {

return utils.NewToolResultErrorFromErr("failed to get GitHub client", err), nil, nil

}

// attachIFC adds the IFC label to a successful tool result when

// IFC labels are enabled. Pull request content (descriptions,

// diffs, comments, reviews) is user-authored and therefore

// untrusted; confidentiality follows repo visibility. If the

// visibility lookup fails the label is omitted rather than

// misclassifying the result.

attachIFC := func(r *mcp.CallToolResult) *mcp.CallToolResult {

return attachRepoVisibilityIFCLabel(ctx, deps, client, owner, repo, r, ifc.LabelRepoUserContent)

}

switch method {

case "get":

result, output, err := getPullRequest(ctx, client, deps, owner, repo, pullNumber)

return attachIFC(result), output, err

case "get_diff":

result, output, err := getPullRequestDiff(ctx, client, deps, owner, repo, pullNumber)

return attachIFC(result), output, err

case "get_status":

result, output, err := getPullRequestStatus(ctx, client, owner, repo, pullNumber)

return attachIFC(result), output, err

case "get_files":

result, output, err := getPullRequestFiles(ctx, client, deps, owner, repo, pullNumber, pagination)

return attachIFC(result), output, err

case "get_commits":

result, output, err := getPullRequestCommits(ctx, client, deps, owner, repo, pullNumber, pagination)

return attachIFC(result), output, err

case "get_review_comments":

gqlClient, err := deps.GetGQLClient(ctx)

if err != nil {

return utils.NewToolResultErrorFromErr("failed to get GitHub GQL client", err), nil, nil

}

cursorPagination, err := OptionalCursorPaginationParams(args)

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

result, output, err := getPullRequestReviewComments(ctx, gqlClient, deps, owner, repo, pullNumber, cursorPagination)

return attachIFC(result), output, err

case "get_reviews":

result, output, err := getPullRequestReviews(ctx, client, deps, owner, repo, pullNumber, pagination)

return attachIFC(result), output, err

case "get_comments":

result, output, err := getIssueComments(ctx, client, deps, owner, repo, pullNumber, pagination)

return attachIFC(result), pullRequestCommentsOutput(output), err

case "get_check_runs":

result, output, err := getPullRequestCheckRuns(ctx, client, owner, repo, pullNumber, pagination)

return attachIFC(result), output, err

default:

return utils.NewToolResultError(fmt.Sprintf("unknown method: %s", method)), nil, nil

}

}, normalizePullRequestArguments("read"))

}

func GetPullRequest(ctx context.Context, client *github.Client, deps ToolDependencies, owner, repo string, pullNumber int) (*mcp.CallToolResult, error) {

result, _, err := getPullRequest(ctx, client, deps, owner, repo, pullNumber)

return result, err

}

func getPullRequest(ctx context.Context, client *github.Client, deps ToolDependencies, owner, repo string, pullNumber int) (*mcp.CallToolResult, *PullRequestReadOutput, error) {

cache, err := deps.GetRepoAccessCache(ctx)

if err != nil {

return nil, nil, fmt.Errorf("failed to get repo access cache: %w", err)

}

ff := deps.GetFlags(ctx)

pr, resp, err := client.PullRequests.Get(ctx, owner, repo, pullNumber)

if err != nil {

return ghErrors.NewGitHubAPIErrorResponse(ctx,

"failed to get pull request",

resp,

err,

), nil, nil

}

defer func() { _ = resp.Body.Close() }()

if resp.StatusCode != http.StatusOK {

body, err := io.ReadAll(resp.Body)

if err != nil {

return nil, nil, fmt.Errorf("failed to read response body: %w", err)

}

return ghErrors.NewGitHubAPIStatusErrorResponse(ctx, "failed to get pull request", resp, body), nil, nil

}

if pr == nil {

return utils.NewToolResultText("null"), &PullRequestReadOutput{}, nil

}

if ff.LockdownMode {

if restricted, err := authorLockdownResult(ctx, cache, owner, repo, pr.GetUser().GetLogin(), lockdownPullRequestRestrictedMessage); restricted != nil || err != nil {

return restricted, nil, err

}

}

minimalPR := convertToMinimalPullRequest(pr)

return MarshalledTextResult(minimalPR), &PullRequestReadOutput{PullRequest: &minimalPR}, nil

}

// enforcePullRequestLockdown returns a restricted tool result when lockdown mode is

// enabled and the pull request author is not a safe content source for owner/repo,

// and (nil, nil) otherwise. It fetches the pull request to resolve the author and is

// a no-op that performs no request when lockdown mode is disabled.

func enforcePullRequestLockdown(ctx context.Context, client *github.Client, deps ToolDependencies, owner, repo string, pullNumber int) (*mcp.CallToolResult, error) {

if !deps.GetFlags(ctx).LockdownMode {

return nil, nil

}

cache, err := deps.GetRepoAccessCache(ctx)

if err != nil {

return nil, fmt.Errorf("failed to get repo access cache: %w", err)

}

pr, resp, err := client.PullRequests.Get(ctx, owner, repo, pullNumber)

if err != nil {

return ghErrors.NewGitHubAPIErrorResponse(ctx, "failed to get pull request", resp, err), nil

}

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 ghErrors.NewGitHubAPIStatusErrorResponse(ctx, "failed to get pull request", resp, body), nil

}

return authorLockdownResult(ctx, cache, owner, repo, pr.GetUser().GetLogin(), lockdownPullRequestRestrictedMessage)

}

func GetPullRequestDiff(ctx context.Context, client *github.Client, deps ToolDependencies, owner, repo string, pullNumber int) (*mcp.CallToolResult, error) {

result, _, err := getPullRequestDiff(ctx, client, deps, owner, repo, pullNumber)

return result, err

}

func getPullRequestDiff(ctx context.Context, client *github.Client, deps ToolDependencies, owner, repo string, pullNumber int) (*mcp.CallToolResult, *PullRequestReadOutput, error) {

if restricted, err := enforcePullRequestLockdown(ctx, client, deps, owner, repo, pullNumber); restricted != nil || err != nil {

return restricted, nil, err

}

raw, resp, err := client.PullRequests.GetRaw(

ctx,

owner,

repo,

pullNumber,

github.RawOptions{Type: github.Diff},

)

if err != nil {

return ghErrors.NewGitHubAPIErrorResponse(ctx,

"failed to get pull request diff",

resp,

err,

), nil, nil

}

if resp.StatusCode != http.StatusOK {

body, err := io.ReadAll(resp.Body)

if err != nil {

return nil, nil, fmt.Errorf("failed to read response body: %w", err)

}

return ghErrors.NewGitHubAPIStatusErrorResponse(ctx, "failed to get pull request diff", resp, body), nil, nil

}

defer func() { _ = resp.Body.Close() }()

// Return the raw response

return utils.NewToolResultText(string(raw)), &PullRequestReadOutput{Diff: &PullRequestDiffOutput{Diff: string(raw)}}, nil

}

func GetPullRequestStatus(ctx context.Context, client *github.Client, owner, repo string, pullNumber int) (*mcp.CallToolResult, error) {

result, _, err := getPullRequestStatus(ctx, client, owner, repo, pullNumber)

return result, err

}

func getPullRequestStatus(ctx context.Context, client *github.Client, owner, repo string, pullNumber int) (*mcp.CallToolResult, *PullRequestReadOutput, error) {

pr, resp, err := client.PullRequests.Get(ctx, owner, repo, pullNumber)

if err != nil {

return ghErrors.NewGitHubAPIErrorResponse(ctx,

"failed to get pull request",

resp,

err,

), nil, nil

}

defer func() { _ = resp.Body.Close() }()

if resp.StatusCode != http.StatusOK {

body, err := io.ReadAll(resp.Body)

if err != nil {

return nil, nil, fmt.Errorf("failed to read response body: %w", err)

}

return ghErrors.NewGitHubAPIStatusErrorResponse(ctx, "failed to get pull request", resp, body), nil, nil

}

// Get combined status for the head SHA

status, resp, err := client.Repositories.GetCombinedStatus(ctx, owner, repo, *pr.Head.SHA, nil)

if err != nil {

return ghErrors.NewGitHubAPIErrorResponse(ctx,

"failed to get combined status",

resp,

err,

), nil, nil

}

defer func() { _ = resp.Body.Close() }()

if resp.StatusCode != http.StatusOK {

body, err := io.ReadAll(resp.Body)

if err != nil {

return nil, nil, fmt.Errorf("failed to read response body: %w", err)

}

return ghErrors.NewGitHubAPIStatusErrorResponse(ctx, "failed to get combined status", resp, body), nil, nil

}

minimalStatus := convertToMinimalCombinedStatus(status)

r, err := json.Marshal(minimalStatus)

if err != nil {

return nil, nil, fmt.Errorf("failed to marshal response: %w", err)

}

return utils.NewToolResultText(string(r)), &PullRequestReadOutput{Status: &minimalStatus}, nil

}

func GetPullRequestCheckRuns(ctx context.Context, client *github.Client, owner, repo string, pullNumber int, pagination PaginationParams) (*mcp.CallToolResult, error) {

result, _, err := getPullRequestCheckRuns(ctx, client, owner, repo, pullNumber, pagination)

return result, err

}

func getPullRequestCheckRuns(ctx context.Context, client *github.Client, owner, repo string, pullNumber int, pagination PaginationParams) (*mcp.CallToolResult, *PullRequestReadOutput, error) {

// First get the PR to get the head SHA

pr, resp, err := client.PullRequests.Get(ctx, owner, repo, pullNumber)

if err != nil {

return ghErrors.NewGitHubAPIErrorResponse(ctx,

"failed to get pull request",

resp,

err,

), nil, nil

}

defer resp.Body.Close()

if resp.StatusCode != http.StatusOK {

body, err := io.ReadAll(resp.Body)

if err != nil {

return nil, nil, fmt.Errorf("failed to read response body: %w", err)

}

return ghErrors.NewGitHubAPIStatusErrorResponse(ctx, "failed to get pull request", resp, body), nil, nil

}

// Get check runs for the head SHA

opts := &github.ListCheckRunsOptions{

PerPage: pagination.PerPage,

Page: pagination.Page,

}

checkRuns, resp, err := client.Checks.ListCheckRunsForRef(ctx, owner, repo, *pr.Head.SHA, opts)

if err != nil {

return ghErrors.NewGitHubAPIErrorResponse(ctx,

"failed to get check runs",

resp,

err,

), nil, nil

}

defer resp.Body.Close()

if resp.StatusCode != http.StatusOK {

body, err := io.ReadAll(resp.Body)

if err != nil {

return nil, nil, fmt.Errorf("failed to read response body: %w", err)

}

return ghErrors.NewGitHubAPIStatusErrorResponse(ctx, "failed to get check runs", resp, body), nil, nil

}

// Convert to minimal check runs to reduce context usage

minimalCheckRuns := make([]MinimalCheckRun, 0, len(checkRuns.CheckRuns))

for _, checkRun := range checkRuns.CheckRuns {

minimalCheckRuns = append(minimalCheckRuns, convertToMinimalCheckRun(checkRun))

}

minimalResult := MinimalCheckRunsResult{

TotalCount: checkRuns.GetTotal(),

CheckRuns: minimalCheckRuns,

}

r, err := json.Marshal(minimalResult)

if err != nil {

return nil, nil, fmt.Errorf("failed to marshal response: %w", err)

}

return utils.NewToolResultText(string(r)), &PullRequestReadOutput{CheckRuns: &minimalResult}, nil

}

func GetPullRequestFiles(ctx context.Context, client *github.Client, deps ToolDependencies, owner, repo string, pullNumber int, pagination PaginationParams) (*mcp.CallToolResult, error) {

result, _, err := getPullRequestFiles(ctx, client, deps, owner, repo, pullNumber, pagination)

return result, err

}

func getPullRequestFiles(ctx context.Context, client *github.Client, deps ToolDependencies, owner, repo string, pullNumber int, pagination PaginationParams) (*mcp.CallToolResult, *PullRequestReadOutput, error) {

if restricted, err := enforcePullRequestLockdown(ctx, client, deps, owner, repo, pullNumber); restricted != nil || err != nil {

return restricted, nil, err

}

opts := &github.ListOptions{

PerPage: pagination.PerPage,

Page: pagination.Page,

}

files, resp, err := client.PullRequests.ListFiles(ctx, owner, repo, pullNumber, opts)

if err != nil {

return ghErrors.NewGitHubAPIErrorResponse(ctx,

"failed to get pull request files",

resp,

err,

), nil, nil

}

defer func() { _ = resp.Body.Close() }()

if resp.StatusCode != http.StatusOK {

body, err := io.ReadAll(resp.Body)

if err != nil {

return nil, nil, fmt.Errorf("failed to read response body: %w", err)

}

return ghErrors.NewGitHubAPIStatusErrorResponse(ctx, "failed to get pull request files", resp, body), nil, nil

}

minimalFiles := convertToMinimalPRFiles(files)

return MarshalledTextResult(minimalFiles), &PullRequestReadOutput{Files: &minimalFiles}, nil

}

// GetPullRequestCommits returns the commits on a pull request. Under lockdown

// mode it checks the PR author once rather than per commit, since every

// commit on the PR belongs to the same untrusted head branch.

func GetPullRequestCommits(ctx context.Context, client *github.Client, deps ToolDependencies, owner, repo string, pullNumber int, pagination PaginationParams) (*mcp.CallToolResult, error) {

result, _, err := getPullRequestCommits(ctx, client, deps, owner, repo, pullNumber, pagination)

return result, err

}

func getPullRequestCommits(ctx context.Context, client *github.Client, deps ToolDependencies, owner, repo string, pullNumber int, pagination PaginationParams) (*mcp.CallToolResult, *PullRequestReadOutput, error) {

if restricted, err := enforcePullRequestLockdown(ctx, client, deps, owner, repo, pullNumber); restricted != nil || err != nil {

return restricted, nil, err

}

opts := &github.ListOptions{

PerPage: pagination.PerPage,

Page: pagination.Page,

}

commits, resp, err := client.PullRequests.ListCommits(ctx, owner, repo, pullNumber, opts)

if err != nil {

return ghErrors.NewGitHubAPIErrorResponse(ctx,

"failed to get pull request commits",

resp,

err,

), nil, nil

}

defer func() { _ = resp.Body.Close() }()

if resp.StatusCode != http.StatusOK {

body, err := io.ReadAll(resp.Body)

if err != nil {

return nil, nil, fmt.Errorf("failed to read response body: %w", err)

}

return ghErrors.NewGitHubAPIStatusErrorResponse(ctx, "failed to get pull request commits", resp, body), nil, nil

}

minimalCommits := convertToMinimalPullRequestCommits(commits)

return MarshalledTextResult(minimalCommits), &PullRequestReadOutput{Commits: &minimalCommits}, nil

}

// GraphQL types for review threads query

type reviewThreadsQuery struct {

Repository struct {

PullRequest struct {

ReviewThreads struct {

Nodes []reviewThreadNode

PageInfo pageInfoFragment

TotalCount githubv4.Int

} `graphql:"reviewThreads(first: $first, after: $after)"`

} `graphql:"pullRequest(number: $prNum)"`

} `graphql:"repository(owner: $owner, name: $repo)"`

}

type reviewThreadNode struct {

ID githubv4.ID

IsResolved githubv4.Boolean

IsOutdated githubv4.Boolean

IsCollapsed githubv4.Boolean

Comments struct {

Nodes []reviewCommentNode

TotalCount githubv4.Int

} `graphql:"comments(first: $commentsPerThread)"`

}

type reviewCommentNode struct {

ID githubv4.ID

Body githubv4.String

Path githubv4.String

Line *githubv4.Int

OriginalLine *githubv4.Int

StartLine *githubv4.Int

OriginalStartLine *githubv4.Int

Author struct {

Login githubv4.String

}

CreatedAt githubv4.DateTime

UpdatedAt githubv4.DateTime

URL githubv4.URI

}

type pageInfoFragment struct {

HasNextPage githubv4.Boolean

HasPreviousPage githubv4.Boolean

StartCursor githubv4.String

EndCursor githubv4.String

}

func GetPullRequestReviewComments(ctx context.Context, gqlClient *githubv4.Client, deps ToolDependencies, owner, repo string, pullNumber int, pagination CursorPaginationParams) (*mcp.CallToolResult, error) {

result, _, err := getPullRequestReviewComments(ctx, gqlClient, deps, owner, repo, pullNumber, pagination)

return result, err

}

func getPullRequestReviewComments(ctx context.Context, gqlClient *githubv4.Client, deps ToolDependencies, owner, repo string, pullNumber int, pagination CursorPaginationParams) (*mcp.CallToolResult, *PullRequestReadOutput, error) {

cache, err := deps.GetRepoAccessCache(ctx)

if err != nil {

return nil, nil, fmt.Errorf("failed to get repo access cache: %w", err)

}

ff := deps.GetFlags(ctx)

// Convert pagination parameters to GraphQL format

gqlParams, err := pagination.ToGraphQLParams()

if err != nil {

return utils.NewToolResultError(fmt.Sprintf("invalid pagination parameters: %v", err)), nil, nil

}

// Build variables for GraphQL query

vars := map[string]any{

"owner": githubv4.String(owner),

"repo": githubv4.String(repo),

"prNum": githubv4.Int(int32(pullNumber)), //nolint:gosec // pullNumber is controlled by user input validation

"first": githubv4.Int(*gqlParams.First),

"commentsPerThread": githubv4.Int(100),

}

// Add cursor if provided

if gqlParams.After != nil {

vars["after"] = githubv4.String(*gqlParams.After)

} else {

vars["after"] = (*githubv4.String)(nil)

}

// Execute GraphQL query

var query reviewThreadsQuery

if err := gqlClient.Query(ctx, &query, vars); err != nil {

return ghErrors.NewGitHubGraphQLErrorResponse(ctx,

"failed to get pull request review threads",

err,

), nil, nil

}

// Lockdown mode filtering

if ff.LockdownMode {

if cache == nil {

return nil, nil, fmt.Errorf("lockdown cache is not configured")

}

// Iterate through threads and filter comments

for i := range query.Repository.PullRequest.ReviewThreads.Nodes {

thread := &query.Repository.PullRequest.ReviewThreads.Nodes[i]

filteredComments := make([]reviewCommentNode, 0, len(thread.Comments.Nodes))

for _, comment := range thread.Comments.Nodes {

login := string(comment.Author.Login)

if login != "" {

isSafeContent, err := cache.IsSafeContent(ctx, login, owner, repo)

if err != nil {

return nil, nil, fmt.Errorf("failed to check lockdown mode: %w", err)

}

if isSafeContent {

filteredComments = append(filteredComments, comment)

}

}

}

thread.Comments.Nodes = filteredComments

thread.Comments.TotalCount = githubv4.Int(int32(len(filteredComments))) //nolint:gosec // comment count is bounded by API limits

}

}

threads := convertToMinimalReviewThreadsResponse(query)

return MarshalledTextResult(threads), &PullRequestReadOutput{ReviewThreads: &threads}, nil

}

func GetPullRequestReviews(ctx context.Context, client *github.Client, deps ToolDependencies, owner, repo string, pullNumber int, pagination PaginationParams) (*mcp.CallToolResult, error) {

result, _, err := getPullRequestReviews(ctx, client, deps, owner, repo, pullNumber, pagination)

return result, err

}

func getPullRequestReviews(ctx context.Context, client *github.Client, deps ToolDependencies, owner, repo string, pullNumber int, pagination PaginationParams) (*mcp.CallToolResult, *PullRequestReadOutput, error) {

cache, err := deps.GetRepoAccessCache(ctx)

if err != nil {

return nil, nil, fmt.Errorf("failed to get repo access cache: %w", err)

}

ff := deps.GetFlags(ctx)

reviews, resp, err := client.PullRequests.ListReviews(ctx, owner, repo, pullNumber, &github.ListOptions{

Page: pagination.Page,

PerPage: pagination.PerPage,

})

if err != nil {

return ghErrors.NewGitHubAPIErrorResponse(ctx,

"failed to get pull request reviews",

resp,

err,

), nil, nil

}

defer func() { _ = resp.Body.Close() }()

if resp.StatusCode != http.StatusOK {

body, err := io.ReadAll(resp.Body)

if err != nil {

return nil, nil, fmt.Errorf("failed to read response body: %w", err)

}

return ghErrors.NewGitHubAPIStatusErrorResponse(ctx, "failed to get pull request reviews", resp, body), nil, nil

}

if ff.LockdownMode {

if cache == nil {

return nil, nil, fmt.Errorf("lockdown cache is not configured")

}

filteredReviews := make([]*github.PullRequestReview, 0, len(reviews))

for _, review := range reviews {

login := review.GetUser().GetLogin()

if login == "" {

continue

}

isSafeContent, err := cache.IsSafeContent(ctx, login, owner, repo)

if err != nil {

return nil, nil, fmt.Errorf("failed to check lockdown mode: %w", err)

}

if isSafeContent {

filteredReviews = append(filteredReviews, review)

}

}

reviews = filteredReviews

}

minimalReviews := make([]MinimalPullRequestReview, 0, len(reviews))

for _, review := range reviews {

minimalReviews = append(minimalReviews, convertToMinimalPullRequestReview(review))

}

return MarshalledTextResult(minimalReviews), &PullRequestReadOutput{Reviews: &minimalReviews}, nil

}

// PullRequestWriteUIResourceURI is the URI for the create_pull_request tool's MCP App UI resource.

const PullRequestWriteUIResourceURI = "ui://github-mcp-server/pr-write"

// PullRequestEditUIResourceURI is the URI for the update_pull_request tool's MCP App UI resource.

const PullRequestEditUIResourceURI = "ui://github-mcp-server/pr-edit"

// pullRequestWriteFormParams are the parameters the create_pull_request MCP App

// form collects and re-sends on submit. Any other parameter present on a call

// cannot be represented by the form.

var pullRequestWriteFormParams = map[string]struct{}{

"owner": {},

"repo": {},

"title": {},

"body": {},

"head": {},

"base": {},

"draft": {},

"maintainer_can_modify": {},

"reviewers": {},

"_ui_submitted": {},

}

var pullRequestUpdateFormParams = map[string]struct{}{

"owner": {},

"repo": {},

"pullNumber": {},

"title": {},

"body": {},

"state": {},

"draft": {},

"base": {},

"maintainer_can_modify": {},

"reviewers": {},

"_ui_submitted": {},

}

// CreatePullRequest creates a tool to create a new pull request.

func CreatePullRequest(t translations.TranslationHelperFunc) inventory.ServerTool {

return NewTool[CreatePullRequestInput, *PullRequestWriteOutput](

ToolsetMetadataPullRequests,

mcp.Tool{

Name: "create_pull_request",

OutputSchema: pullRequestWriteOutputSchema(),

Description: t("TOOL_CREATE_PULL_REQUEST_DESCRIPTION", "Create a new pull request in a GitHub repository."),

Annotations: &mcp.ToolAnnotations{

Title: t("TOOL_CREATE_PULL_REQUEST_USER_TITLE", "Open new pull request"),

ReadOnlyHint: false,

},

Meta: mcp.Meta{

"ui": map[string]any{

"resourceUri": PullRequestWriteUIResourceURI,

"visibility": []string{"model", "app"},

},

},

InputSchema: &jsonschema.Schema{

Type: "object",

Properties: map[string]*jsonschema.Schema{

"owner": {

Type: "string",

Description: "Repository owner",

},

"repo": {

Type: "string",

Description: "Repository name",

},

"title": {

Type: "string",

Description: "PR title",

},

"body": {

Type: "string",

Description: "PR description",

},

"head": {

Type: "string",

Description: "Branch containing changes",

},

"base": {

Type: "string",

Description: "Branch to merge into",

},

"draft": {

Type: "boolean",

Description: "Create as draft PR",

},

"maintainer_can_modify": {

Type: "boolean",

Description: "Allow maintainer edits",

},

"reviewers": {

Type: "array",

Description: "GitHub usernames or ORG/team-slug team reviewers to request reviews from",

Items: &jsonschema.Schema{

Type: "string",

},

},

},

Required: []string{"owner", "repo", "title", "head", "base"},

},

},

publicRepositoryWriteScopeAccess(),

func(ctx context.Context, deps ToolDependencies, req *mcp.CallToolRequest, input CreatePullRequestInput) (*mcp.CallToolResult, *PullRequestWriteOutput, error) {

args, err := discussionNotificationArguments(input)

if err != nil {

return nil, nil, err

}

owner, err := RequiredParam[string](args, "owner")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

repo, err := RequiredParam[string](args, "repo")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

// Hand off to the interactive MCP App form unless this call must

// execute now (see shouldDeferToForm).

formArgs, err := pullRequestFormArguments(req, args)

if err != nil {

return nil, nil, err

}

if shouldDeferToForm(ctx, deps, req, formArgs, pullRequestWriteFormParams) {

return pullRequestAwaitingFormResult(fmt.Sprintf(

"An interactive form has been shown to the user for creating a new pull request in %s/%s. "+

"STOP — do not call any other tools, do not respond as if the pull request was created, "+

"and do not claim the operation succeeded. The pull request has NOT been created yet; "+

"only the form was rendered. Wait silently for the user to review and click Submit. "+

"When they do, the real result will be delivered to your context automatically.",

owner, repo,

))

}

// When creating PR, title/head/base are required

title, err := OptionalParam[string](args, "title")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

head, err := OptionalParam[string](args, "head")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

base, err := OptionalParam[string](args, "base")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

if title == "" {

return utils.NewToolResultError("missing required parameter: title"), nil, nil

}

if head == "" {

return utils.NewToolResultError("missing required parameter: head"), nil, nil

}

if base == "" {

return utils.NewToolResultError("missing required parameter: base"), nil, nil

}

body, err := OptionalParam[string](args, "body")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

draft, err := OptionalParam[bool](args, "draft")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

maintainerCanModify, err := OptionalParam[bool](args, "maintainer_can_modify")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

reviewers, err := OptionalStringArrayParam(args, "reviewers")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

newPR := &github.CreatePullRequest{

Title: new(title),

Head: head,

Base: base,

}

if body != "" {

newPR.Body = new(body)

}

newPR.Draft = new(draft)

newPR.MaintainerCanModify = new(maintainerCanModify)

client, err := deps.GetClient(ctx)

if err != nil {

return utils.NewToolResultErrorFromErr("failed to get GitHub client", err), nil, nil

}

pr, resp, err := client.PullRequests.Create(ctx, owner, repo, *newPR)

if err != nil {

return ghErrors.NewGitHubAPIErrorResponse(ctx,

"failed to create pull request",

resp,

err,

), nil, nil

}

defer func() { _ = resp.Body.Close() }()

if resp.StatusCode != http.StatusCreated {

bodyBytes, err := io.ReadAll(resp.Body)

if err != nil {

return utils.NewToolResultErrorFromErr("failed to read response body", err), nil, nil

}

return ghErrors.NewGitHubAPIStatusErrorResponse(ctx, "failed to create pull request", resp, bodyBytes), nil, nil

}

if len(reviewers) > 0 {

userReviewers, teamReviewers := splitPullRequestReviewers(reviewers)

reviewersRequest := github.ReviewersRequest{

Reviewers: userReviewers,

TeamReviewers: teamReviewers,

}

_, reviewerResp, err := client.PullRequests.RequestReviewers(ctx, owner, repo, pr.GetNumber(), reviewersRequest)

if err != nil {

return ghErrors.NewGitHubAPIErrorResponse(ctx,

"failed to request reviewers",

reviewerResp,

err,

), nil, nil

}

defer func() {

if reviewerResp != nil && reviewerResp.Body != nil {

_ = reviewerResp.Body.Close()

}

}()

if reviewerResp.StatusCode != http.StatusCreated && reviewerResp.StatusCode != http.StatusOK {

bodyBytes, err := io.ReadAll(reviewerResp.Body)

if err != nil {

return utils.NewToolResultErrorFromErr("failed to read response body", err), nil, nil

}

return ghErrors.NewGitHubAPIStatusErrorResponse(ctx, "failed to request reviewers", reviewerResp, bodyBytes), nil, nil

}

}

// Return minimal response with just essential information

minimalResponse := MinimalResponse{

ID: fmt.Sprintf("%d", pr.GetID()),

URL: pr.GetHTMLURL(),

}

r, err := json.Marshal(minimalResponse)

if err != nil {

return utils.NewToolResultErrorFromErr("failed to marshal response", err), nil, nil

}

return utils.NewToolResultText(string(r)), &PullRequestWriteOutput{PullRequest: pullRequestMutationReference(minimalResponse)}, nil

}, normalizePullRequestArguments("create"))

}

// UpdatePullRequest creates a tool to update an existing pull request.

func UpdatePullRequest(t translations.TranslationHelperFunc) inventory.ServerTool {

schema := &jsonschema.Schema{

Type: "object",

Properties: map[string]*jsonschema.Schema{

"owner": {

Type: "string",

Description: "Repository owner",

},

"repo": {

Type: "string",

Description: "Repository name",

},

"pullNumber": {

Type: "number",

Description: "Pull request number to update",

},

"title": {

Type: "string",

Description: "New title",

},

"body": {

Type: "string",

Description: "New description",

},

"state": {

Type: "string",

Description: "New state",

Enum: []any{"open", "closed"},

},

"draft": {

Type: "boolean",

Description: "Mark pull request as draft (true) or ready for review (false)",

},

"base": {

Type: "string",

Description: "New base branch name",

},

"maintainer_can_modify": {

Type: "boolean",

Description: "Allow maintainer edits",

},

"reviewers": {

Type: "array",

Description: "GitHub usernames or ORG/team-slug team reviewers to request reviews from",

Items: &jsonschema.Schema{

Type: "string",

},

},

},

Required: []string{"owner", "repo", "pullNumber"},

}

st := NewTool[UpdatePullRequestInput, *PullRequestWriteOutput](

ToolsetMetadataPullRequests,

mcp.Tool{

Name: "update_pull_request",

OutputSchema: pullRequestWriteOutputSchema(),

Description: t("TOOL_UPDATE_PULL_REQUEST_DESCRIPTION", "Update an existing pull request in a GitHub repository."),

Annotations: &mcp.ToolAnnotations{

Title: t("TOOL_UPDATE_PULL_REQUEST_USER_TITLE", "Edit pull request"),

ReadOnlyHint: false,

},

Meta: mcp.Meta{

"ui": map[string]any{

"resourceUri": PullRequestEditUIResourceURI,

"visibility": []string{"model", "app"},

},

},

InputSchema: schema,

},

scopes.RequireAll(scopes.Repo),

func(ctx context.Context, deps ToolDependencies, req *mcp.CallToolRequest, input UpdatePullRequestInput) (*mcp.CallToolResult, *PullRequestWriteOutput, error) {

args, err := discussionNotificationArguments(input)

if err != nil {

return nil, nil, err

}

owner, err := RequiredParam[string](args, "owner")

if err != nil {

return utils.NewToolResultError(err.Error()), nil, nil

}

repo, err := RequiredParam[string](args, "repo")

if err != nil {