Add add_pull_request_review_comment tool for PR review comments

Adds the ability to add review comments to pull requests with support for line, multi-line, and file-level comments, as well as replying to existing comments.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: ashwin-ant

pkg/github/pullrequests.go

@@ -499,6 +499,156 @@ func GetPullRequestComments(client *github.Client, t translations.TranslationHel
 		}
 }
 
+// AddPullRequestReviewComment creates a tool to add a review comment to a pull request.
+func AddPullRequestReviewComment(client *github.Client, t translations.TranslationHelperFunc) (tool mcp.Tool, handler server.ToolHandlerFunc) {
+	return mcp.NewTool("add_pull_request_review_comment",
+			mcp.WithDescription(t("TOOL_ADD_PULL_REQUEST_COMMENT_DESCRIPTION", "Add a review comment to a pull request")),
+			mcp.WithString("owner",
+				mcp.Required(),
+				mcp.Description("Repository owner"),
+			),
+			mcp.WithString("repo",
+				mcp.Required(),
+				mcp.Description("Repository name"),
+			),
+			mcp.WithNumber("pull_number",
+				mcp.Required(),
+				mcp.Description("Pull request number"),
+			),
+			mcp.WithString("body",
+				mcp.Required(),
+				mcp.Description("The text of the review comment"),
+			),
+			mcp.WithString("commit_id",
+				mcp.Required(),
+				mcp.Description("The SHA of the commit to comment on"),
+			),
+			mcp.WithString("path",
+				mcp.Required(),
+				mcp.Description("The relative path to the file that necessitates a comment"),
+			),
+			mcp.WithString("subject_type",
+				mcp.Description("The level at which the comment is targeted, 'line' or 'file'"),
+				mcp.Enum("line", "file"),
+			),
+			mcp.WithNumber("line",
+				mcp.Description("The line of the blob in the pull request diff that the comment applies to. For multi-line comments, the last line of the range"),
+			),
+			mcp.WithString("side",
+				mcp.Description("The side of the diff to comment on. Can be LEFT or RIGHT"),
+				mcp.Enum("LEFT", "RIGHT"),
+			),
+			mcp.WithNumber("start_line",
+				mcp.Description("For multi-line comments, the first line of the range that the comment applies to"),
+			),
+			mcp.WithString("start_side",
+				mcp.Description("For multi-line comments, the starting side of the diff that the comment applies to. Can be LEFT or RIGHT"),
+				mcp.Enum("LEFT", "RIGHT"),
+			),
+			mcp.WithNumber("in_reply_to",
+				mcp.Description("The ID of the review comment to reply to. When specified, all parameters other than body are ignored"),
+			),
+		),
+		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, "pull_number")
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+			body, err := requiredParam[string](request, "body")
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+			commitID, err := requiredParam[string](request, "commit_id")
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+			path, err := requiredParam[string](request, "path")
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+
+			comment := &github.PullRequestComment{
+				Body:     github.Ptr(body),
+				CommitID: github.Ptr(commitID),
+				Path:     github.Ptr(path),
+			}
+
+			// Check for in_reply_to parameter which takes precedence
+			if replyToFloat, ok := request.Params.Arguments["in_reply_to"].(float64); ok {
+				comment.InReplyTo = github.Ptr(int64(replyToFloat))
+			} else {
+				// Handle subject_type parameter
+				subjectType, err := optionalParam[string](request, "subject_type")
+				if err != nil {
+					return mcp.NewToolResultError(err.Error()), nil
+				}
+				if subjectType == "file" {
+					// When commenting on a file, no line/position fields are needed
+				} else {
+					// Handle line or position-based comments
+					line, lineExists := request.Params.Arguments["line"].(float64)
+					startLine, startLineExists := request.Params.Arguments["start_line"].(float64)
+					side, sideExists := request.Params.Arguments["side"].(string)
+					startSide, startSideExists := request.Params.Arguments["start_side"].(string)
+
+					if subjectType != "file" && !lineExists {
+						return mcp.NewToolResultError("line parameter is required unless using subject_type:file or in_reply_to"), nil
+					}
+
+					if lineExists {
+						comment.Line = github.Ptr(int(line))
+					}
+					if sideExists {
+						comment.Side = github.Ptr(side)
+					}
+					if startLineExists {
+						comment.StartLine = github.Ptr(int(startLine))
+					}
+					if startSideExists {
+						comment.StartSide = github.Ptr(startSide)
+					}
+
+					// Validate multi-line comment parameters
+					if startLineExists && !lineExists {
+						return mcp.NewToolResultError("if start_line is provided, line must also be provided"), nil
+					}
+					if startSideExists && !sideExists {
+						return mcp.NewToolResultError("if start_side is provided, side must also be provided"), nil
+					}
+				}
+			}
+
+			createdComment, resp, err := client.PullRequests.CreateComment(ctx, owner, repo, pullNumber, comment)
+			if err != nil {
+				return nil, fmt.Errorf("failed to create pull request comment: %w", err)
+			}
+			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 comment: %s", string(body))), nil
+			}
+
+			r, err := json.Marshal(createdComment)
+			if err != nil {
+				return nil, fmt.Errorf("failed to marshal response: %w", err)
+			}
+
+			return mcp.NewToolResultText(string(r)), nil
+		}
+}
+
 // GetPullRequestReviews creates a tool to get the reviews on a pull request.
 func GetPullRequestReviews(client *github.Client, t translations.TranslationHelperFunc) (tool mcp.Tool, handler server.ToolHandlerFunc) {
 	return mcp.NewTool("get_pull_request_reviews",

pkg/github/pullrequests_test.go

@@ -1537,3 +1537,116 @@ func Test_CreatePullRequest(t *testing.T) {
 		})
 	}
 }
+
+func Test_AddPullRequestReviewComment(t *testing.T) {
+	mockClient := github.NewClient(nil)
+	tool, _ := AddPullRequestReviewComment(mockClient, translations.NullTranslationHelper)
+
+	assert.Equal(t, "add_pull_request_review_comment", tool.Name)
+	assert.NotEmpty(t, tool.Description)
+	assert.Contains(t, tool.InputSchema.Properties, "owner")
+	assert.Contains(t, tool.InputSchema.Properties, "repo")
+	assert.Contains(t, tool.InputSchema.Properties, "pull_number")
+	assert.Contains(t, tool.InputSchema.Properties, "body")
+	assert.Contains(t, tool.InputSchema.Properties, "commit_id")
+	assert.Contains(t, tool.InputSchema.Properties, "path")
+	assert.ElementsMatch(t, tool.InputSchema.Required, []string{"owner", "repo", "pull_number", "body", "commit_id", "path"})
+
+	mockComment := &github.PullRequestComment{
+		ID:   github.Ptr(int64(123)),
+		Body: github.Ptr("Great stuff!"),
+		Path: github.Ptr("file1.txt"),
+		Line: github.Ptr(2),
+		Side: github.Ptr("RIGHT"),
+	}
+
+	tests := []struct {
+		name            string
+		mockedClient    *http.Client
+		requestArgs     map[string]interface{}
+		expectError     bool
+		expectedComment *github.PullRequestComment
+		expectedErrMsg  string
+	}{
+		{
+			name: "successful line comment creation",
+			mockedClient: mock.NewMockedHTTPClient(
+				mock.WithRequestMatchHandler(
+					mock.PostReposPullsCommentsByOwnerByRepoByPullNumber,
+					http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+						w.WriteHeader(http.StatusCreated)
+						json.NewEncoder(w).Encode(mockComment)
+					}),
+				),
+			),
+			requestArgs: map[string]interface{}{
+				"owner":       "owner",
+				"repo":        "repo",
+				"pull_number": float64(1),
+				"body":        "Great stuff!",
+				"commit_id":   "6dcb09b5b57875f334f61aebed695e2e4193db5e",
+				"path":        "file1.txt",
+				"line":        float64(2),
+				"side":        "RIGHT",
+			},
+			expectError:     false,
+			expectedComment: mockComment,
+		},
+		{
+			name: "comment creation fails",
+			mockedClient: mock.NewMockedHTTPClient(
+				mock.WithRequestMatchHandler(
+					mock.PostReposPullsCommentsByOwnerByRepoByPullNumber,
+					http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+						w.WriteHeader(http.StatusUnprocessableEntity)
+						w.Header().Set("Content-Type", "application/json")
+						_, _ = w.Write([]byte(`{"message": "Validation Failed"}`))
+					}),
+				),
+			),
+			requestArgs: map[string]interface{}{
+				"owner":       "owner",
+				"repo":        "repo",
+				"pull_number": float64(1),
+				"body":        "Great stuff!",
+				"commit_id":   "6dcb09b5b57875f334f61aebed695e2e4193db5e",
+				"path":        "file1.txt",
+				"line":        float64(2),
+			},
+			expectError:    false,
+			expectedErrMsg: "failed to create pull request comment",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			mockClient := github.NewClient(tc.mockedClient)
+
+			_, handler := AddPullRequestReviewComment(mockClient, translations.NullTranslationHelper)
+
+			request := createMCPRequest(tc.requestArgs)
+
+			result, err := handler(context.Background(), request)
+
+			if tc.name == "comment creation fails" {
+				require.Error(t, err)
+				assert.Contains(t, err.Error(), tc.expectedErrMsg)
+				return
+			}
+
+			require.NoError(t, err)
+			assert.NotNil(t, result)
+			require.Len(t, result.Content, 1)
+
+			var returnedComment github.PullRequestComment
+			err = json.Unmarshal([]byte(getTextResult(t, result).Text), &returnedComment)
+			require.NoError(t, err)
+
+			assert.Equal(t, *tc.expectedComment.ID, *returnedComment.ID)
+			assert.Equal(t, *tc.expectedComment.Body, *returnedComment.Body)
+			assert.Equal(t, *tc.expectedComment.Path, *returnedComment.Path)
+			assert.Equal(t, *tc.expectedComment.Line, *returnedComment.Line)
+			assert.Equal(t, *tc.expectedComment.Side, *returnedComment.Side)
+		})
+	}
+}

pkg/github/server.go

@@ -53,6 +53,7 @@ func NewServer(client *github.Client, version string, readOnly bool, t translati
 		s.AddTool(UpdatePullRequestBranch(client, t))
 		s.AddTool(CreatePullRequestReview(client, t))
 		s.AddTool(CreatePullRequest(client, t))
+		s.AddTool(AddPullRequestReviewComment(client, t))
 	}
 
 	// Add GitHub tools - Repositories