package github

import (

"context"

"encoding/json"

"fmt"

"io"

"net/http"

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

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

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

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

"github.com/shurcooL/githubv4"

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

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

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

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

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

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

"github.com/github/github-mcp-server/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_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 threads with metadata (isResolved, isOutdated, isCollapsed) and their associated comments. Use cursor-based pagination (perPage, after) to control results.

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

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

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

return NewTool(

ToolsetMetadataPullRequests,

mcp.Tool{

Name: "pull_request_read",

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.Scope{scopes.Repo},

func(ctx context.Context, deps ToolDependencies, _ *mcp.CallToolRequest, args map[string]any) (*mcp.CallToolResult, any, error) {

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

}

switch method {

case "get":

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

return result, nil, err

case "get_diff":

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

return result, nil, err

case "get_status":

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

return result, nil, err

case "get_files":

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

return result, nil, 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, err := GetPullRequestReviewComments(ctx, gqlClient, deps, owner, repo, pullNumber, cursorPagination)

return result, nil, err

case "get_reviews":

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

return result, nil, err

case "get_comments":

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

return result, nil, err

case "get_check_runs":

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

return result, nil, err

default:

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

}

})

}

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

cache, err := deps.GetRepoAccessCache(ctx)

if err != nil {

return 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

}

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

}

// sanitize title/body on response

if pr != nil {

if pr.Title != nil {

pr.Title = github.Ptr(sanitize.Sanitize(*pr.Title))

}

if pr.Body != nil {

pr.Body = github.Ptr(sanitize.Sanitize(*pr.Body))

}

}

if ff.LockdownMode {

if cache == nil {

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

}

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

if login != "" {

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

if err != nil {

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

}

if !isSafeContent {

return utils.NewToolResultError("access to pull request is restricted by lockdown mode"), nil

}

}

}

minimalPR := convertToMinimalPullRequest(pr)

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

}

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

// Return the raw response

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

}

r, err := json.Marshal(status)

if err != nil {

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

}

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

}

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

}

defer 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

}

// Get check runs for the head SHA

opts := &github.ListCheckRunsOptions{

ListOptions: github.ListOptions{

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

}

defer 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 check runs", resp, body), 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, fmt.Errorf("failed to marshal response: %w", err)

}

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

}

minimalFiles := convertToMinimalPRFiles(files)

return MarshalledTextResult(minimalFiles), 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

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

cache, err := deps.GetRepoAccessCache(ctx)

if err != nil {

return 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

}

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

}

// Lockdown mode filtering

if ff.LockdownMode {

if cache == nil {

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

}

}

return MarshalledTextResult(convertToMinimalReviewThreadsResponse(query)), nil

}

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

cache, err := deps.GetRepoAccessCache(ctx)

if err != nil {

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

}

if ff.LockdownMode {

if cache == nil {

return 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 != "" {

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

if err != nil {

return 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), nil

}

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

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

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

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

return NewTool(

ToolsetMetadataPullRequests,

mcp.Tool{

Name: "create_pull_request",

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

},

},

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

},

},

[]scopes.Scope{scopes.Repo},

func(ctx context.Context, deps ToolDependencies, req *mcp.CallToolRequest, args map[string]any) (*mcp.CallToolResult, any, error) {

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

}

// When insiders mode is enabled and the client supports MCP Apps UI,

// check if this is a UI form submission. The UI sends _ui_submitted=true

// to distinguish form submissions from LLM calls.

uiSubmitted, _ := OptionalParam[bool](args, "_ui_submitted")

if deps.GetFlags(ctx).InsidersMode && clientSupportsUI(ctx, req) && !uiSubmitted {

return utils.NewToolResultText(fmt.Sprintf("Ready to create a pull request in %s/%s. IMPORTANT: The PR has NOT been created yet. Do NOT tell the user the PR was created. The user MUST click Submit in the form to create it.", owner, repo)), nil, nil

}

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

}

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 := 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

}

// 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)), nil, nil

})

}

// 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 to request reviews from",

Items: &jsonschema.Schema{

Type: "string",

},

},

},

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

}

st := NewTool(

ToolsetMetadataPullRequests,

mcp.Tool{

Name: "update_pull_request",

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,

},

InputSchema: schema,

},

[]scopes.Scope{scopes.Repo},

func(ctx context.Context, deps ToolDependencies, _ *mcp.CallToolRequest, args map[string]any) (*mcp.CallToolResult, any, error) {

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

}

_, draftProvided := args["draft"]

var draftValue bool

if draftProvided {

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

if err != nil {

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

}

}

update := &github.PullRequest{}

restUpdateNeeded := false

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

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

} else if ok {

update.Title = github.Ptr(title)

restUpdateNeeded = true

}

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

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

} else if ok {

update.Body = github.Ptr(body)

restUpdateNeeded = true

}

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

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

} else if ok {

update.State = github.Ptr(state)

restUpdateNeeded = true

}

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

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

} else if ok {

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

restUpdateNeeded = true

}

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

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

} else if ok {

update.MaintainerCanModify = github.Ptr(maintainerCanModify)

restUpdateNeeded = true

}

// Handle reviewers separately

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

if err != nil {

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

}

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

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

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

}

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

if restUpdateNeeded {

client, err := deps.GetClient(ctx)

if err != nil {

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

}

_, 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, nil

}

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

if resp.StatusCode != http.StatusOK {

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 update pull request", resp, bodyBytes), nil, nil

}

}

// Handle draft status changes using GraphQL

if draftProvided {

gqlClient, err := deps.GetGQLClient(ctx)

if err != nil {

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

}

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]any{

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

}

}

}

}

// Handle reviewer requests

if len(reviewers) > 0 {

client, err := deps.GetClient(ctx)

if err != nil {

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

}

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

}

defer func() {

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

_ = resp.Body.Close()

}

}()

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

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 request reviewers", resp, bodyBytes), nil, nil

}

}

// Get the final state of the PR to return

client, err := deps.GetClient(ctx)

if err != nil {

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

}

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, 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 utils.NewToolResultErrorFromErr("Failed to marshal response", err), nil, nil

}

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

})

st.FeatureFlagDisable = FeatureFlagPullRequestsGranular

return st

}

// AddReplyToPullRequestComment creates a tool to add a reply to an existing pull request comment.

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

schema := &jsonschema.Schema{

Type: "object",