package github

import (

"context"

"encoding/json"

"fmt"

"io"

"net/http"

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

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

"github.com/mark3labs/mcp-go/mcp"

"github.com/mark3labs/mcp-go/server"

"github.com/shurcooL/githubv4"

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

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

)

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

func PullRequestRead(getClient GetClientFn, t translations.TranslationHelperFunc) (mcp.Tool, server.ToolHandlerFunc) {

return mcp.NewTool("pull_request_read",

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

mcp.WithToolAnnotation(mcp.ToolAnnotation{

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

ReadOnlyHint: ToBoolPtr(true),

}),

mcp.WithString("method",

mcp.Required(),

mcp.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 status of a head commit in a pull request. This reflects status of builds and checks.

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_review_comments - Get the review comments on a pull request. Use with pagination parameters to control the number of results returned.

6. get_reviews - Get the reviews on a pull request. When asked for review comments, use get_review_comments method.

`),

mcp.Enum("get", "get_diff", "get_status", "get_files", "get_review_comments", "get_reviews"),

),

mcp.WithString("owner",

mcp.Required(),

mcp.Description("Repository owner"),

),

mcp.WithString("repo",

mcp.Required(),

mcp.Description("Repository name"),

),

mcp.WithNumber("pullNumber",

mcp.Required(),

mcp.Description("Pull request number"),

),

WithPagination(),

),

func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {

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

if err != nil {

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

}

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

if err != nil {

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

}

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

if err != nil {

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

}

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

if err != nil {

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

}

pagination, err := OptionalPaginationParams(request)

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)

}

switch method {

case "get":

return GetPullRequest(ctx, client, owner, repo, pullNumber)

case "get_diff":

return GetPullRequestDiff(ctx, client, owner, repo, pullNumber)

case "get_status":

return GetPullRequestStatus(ctx, client, owner, repo, pullNumber)

case "get_files":

return GetPullRequestFiles(ctx, client, owner, repo, pullNumber, pagination)

case "get_review_comments":

return GetPullRequestReviewComments(ctx, client, owner, repo, pullNumber, pagination)

case "get_reviews":

return GetPullRequestReviews(ctx, client, owner, repo, pullNumber)

default:

return nil, fmt.Errorf("unknown method: %s", method)

}

}

}

func GetPullRequest(ctx context.Context, client *github.Client, owner, repo string, pullNumber int) (*mcp.CallToolResult, 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

}

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 pull request: %s", string(body))), nil

}

r, err := json.Marshal(pr)

if err != nil {

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

}

return mcp.NewToolResultText(string(r)), nil

}

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

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

}

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 pull request diff: %s", string(body))), nil

}

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

// Return the raw response

return mcp.NewToolResultText(string(raw)), nil

}

func GetPullRequestStatus(ctx context.Context, client *github.Client, owner, repo string, pullNumber int) (*mcp.CallToolResult, 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

}

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 pull request: %s", string(body))), 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

}

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 combined status: %s", string(body))), nil

}

r, err := json.Marshal(status)

if err != nil {

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

}

return mcp.NewToolResultText(string(r)), nil

}

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

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

}

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 pull request files: %s", string(body))), nil

}

r, err := json.Marshal(files)

if err != nil {

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

}

return mcp.NewToolResultText(string(r)), nil

}

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

opts := &github.PullRequestListCommentsOptions{

ListOptions: github.ListOptions{

PerPage: pagination.PerPage,

Page: pagination.Page,

},

}

comments, resp, err := client.PullRequests.ListComments(ctx, owner, repo, pullNumber, opts)

if err != nil {

return ghErrors.NewGitHubAPIErrorResponse(ctx,

"failed to get pull request review comments",

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 mcp.NewToolResultError(fmt.Sprintf("failed to get pull request review comments: %s", string(body))), nil

}

r, err := json.Marshal(comments)

if err != nil {

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

}

return mcp.NewToolResultText(string(r)), nil

}

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

reviews, resp, err := client.PullRequests.ListReviews(ctx, owner, repo, pullNumber, nil)

if err != nil {

return ghErrors.NewGitHubAPIErrorResponse(ctx,

"failed to get pull request reviews",

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 mcp.NewToolResultError(fmt.Sprintf("failed to get pull request reviews: %s", string(body))), nil

}

r, err := json.Marshal(reviews)

if err != nil {

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

}

return mcp.NewToolResultText(string(r)), nil

}

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

func CreatePullRequest(getClient GetClientFn, t translations.TranslationHelperFunc) (mcp.Tool, server.ToolHandlerFunc) {

return mcp.NewTool("create_pull_request",

mcp.WithDescription(t("TOOL_CREATE_PULL_REQUEST_DESCRIPTION", "Create a new pull request in a GitHub repository.")),

mcp.WithToolAnnotation(mcp.ToolAnnotation{

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

ReadOnlyHint: ToBoolPtr(false),

}),

mcp.WithString("owner",

mcp.Required(),

mcp.Description("Repository owner"),

),

mcp.WithString("repo",

mcp.Required(),

mcp.Description("Repository name"),

),

mcp.WithString("title",

mcp.Required(),

mcp.Description("PR title"),

),

mcp.WithString("body",

mcp.Description("PR description"),

),

mcp.WithString("head",

mcp.Required(),

mcp.Description("Branch containing changes"),

),

mcp.WithString("base",

mcp.Required(),

mcp.Description("Branch to merge into"),

),

mcp.WithBoolean("draft",

mcp.Description("Create as draft PR"),

),

mcp.WithBoolean("maintainer_can_modify",

mcp.Description("Allow maintainer edits"),

),

),

func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {

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

if err != nil {

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

}

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

if err != nil {

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

}

title, err := RequiredParam[string](request, "title")

if err != nil {

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

}

head, err := RequiredParam[string](request, "head")

if err != nil {

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

}

base, err := RequiredParam[string](request, "base")

if err != nil {

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

}

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

if err != nil {

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

}

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

if err != nil {

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

}

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

if err != nil {

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

}

newPR := &github.NewPullRequest{

Title: github.Ptr(title),

Head: github.Ptr(head),

Base: github.Ptr(base),

}

if body != "" {

newPR.Body = github.Ptr(body)

}

newPR.Draft = github.Ptr(draft)

newPR.MaintainerCanModify = github.Ptr(maintainerCanModify)

client, err := getClient(ctx)

if err != nil {

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

}

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

}

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

if resp.StatusCode != http.StatusCreated {

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 create pull request: %s", string(body))), 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 nil, fmt.Errorf("failed to marshal response: %w", err)

}

return mcp.NewToolResultText(string(r)), nil

}

}

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

func UpdatePullRequest(getClient GetClientFn, getGQLClient GetGQLClientFn, t translations.TranslationHelperFunc) (mcp.Tool, server.ToolHandlerFunc) {

return mcp.NewTool("update_pull_request",

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

mcp.WithToolAnnotation(mcp.ToolAnnotation{

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

ReadOnlyHint: ToBoolPtr(false),

}),

mcp.WithString("owner",

mcp.Required(),

mcp.Description("Repository owner"),

),

mcp.WithString("repo",

mcp.Required(),

mcp.Description("Repository name"),

),

mcp.WithNumber("pullNumber",

mcp.Required(),

mcp.Description("Pull request number to update"),

),

mcp.WithString("title",

mcp.Description("New title"),

),

mcp.WithString("body",

mcp.Description("New description"),

),

mcp.WithString("state",

mcp.Description("New state"),

mcp.Enum("open", "closed"),

),

mcp.WithBoolean("draft",

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

),

mcp.WithString("base",

mcp.Description("New base branch name"),

),

mcp.WithBoolean("maintainer_can_modify",

mcp.Description("Allow maintainer edits"),

),

mcp.WithArray("reviewers",

mcp.Description("GitHub usernames to request reviews from"),

mcp.Items(map[string]interface{}{

"type": "string",

}),

),

),

func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {

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

if err != nil {

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

}

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

if err != nil {

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

}

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

if err != nil {

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

}

// Check if draft parameter is provided

draftProvided := request.GetArguments()["draft"] != nil

var draftValue bool

if draftProvided {

draftValue, err = OptionalParam[bool](request, "draft")

if err != nil {

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

}

}

// Build the update struct only with provided fields

update := &github.PullRequest{}

restUpdateNeeded := false

if title, ok, err := OptionalParamOK[string](request, "title"); err != nil {

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

} else if ok {

update.Title = github.Ptr(title)

restUpdateNeeded = true

}

if body, ok, err := OptionalParamOK[string](request, "body"); err != nil {

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

} else if ok {

update.Body = github.Ptr(body)

restUpdateNeeded = true

}

if state, ok, err := OptionalParamOK[string](request, "state"); err != nil {

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

} else if ok {

update.State = github.Ptr(state)

restUpdateNeeded = true

}

if base, ok, err := OptionalParamOK[string](request, "base"); err != nil {

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

} else if ok {

update.Base = &github.PullRequestBranch{Ref: github.Ptr(base)}

restUpdateNeeded = true

}

if maintainerCanModify, ok, err := OptionalParamOK[bool](request, "maintainer_can_modify"); err != nil {

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

} else if ok {

update.MaintainerCanModify = github.Ptr(maintainerCanModify)

restUpdateNeeded = true

}

// Handle reviewers separately

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

if err != nil {

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

}

// If no updates, no draft change, and no reviewers, return error early

if !restUpdateNeeded && !draftProvided && len(reviewers) == 0 {

return mcp.NewToolResultError("No update parameters provided."), nil

}

// Handle REST API updates (title, body, state, base, maintainer_can_modify)

if restUpdateNeeded {

client, err := getClient(ctx)

if err != nil {

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

}

_, resp, err := client.PullRequests.Edit(ctx, owner, repo, pullNumber, update)

if err != nil {

return ghErrors.NewGitHubAPIErrorResponse(ctx,

"failed to update 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 mcp.NewToolResultError(fmt.Sprintf("failed to update pull request: %s", string(body))), nil

}

}

// Handle draft status changes using GraphQL

if draftProvided {

gqlClient, err := getGQLClient(ctx)

if err != nil {

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

}

var prQuery struct {

Repository struct {

PullRequest struct {

ID githubv4.ID

IsDraft githubv4.Boolean

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

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

}

err = gqlClient.Query(ctx, &prQuery, map[string]interface{}{

"owner": githubv4.String(owner),

"repo": githubv4.String(repo),

"prNum": githubv4.Int(pullNumber), // #nosec G115 - pull request numbers are always small positive integers

})

if err != nil {

return ghErrors.NewGitHubGraphQLErrorResponse(ctx, "Failed to find pull request", err), nil

}

currentIsDraft := bool(prQuery.Repository.PullRequest.IsDraft)

if currentIsDraft != draftValue {

if draftValue {

// Convert to draft

var mutation struct {

ConvertPullRequestToDraft struct {

PullRequest struct {

ID githubv4.ID

IsDraft githubv4.Boolean

}

} `graphql:"convertPullRequestToDraft(input: $input)"`

}

err = gqlClient.Mutate(ctx, &mutation, githubv4.ConvertPullRequestToDraftInput{

PullRequestID: prQuery.Repository.PullRequest.ID,

}, nil)

if err != nil {

return ghErrors.NewGitHubGraphQLErrorResponse(ctx, "Failed to convert pull request to draft", err), nil

}

} else {

// Mark as ready for review

var mutation struct {

MarkPullRequestReadyForReview struct {

PullRequest struct {

ID githubv4.ID

IsDraft githubv4.Boolean

}

} `graphql:"markPullRequestReadyForReview(input: $input)"`

}

err = gqlClient.Mutate(ctx, &mutation, githubv4.MarkPullRequestReadyForReviewInput{

PullRequestID: prQuery.Repository.PullRequest.ID,

}, nil)

if err != nil {

return ghErrors.NewGitHubGraphQLErrorResponse(ctx, "Failed to mark pull request ready for review", err), nil

}

}

}

}

// Handle reviewer requests

if len(reviewers) > 0 {

client, err := getClient(ctx)

if err != nil {

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

}

reviewersRequest := github.ReviewersRequest{

Reviewers: reviewers,

}

_, resp, err := client.PullRequests.RequestReviewers(ctx, owner, repo, pullNumber, reviewersRequest)

if err != nil {

return ghErrors.NewGitHubAPIErrorResponse(ctx,

"failed to request reviewers",

resp,

err,

), nil

}

defer func() {

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

_ = resp.Body.Close()

}

}()

if resp.StatusCode != http.StatusCreated && 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 request reviewers: %s", string(body))), nil

}

}

// Get the final state of the PR to return

client, err := getClient(ctx)

if err != nil {

return nil, err

}

finalPR, 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() {

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

_ = resp.Body.Close()

}

}()

// Return minimal response with just essential information

minimalResponse := MinimalResponse{

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

URL: finalPR.GetHTMLURL(),

}

r, err := json.Marshal(minimalResponse)

if err != nil {

return mcp.NewToolResultError(fmt.Sprintf("Failed to marshal response: %v", err)), nil

}

return mcp.NewToolResultText(string(r)), nil

}

}

// ListPullRequests creates a tool to list and filter repository pull requests.

func ListPullRequests(getClient GetClientFn, t translations.TranslationHelperFunc) (mcp.Tool, server.ToolHandlerFunc) {

return mcp.NewTool("list_pull_requests",

mcp.WithDescription(t("TOOL_LIST_PULL_REQUESTS_DESCRIPTION", "List pull requests in a GitHub repository. If the user specifies an author, then DO NOT use this tool and use the search_pull_requests tool instead.")),

mcp.WithToolAnnotation(mcp.ToolAnnotation{

Title: t("TOOL_LIST_PULL_REQUESTS_USER_TITLE", "List pull requests"),

ReadOnlyHint: ToBoolPtr(true),

}),

mcp.WithString("owner",

mcp.Required(),

mcp.Description("Repository owner"),

),

mcp.WithString("repo",

mcp.Required(),

mcp.Description("Repository name"),

),

mcp.WithString("state",

mcp.Description("Filter by state"),

mcp.Enum("open", "closed", "all"),

),

mcp.WithString("head",

mcp.Description("Filter by head user/org and branch"),

),

mcp.WithString("base",

mcp.Description("Filter by base branch"),

),

mcp.WithString("sort",

mcp.Description("Sort by"),

mcp.Enum("created", "updated", "popularity", "long-running"),

),

mcp.WithString("direction",

mcp.Description("Sort direction"),

mcp.Enum("asc", "desc"),

),

WithPagination(),

),

func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {

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

if err != nil {

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

}

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

if err != nil {

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

}

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

if err != nil {

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

}

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

if err != nil {

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

}

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

if err != nil {

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

}

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

if err != nil {

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

}

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

if err != nil {

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

}

pagination, err := OptionalPaginationParams(request)

if err != nil {

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

}

opts := &github.PullRequestListOptions{

State: state,

Head: head,

Base: base,

Sort: sort,

Direction: direction,

ListOptions: github.ListOptions{

PerPage: pagination.PerPage,

Page: pagination.Page,

},

}

client, err := getClient(ctx)

if err != nil {

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

}

prs, resp, err := client.PullRequests.List(ctx, owner, repo, opts)

if err != nil {

return ghErrors.NewGitHubAPIErrorResponse(ctx,

"failed to list pull requests",

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 mcp.NewToolResultError(fmt.Sprintf("failed to list pull requests: %s", string(body))), nil

}

r, err := json.Marshal(prs)

if err != nil {

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

}

return mcp.NewToolResultText(string(r)), nil

}

}

// MergePullRequest creates a tool to merge a pull request.

func MergePullRequest(getClient GetClientFn, t translations.TranslationHelperFunc) (mcp.Tool, server.ToolHandlerFunc) {

return mcp.NewTool("merge_pull_request",

mcp.WithDescription(t("TOOL_MERGE_PULL_REQUEST_DESCRIPTION", "Merge a pull request in a GitHub repository.")),

mcp.WithToolAnnotation(mcp.ToolAnnotation{

Title: t("TOOL_MERGE_PULL_REQUEST_USER_TITLE", "Merge pull request"),

ReadOnlyHint: ToBoolPtr(false),

}),

mcp.WithString("owner",

mcp.Required(),

mcp.Description("Repository owner"),

),

mcp.WithString("repo",

mcp.Required(),

mcp.Description("Repository name"),

),

mcp.WithNumber("pullNumber",

mcp.Required(),

mcp.Description("Pull request number"),

),

mcp.WithString("commit_title",

mcp.Description("Title for merge commit"),

),

mcp.WithString("commit_message",

mcp.Description("Extra detail for merge commit"),

),

mcp.WithString("merge_method",

mcp.Description("Merge method"),

mcp.Enum("merge", "squash", "rebase"),

),

),

func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {

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

if err != nil {

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

}

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

if err != nil {

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

}

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

if err != nil {

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

}

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

if err != nil {

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

}

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

if err != nil {

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

}

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

if err != nil {

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

}

options := &github.PullRequestOptions{

CommitTitle: commitTitle,

MergeMethod: mergeMethod,

}

client, err := getClient(ctx)

if err != nil {

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

}

result, resp, err := client.PullRequests.Merge(ctx, owner, repo, pullNumber, commitMessage, options)

if err != nil {

return ghErrors.NewGitHubAPIErrorResponse(ctx,

"failed to merge 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 mcp.NewToolResultError(fmt.Sprintf("failed to merge pull request: %s", string(body))), nil

}

r, err := json.Marshal(result)

if err != nil {

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

}

return mcp.NewToolResultText(string(r)), nil

}

}

// SearchPullRequests creates a tool to search for pull requests.

func SearchPullRequests(getClient GetClientFn, t translations.TranslationHelperFunc) (tool mcp.Tool, handler server.ToolHandlerFunc) {

return mcp.NewTool("search_pull_requests",

mcp.WithDescription(t("TOOL_SEARCH_PULL_REQUESTS_DESCRIPTION", "Search for pull requests in GitHub repositories using issues search syntax already scoped to is:pr")),

mcp.WithToolAnnotation(mcp.ToolAnnotation{

Title: t("TOOL_SEARCH_PULL_REQUESTS_USER_TITLE", "Search pull requests"),

ReadOnlyHint: ToBoolPtr(true),

}),

mcp.WithString("query",

mcp.Required(),

mcp.Description("Search query using GitHub pull request search syntax"),

),

mcp.WithString("owner",

mcp.Description("Optional repository owner. If provided with repo, only pull requests for this repository are listed."),

),

mcp.WithString("repo",

mcp.Description("Optional repository name. If provided with owner, only pull requests for this repository are listed."),

),

mcp.WithString("sort",

mcp.Description("Sort field by number of matches of categories, defaults to best match"),

mcp.Enum(

"comments",

"reactions",

"reactions-+1",

"reactions--1",

"reactions-smile",

"reactions-thinking_face",

"reactions-heart",

"reactions-tada",

"interactions",

"created",

"updated",

),

),

mcp.WithString("order",

mcp.Description("Sort order"),

mcp.Enum("asc", "desc"),

),

WithPagination(),

),

func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {

return searchHandler(ctx, getClient, request, "pr", "failed to search pull requests")

}

}

// UpdatePullRequestBranch creates a tool to update a pull request branch with the latest changes from the base branch.

func UpdatePullRequestBranch(getClient GetClientFn, t translations.TranslationHelperFunc) (mcp.Tool, server.ToolHandlerFunc) {

return mcp.NewTool("update_pull_request_branch",

mcp.WithDescription(t("TOOL_UPDATE_PULL_REQUEST_BRANCH_DESCRIPTION", "Update the branch of a pull request with the latest changes from the base branch.")),

mcp.WithToolAnnotation(mcp.ToolAnnotation{

Title: t("TOOL_UPDATE_PULL_REQUEST_BRANCH_USER_TITLE", "Update pull request branch"),

ReadOnlyHint: ToBoolPtr(false),

}),

mcp.WithString("owner",

mcp.Required(),

mcp.Description("Repository owner"),

),

mcp.WithString("repo",

mcp.Required(),

mcp.Description("Repository name"),

),

mcp.WithNumber("pullNumber",

mcp.Required(),

mcp.Description("Pull request number"),

),

mcp.WithString("expectedHeadSha",

mcp.Description("The expected SHA of the pull request's HEAD ref"),

),

),

func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {

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

if err != nil {

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

}

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

if err != nil {

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

}

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

if err != nil {

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

}

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

if err != nil {

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

}

opts := &github.PullRequestBranchUpdateOptions{}

if expectedHeadSHA != "" {

opts.ExpectedHeadSHA = github.Ptr(expectedHeadSHA)

}

client, err := getClient(ctx)

if err != nil {

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

}