From 7e4f2bb1e5c3a349f9e0624c6e5812f84e79fe72 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Almeida?= <57680069+zeval@users.noreply.github.com> Date: Fri, 24 Jul 2026 15:55:57 +0100 Subject: [PATCH] feat(github): re-request dismissed reviews (#1921) --- apps/backend/internal/github/client.go | 3 + apps/backend/internal/github/controller.go | 62 ++- .../internal/github/controller_test.go | 146 +++++ apps/backend/internal/github/gh_client.go | 11 + .../backend/internal/github/gh_client_test.go | 23 + apps/backend/internal/github/mock_client.go | 46 ++ .../internal/github/mock_client_test.go | 28 + apps/backend/internal/github/noop_client.go | 4 + .../internal/github/noop_client_test.go | 5 + apps/backend/internal/github/pat_client.go | 11 + .../internal/github/pat_client_test.go | 26 + apps/backend/internal/github/service_pr.go | 15 + .../github/service_request_review_test.go | 160 ++++++ apps/backend/internal/github/ttl_cache.go | 102 +++- .../backend/internal/github/ttl_cache_test.go | 70 +++ .../components/github/pr-detail-panel.test.ts | 505 +++++++++++++++++- .../web/components/github/pr-detail-panel.tsx | 26 +- .../github/pr-reviews-section.test.tsx | 126 +++++ .../components/github/pr-reviews-section.tsx | 106 +++- apps/web/components/github/pr-shared.tsx | 7 +- .../github/use-pr-scoped-review-request.ts | 238 +++++++++ .../mobile/session-mobile-layout.test.tsx | 82 ++- .../task/mobile/session-mobile-layout.tsx | 95 +++- apps/web/e2e/pages/session-page.ts | 15 + .../pr/mobile-pr-rerequest-review.spec.ts | 192 +++++++ .../e2e/tests/pr/pr-rerequest-review.spec.ts | 73 +++ apps/web/lib/api/domains/github-api.ts | 19 - .../lib/api/domains/github-review-api.test.ts | 57 ++ apps/web/lib/api/domains/github-review-api.ts | 36 ++ docs/plans/github-pr-review-rerequest/plan.md | 140 +++++ .../task-01-backend-review-request.md | 60 +++ ...ask-02-frontend-dismissed-review-action.md | 58 ++ .../task-03-mobile-github-pr-review.md | 55 ++ .../task-04-e2e-rerequest-review.md | 55 ++ .../task-05-public-review-flow-docs.md | 49 ++ .../task-06-pr-scoped-request-state.md | 36 ++ .../task-07-mobile-pr-identity-layout.md | 40 ++ .../task-08-reviewer-input-hardening.md | 35 ++ .../task-09-key-scoped-cache-invalidation.md | 36 ++ .../task-10-persistent-request-lifecycle.md | 45 ++ .../task-11-reclaim-cache-epochs.md | 37 ++ docs/public/sessions-and-review.md | 2 +- docs/specs/INDEX.md | 1 + docs/specs/ui/github-pr-review-actions.md | 103 ++++ 44 files changed, 2954 insertions(+), 87 deletions(-) create mode 100644 apps/backend/internal/github/service_request_review_test.go create mode 100644 apps/web/components/github/pr-reviews-section.test.tsx create mode 100644 apps/web/components/github/use-pr-scoped-review-request.ts create mode 100644 apps/web/e2e/tests/pr/mobile-pr-rerequest-review.spec.ts create mode 100644 apps/web/e2e/tests/pr/pr-rerequest-review.spec.ts create mode 100644 apps/web/lib/api/domains/github-review-api.test.ts create mode 100644 apps/web/lib/api/domains/github-review-api.ts create mode 100644 docs/plans/github-pr-review-rerequest/plan.md create mode 100644 docs/plans/github-pr-review-rerequest/task-01-backend-review-request.md create mode 100644 docs/plans/github-pr-review-rerequest/task-02-frontend-dismissed-review-action.md create mode 100644 docs/plans/github-pr-review-rerequest/task-03-mobile-github-pr-review.md create mode 100644 docs/plans/github-pr-review-rerequest/task-04-e2e-rerequest-review.md create mode 100644 docs/plans/github-pr-review-rerequest/task-05-public-review-flow-docs.md create mode 100644 docs/plans/github-pr-review-rerequest/task-06-pr-scoped-request-state.md create mode 100644 docs/plans/github-pr-review-rerequest/task-07-mobile-pr-identity-layout.md create mode 100644 docs/plans/github-pr-review-rerequest/task-08-reviewer-input-hardening.md create mode 100644 docs/plans/github-pr-review-rerequest/task-09-key-scoped-cache-invalidation.md create mode 100644 docs/plans/github-pr-review-rerequest/task-10-persistent-request-lifecycle.md create mode 100644 docs/plans/github-pr-review-rerequest/task-11-reclaim-cache-epochs.md create mode 100644 docs/specs/ui/github-pr-review-actions.md diff --git a/apps/backend/internal/github/client.go b/apps/backend/internal/github/client.go index 5e686f1658..bd0e554e71 100644 --- a/apps/backend/internal/github/client.go +++ b/apps/backend/internal/github/client.go @@ -77,6 +77,9 @@ type Client interface { // event is one of "APPROVE", "COMMENT", "REQUEST_CHANGES". SubmitReview(ctx context.Context, owner, repo string, number int, event, body string) error + // RequestReviewers requests reviews from GitHub users on a pull request. + RequestReviewers(ctx context.Context, owner, repo string, number int, reviewers []string) error + // MergePR merges a pull request. mergeMethod is one of "merge", "squash", "rebase". MergePR(ctx context.Context, owner, repo string, number int, mergeMethod string) error diff --git a/apps/backend/internal/github/controller.go b/apps/backend/internal/github/controller.go index 284046b2a6..52c9412178 100644 --- a/apps/backend/internal/github/controller.go +++ b/apps/backend/internal/github/controller.go @@ -18,7 +18,15 @@ import ( "github.com/kandev/kandev/internal/events/bus" ) -const jsonNullLiteral = "null" +const ( + jsonNullLiteral = "null" + + // These limits keep the trusted local API bounded without imposing GitHub's + // login syntax rules at this boundary. + maxRequestReviewersBodyBytes = 64 * 1024 + maxRequestReviewerCount = 50 + maxRequestReviewerLoginBytes = 256 +) // Controller handles HTTP endpoints for GitHub integration. type Controller struct { @@ -52,6 +60,7 @@ func (c *Controller) RegisterHTTPRoutes(router *gin.Engine) { api.GET("/prs/:owner/:repo/:number/status", c.httpGetPRStatus) api.POST("/prs/statuses", c.httpGetPRStatusesBatch) api.POST("/prs/:owner/:repo/:number/reviews", c.httpSubmitReview) + api.POST("/prs/:owner/:repo/:number/requested-reviewers", c.httpRequestReviewers) api.PUT("/prs/:owner/:repo/:number/merge", c.httpMergePR) api.GET("/issues/:owner/:repo/:number/info", c.httpGetIssueInfo) @@ -527,6 +536,57 @@ func (c *Controller) httpSubmitReview(ctx *gin.Context) { ctx.JSON(http.StatusOK, gin.H{"submitted": true}) } +func (c *Controller) httpRequestReviewers(ctx *gin.Context) { + number, err := strconv.Atoi(ctx.Param("number")) + if err != nil || number <= 0 { + ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid PR number"}) + return + } + var req struct { + Reviewers []string `json:"reviewers"` + } + ctx.Request.Body = http.MaxBytesReader(ctx.Writer, ctx.Request.Body, maxRequestReviewersBodyBytes) + if err := ctx.ShouldBindJSON(&req); err != nil { + ctx.JSON(http.StatusBadRequest, gin.H{"error": "reviewers must contain non-empty logins"}) + return + } + reviewers, ok := normalizeReviewers(req.Reviewers) + if !ok { + ctx.JSON(http.StatusBadRequest, gin.H{"error": "reviewers must contain non-empty logins"}) + return + } + if err := c.service.RequestReviewers(ctx.Request.Context(), ctx.Param("owner"), ctx.Param("repo"), number, reviewers); err != nil { + if errors.Is(err, ErrNoClient) { + ctx.JSON(http.StatusServiceUnavailable, gin.H{"error": "GitHub is not configured", "code": "github_not_configured"}) + return + } + ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()}) + return + } + ctx.JSON(http.StatusOK, gin.H{"requested": true}) +} + +func normalizeReviewers(reviewers []string) ([]string, bool) { + if len(reviewers) == 0 || len(reviewers) > maxRequestReviewerCount { + return nil, false + } + normalized := make([]string, 0, len(reviewers)) + seen := make(map[string]struct{}, len(reviewers)) + for _, reviewer := range reviewers { + login := strings.TrimSpace(reviewer) + if login == "" || len(login) > maxRequestReviewerLoginBytes { + return nil, false + } + key := strings.ToLower(login) + if _, ok := seen[key]; ok { + continue + } + seen[key] = struct{}{} + normalized = append(normalized, login) + } + return normalized, len(normalized) > 0 +} + func (c *Controller) httpMergePR(ctx *gin.Context) { owner := ctx.Param("owner") repo := ctx.Param("repo") diff --git a/apps/backend/internal/github/controller_test.go b/apps/backend/internal/github/controller_test.go index 7faefddb3b..7644617e8b 100644 --- a/apps/backend/internal/github/controller_test.go +++ b/apps/backend/internal/github/controller_test.go @@ -9,6 +9,7 @@ import ( "net/http" "net/http/httptest" "path/filepath" + "slices" "strings" "testing" "time" @@ -28,6 +29,7 @@ type stubClient struct { getIssueFunc func(ctx context.Context, owner, repo string, number int) (*Issue, error) mergePRFn func(ctx context.Context, owner, repo string, number int, mergeMethod string) error getRepoMergeMethodsFn func() (RepoMergeMethods, error) + requestReviewersFn func(ctx context.Context, owner, repo string, number int, reviewers []string) error } func (s *stubClient) IsAuthenticated(context.Context) (bool, error) { return true, nil } @@ -92,6 +94,13 @@ func (s *stubClient) ListPRCommits(context.Context, string, string, int) ([]PRCo func (s *stubClient) SubmitReview(context.Context, string, string, int, string, string) error { return nil } + +func (s *stubClient) RequestReviewers(ctx context.Context, owner, repo string, number int, reviewers []string) error { + if s.requestReviewersFn != nil { + return s.requestReviewersFn(ctx, owner, repo, number, reviewers) + } + return nil +} func (s *stubClient) MergePR(ctx context.Context, owner, repo string, number int, mergeMethod string) error { if s.mergePRFn != nil { return s.mergePRFn(ctx, owner, repo, number, mergeMethod) @@ -1310,6 +1319,15 @@ func TestHttpMergePR_NoClient_Returns503(t *testing.T) { if w.Code != http.StatusServiceUnavailable { t.Fatalf("expected 503, got %d: %s", w.Code, w.Body.String()) } + var response struct { + Code string `json:"code"` + } + if err := json.NewDecoder(w.Body).Decode(&response); err != nil { + t.Fatalf("decode response: %v", err) + } + if response.Code != "github_not_configured" { + t.Fatalf("response code = %q, want github_not_configured", response.Code) + } } // TestHttpSubmitReview_SelfApproveReturns422 exercises the full controller → @@ -1346,6 +1364,134 @@ func TestHttpSubmitReview_SelfApproveReturns422(t *testing.T) { } } +func TestHttpRequestReviewers_RequestsReviewers(t *testing.T) { + client := NewMockClient() + router, _ := setupControllerTest(client) + + req := httptest.NewRequest(http.MethodPost, "/api/v1/github/prs/acme/widget/42/requested-reviewers", strings.NewReader(`{"reviewers":["octocat"]}`)) + req.Header.Set("Content-Type", "application/json") + w := httptest.NewRecorder() + router.ServeHTTP(w, req) + + if w.Code != http.StatusOK { + t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String()) + } + var response struct { + Requested bool `json:"requested"` + } + if err := json.NewDecoder(w.Body).Decode(&response); err != nil { + t.Fatalf("decode response: %v", err) + } + if !response.Requested { + t.Fatal("expected requested=true") + } +} + +func TestHttpRequestReviewers_NormalizesReviewersBeforeClientDelegation(t *testing.T) { + client := NewMockClient() + router, _ := setupControllerTest(client) + + req := httptest.NewRequest(http.MethodPost, "/api/v1/github/prs/acme/widget/42/requested-reviewers", strings.NewReader(`{"reviewers":[" OctoCat ","octocat","hubot ","HUBOT"]}`)) + req.Header.Set("Content-Type", "application/json") + w := httptest.NewRecorder() + router.ServeHTTP(w, req) + + if w.Code != http.StatusOK { + t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String()) + } + if got, want := client.requestedReviews[0].Reviewers, []string{"OctoCat", "hubot"}; !slices.Equal(got, want) { + t.Fatalf("reviewers sent to client = %#v, want %#v", got, want) + } +} + +func TestHttpRequestReviewers_RejectsInvalidInput(t *testing.T) { + router, _ := setupControllerTest(NewMockClient()) + for _, tc := range []struct { + name string + path string + body string + }{ + {name: "zero PR number", path: "/api/v1/github/prs/acme/widget/0/requested-reviewers", body: `{"reviewers":["octocat"]}`}, + {name: "empty reviewers", path: "/api/v1/github/prs/acme/widget/42/requested-reviewers", body: `{"reviewers":[]}`}, + {name: "blank reviewer", path: "/api/v1/github/prs/acme/widget/42/requested-reviewers", body: `{"reviewers":[" "]}`}, + } { + t.Run(tc.name, func(t *testing.T) { + req := httptest.NewRequest(http.MethodPost, tc.path, strings.NewReader(tc.body)) + req.Header.Set("Content-Type", "application/json") + w := httptest.NewRecorder() + router.ServeHTTP(w, req) + if w.Code != http.StatusBadRequest { + t.Fatalf("expected 400, got %d: %s", w.Code, w.Body.String()) + } + }) + } +} + +func TestHttpRequestReviewers_RejectsBoundedInputBeforeClientDelegation(t *testing.T) { + overCountReviewers := make([]string, 51) + for i := range overCountReviewers { + overCountReviewers[i] = fmt.Sprintf("reviewer-%d", i) + } + overCountBody, err := json.Marshal(map[string][]string{"reviewers": overCountReviewers}) + if err != nil { + t.Fatalf("marshal over-count body: %v", err) + } + + for _, tc := range []struct { + name string + body string + }{ + {name: "malformed JSON", body: `{"reviewers":[`}, + {name: "oversized body", body: `{"reviewers":["` + strings.Repeat("a", 64*1024) + `"]}`}, + {name: "over-count reviewers", body: string(overCountBody)}, + {name: "overlong login", body: `{"reviewers":["` + strings.Repeat("a", 257) + `"]}`}, + } { + t.Run(tc.name, func(t *testing.T) { + client := NewMockClient() + router, _ := setupControllerTest(client) + req := httptest.NewRequest(http.MethodPost, "/api/v1/github/prs/acme/widget/42/requested-reviewers", strings.NewReader(tc.body)) + req.Header.Set("Content-Type", "application/json") + w := httptest.NewRecorder() + router.ServeHTTP(w, req) + + if w.Code != http.StatusBadRequest { + t.Fatalf("expected 400, got %d: %s", w.Code, w.Body.String()) + } + if len(client.requestedReviews) != 0 { + t.Fatalf("client received reviewers: %#v", client.requestedReviews) + } + }) + } +} + +func TestHttpRequestReviewers_ErrNoClientReturns503(t *testing.T) { + router, _ := setupControllerTest(nil) + req := httptest.NewRequest(http.MethodPost, "/api/v1/github/prs/acme/widget/42/requested-reviewers", strings.NewReader(`{"reviewers":["octocat"]}`)) + req.Header.Set("Content-Type", "application/json") + w := httptest.NewRecorder() + router.ServeHTTP(w, req) + + if w.Code != http.StatusServiceUnavailable { + t.Fatalf("expected 503, got %d: %s", w.Code, w.Body.String()) + } +} + +func TestHttpRequestReviewers_UpstreamErrorReturns500(t *testing.T) { + router, _ := setupControllerTest(&stubClient{ + requestReviewersFn: func(context.Context, string, string, int, []string) error { + return errors.New("GitHub rejected reviewers") + }, + }) + req := httptest.NewRequest(http.MethodPost, "/api/v1/github/prs/acme/widget/42/requested-reviewers", strings.NewReader(`{"reviewers":["octocat"]}`)) + req.Header.Set("Content-Type", "application/json") + w := httptest.NewRecorder() + router.ServeHTTP(w, req) + + if w.Code != http.StatusInternalServerError { + t.Fatalf("expected 500, got %d: %s", w.Code, w.Body.String()) + } +} + // listAccessibleReposClient is a per-test client tuned for the // /api/v1/github/repos handler tests. Kept separate from the larger // stubClient so the existing PR/merge tests above keep their minimal shape. diff --git a/apps/backend/internal/github/gh_client.go b/apps/backend/internal/github/gh_client.go index 395f9ca218..04b5df88b6 100644 --- a/apps/backend/internal/github/gh_client.go +++ b/apps/backend/internal/github/gh_client.go @@ -771,6 +771,17 @@ func (c *GHClient) SubmitReview(ctx context.Context, owner, repo string, number return nil } +func (c *GHClient) RequestReviewers(ctx context.Context, owner, repo string, number int, reviewers []string) error { + args := []string{"api", fmt.Sprintf("repos/%s/%s/pulls/%d/requested_reviewers", owner, repo, number), "-X", "POST"} + for _, reviewer := range reviewers { + args = append(args, "-f", "reviewers[]="+reviewer) + } + if _, err := c.run(ctx, args...); err != nil { + return fmt.Errorf("request reviewers on PR #%d: %w", number, err) + } + return nil +} + func (c *GHClient) MergePR(ctx context.Context, owner, repo string, number int, mergeMethod string) error { endpoint := fmt.Sprintf("repos/%s/%s/pulls/%d/merge", owner, repo, number) args := []string{"api", endpoint, "-X", "PUT"} diff --git a/apps/backend/internal/github/gh_client_test.go b/apps/backend/internal/github/gh_client_test.go index 4b093c40dc..4f2edf9d6a 100644 --- a/apps/backend/internal/github/gh_client_test.go +++ b/apps/backend/internal/github/gh_client_test.go @@ -198,6 +198,29 @@ esac } } +func TestGHClient_RequestReviewers_UsesGitHubReviewRequestEndpoint(t *testing.T) { + binDir := t.TempDir() + logPath := filepath.Join(t.TempDir(), "gh-args.log") + ghPath := filepath.Join(binDir, "gh") + if err := os.WriteFile(ghPath, []byte("#!/bin/sh\nprintf '%s\\n' \"$*\" >> \"$GH_ARGS_LOG\"\n"), 0o755); err != nil { + t.Fatalf("write fake gh: %v", err) + } + t.Setenv("PATH", binDir+string(os.PathListSeparator)+os.Getenv("PATH")) + t.Setenv("GH_ARGS_LOG", logPath) + + if err := NewGHClient().RequestReviewers(context.Background(), "acme", "widget", 42, []string{"octocat"}); err != nil { + t.Fatalf("RequestReviewers: %v", err) + } + args, err := os.ReadFile(logPath) + if err != nil { + t.Fatalf("read args: %v", err) + } + want := "api repos/acme/widget/pulls/42/requested_reviewers -X POST -f reviewers[]=octocat\n" + if string(args) != want { + t.Fatalf("gh args = %q, want %q", args, want) + } +} + func TestDecodeGHCheckRuns(t *testing.T) { tests := []struct { name string diff --git a/apps/backend/internal/github/mock_client.go b/apps/backend/internal/github/mock_client.go index fbadab1853..e5d05d8e6c 100644 --- a/apps/backend/internal/github/mock_client.go +++ b/apps/backend/internal/github/mock_client.go @@ -48,6 +48,14 @@ type submittedReview struct { Body string `json:"body"` } +// requestedReviewers records a RequestReviewers call for test assertions. +type requestedReviewers struct { + Owner string `json:"owner"` + Repo string `json:"repo"` + Number int `json:"number"` + Reviewers []string `json:"reviewers"` +} + // mergedPR records a MergePR call for test assertions. type mergedPR struct { Owner string `json:"owner"` @@ -97,6 +105,7 @@ type MockClient struct { files map[prKey][]PRFile commits map[prKey][]PRCommitInfo submittedReviews []submittedReview + requestedReviews []requestedReviewers mergedPRs []mergedPR mergeMethods map[repoKey]RepoMergeMethods gists map[string]mockGist @@ -552,6 +561,33 @@ func (m *MockClient) SubmitReview(_ context.Context, owner, repo string, number return nil } +func (m *MockClient) RequestReviewers(_ context.Context, owner, repo string, number int, reviewers []string) error { + m.mu.Lock() + defer m.mu.Unlock() + m.requestedReviews = append(m.requestedReviews, requestedReviewers{ + Owner: owner, Repo: repo, Number: number, Reviewers: append([]string(nil), reviewers...), + }) + pr := m.prs[prKey{Owner: owner, Repo: repo, Number: number}] + if pr == nil { + return nil + } + for _, reviewer := range reviewers { + if !mockPRHasRequestedReviewer(pr, reviewer) { + pr.RequestedReviewers = append(pr.RequestedReviewers, RequestedReviewer{Login: reviewer, Type: reviewerTypeUser}) + } + } + return nil +} + +func mockPRHasRequestedReviewer(pr *PR, login string) bool { + for _, reviewer := range pr.RequestedReviewers { + if strings.EqualFold(reviewer.Login, login) { + return true + } + } + return false +} + func (m *MockClient) GetRepoMergeMethods(_ context.Context, owner, repo string) (RepoMergeMethods, error) { m.mu.RLock() defer m.mu.RUnlock() @@ -821,6 +857,7 @@ func (m *MockClient) Reset() { m.files = make(map[prKey][]PRFile) m.commits = make(map[prKey][]PRCommitInfo) m.submittedReviews = nil + m.requestedReviews = nil m.mergedPRs = nil m.mergeMethods = make(map[repoKey]RepoMergeMethods) m.gists = make(map[string]mockGist) @@ -841,6 +878,15 @@ func (m *MockClient) SubmittedReviews() []submittedReview { return result } +// RequestedReviews returns all recorded RequestReviewers calls. +func (m *MockClient) RequestedReviews() []requestedReviewers { + m.mu.RLock() + defer m.mu.RUnlock() + result := make([]requestedReviewers, len(m.requestedReviews)) + copy(result, m.requestedReviews) + return result +} + // MergedPRs returns all recorded MergePR calls. func (m *MockClient) MergedPRs() []mergedPR { m.mu.RLock() diff --git a/apps/backend/internal/github/mock_client_test.go b/apps/backend/internal/github/mock_client_test.go index e6d69a436c..3d554a6624 100644 --- a/apps/backend/internal/github/mock_client_test.go +++ b/apps/backend/internal/github/mock_client_test.go @@ -3,6 +3,7 @@ package github import ( "context" "errors" + "strings" "testing" "time" ) @@ -243,6 +244,33 @@ func TestMockClient_SubmitReview(t *testing.T) { } } +func TestMockClient_RequestReviewers_RecordsAndDeduplicatesCaseInsensitively(t *testing.T) { + m := NewMockClient() + m.AddPR(&PR{ + RepoOwner: "o", + RepoName: "r", + Number: 1, + RequestedReviewers: []RequestedReviewer{ + {Login: "OctoCat", Type: reviewerTypeUser}, + }, + }) + + if err := m.RequestReviewers(context.Background(), "o", "r", 1, []string{"octocat", "hubot"}); err != nil { + t.Fatalf("RequestReviewers: %v", err) + } + requests := m.RequestedReviews() + if len(requests) != 1 || strings.Join(requests[0].Reviewers, ",") != "octocat,hubot" { + t.Fatalf("recorded requests = %#v", requests) + } + pr, err := m.GetPR(context.Background(), "o", "r", 1) + if err != nil { + t.Fatalf("GetPR: %v", err) + } + if got := strings.Join([]string{pr.RequestedReviewers[0].Login, pr.RequestedReviewers[1].Login}, ","); got != "OctoCat,hubot" { + t.Fatalf("requested reviewers = %q", got) + } +} + func TestMockClient_CreateAndDeleteGist(t *testing.T) { m := NewMockClient() ctx := context.Background() diff --git a/apps/backend/internal/github/noop_client.go b/apps/backend/internal/github/noop_client.go index 655d58721a..5467e6ca3f 100644 --- a/apps/backend/internal/github/noop_client.go +++ b/apps/backend/internal/github/noop_client.go @@ -97,6 +97,10 @@ func (c *NoopClient) SubmitReview(context.Context, string, string, int, string, return ErrNoClient } +func (c *NoopClient) RequestReviewers(context.Context, string, string, int, []string) error { + return ErrNoClient +} + func (c *NoopClient) MergePR(context.Context, string, string, int, string) error { return ErrNoClient } diff --git a/apps/backend/internal/github/noop_client_test.go b/apps/backend/internal/github/noop_client_test.go index 0146b57558..0d0fab8564 100644 --- a/apps/backend/internal/github/noop_client_test.go +++ b/apps/backend/internal/github/noop_client_test.go @@ -43,4 +43,9 @@ func TestNoopClient_ReturnsErrNoClient(t *testing.T) { if !errors.Is(err, ErrNoClient) { t.Errorf("SubmitReview error = %v, want ErrNoClient", err) } + + err = c.RequestReviewers(ctx, "o", "r", 1, []string{"octocat"}) + if !errors.Is(err, ErrNoClient) { + t.Errorf("RequestReviewers error = %v, want ErrNoClient", err) + } } diff --git a/apps/backend/internal/github/pat_client.go b/apps/backend/internal/github/pat_client.go index d04b4710aa..99979aa2aa 100644 --- a/apps/backend/internal/github/pat_client.go +++ b/apps/backend/internal/github/pat_client.go @@ -626,6 +626,17 @@ func (c *PATClient) SubmitReview(ctx context.Context, owner, repo string, number return c.post(ctx, endpoint, jsonBody) } +func (c *PATClient) RequestReviewers(ctx context.Context, owner, repo string, number int, reviewers []string) error { + endpoint := fmt.Sprintf("/repos/%s/%s/pulls/%d/requested_reviewers", owner, repo, number) + jsonBody, err := json.Marshal(struct { + Reviewers []string `json:"reviewers"` + }{Reviewers: reviewers}) + if err != nil { + return fmt.Errorf("marshal requested reviewers payload: %w", err) + } + return c.post(ctx, endpoint, jsonBody) +} + func (c *PATClient) MergePR(ctx context.Context, owner, repo string, number int, mergeMethod string) error { endpoint := fmt.Sprintf("/repos/%s/%s/pulls/%d/merge", owner, repo, number) payload := map[string]string{} diff --git a/apps/backend/internal/github/pat_client_test.go b/apps/backend/internal/github/pat_client_test.go index d92be6d866..cee4f268d6 100644 --- a/apps/backend/internal/github/pat_client_test.go +++ b/apps/backend/internal/github/pat_client_test.go @@ -129,6 +129,32 @@ func TestPATClientSearchPreservesImmutableIdentity(t *testing.T) { } } +func TestPATClient_RequestReviewers_UsesGitHubReviewRequestEndpoint(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.Method != http.MethodPost { + t.Errorf("method = %s, want POST", r.Method) + } + if r.URL.Path != "/repos/acme/widget/pulls/42/requested_reviewers" { + t.Errorf("path = %q", r.URL.Path) + } + var body struct { + Reviewers []string `json:"reviewers"` + } + if err := json.NewDecoder(r.Body).Decode(&body); err != nil { + t.Errorf("decode body: %v", err) + } + if got := strings.Join(body.Reviewers, ","); got != "octocat,hubot" { + t.Errorf("reviewers = %q", got) + } + w.WriteHeader(http.StatusCreated) + })) + t.Cleanup(srv.Close) + + if err := newPATClientPointingAt(t, srv.URL).RequestReviewers(context.Background(), "acme", "widget", 42, []string{"octocat", "hubot"}); err != nil { + t.Fatalf("RequestReviewers: %v", err) + } +} + func TestPATClient_ListCheckRunsPaginatesCheckRuns(t *testing.T) { var requestedPages []string srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { diff --git a/apps/backend/internal/github/service_pr.go b/apps/backend/internal/github/service_pr.go index badd8e420b..5be4e68f92 100644 --- a/apps/backend/internal/github/service_pr.go +++ b/apps/backend/internal/github/service_pr.go @@ -32,6 +32,21 @@ func (s *Service) SubmitReview(ctx context.Context, owner, repo string, number i return s.client.SubmitReview(ctx, owner, repo, number, event, body) } +// RequestReviewers requests reviews and evicts the affected PR caches so the +// next feedback/status fetch reflects GitHub's new requested reviewer state. +func (s *Service) RequestReviewers(ctx context.Context, owner, repo string, number int, reviewers []string) error { + if s.client == nil { + return ErrNoClient + } + if err := s.client.RequestReviewers(ctx, owner, repo, number, reviewers); err != nil { + return err + } + key := prStatusCacheKey(owner, repo, number) + s.prFeedbackCache.invalidateKey(key) + s.prStatusCache.invalidateKey(key) + return nil +} + // MergePR merges a pull request. mergeMethod is one of "merge", "squash", // "rebase"; an empty string asks the service to pick the first method the // repo allows. The caller is expected to refresh PR feedback after a diff --git a/apps/backend/internal/github/service_request_review_test.go b/apps/backend/internal/github/service_request_review_test.go new file mode 100644 index 0000000000..d0f5b1ef2f --- /dev/null +++ b/apps/backend/internal/github/service_request_review_test.go @@ -0,0 +1,160 @@ +package github + +import ( + "context" + "errors" + "testing" + "time" +) + +type cacheCountingReviewRequestClient struct { + *MockClient + feedbackCalls int + statusCalls int + err error +} + +func TestService_RequestReviewers_InvalidatesOnlyAffectedInFlightPRCaches(t *testing.T) { + client := &cacheCountingReviewRequestClient{MockClient: NewMockClient()} + svc := newTestService(client) + key := prStatusCacheKey("o", "r", 1) + unrelatedKey := prStatusCacheKey("o", "r", 2) + + for name, cache := range map[string]*ttlCache{ + "feedback": svc.prFeedbackCache, + "status": svc.prStatusCache, + } { + t.Run(name, func(t *testing.T) { + targetStarted := make(chan struct{}) + unrelatedStarted := make(chan struct{}) + releaseTarget := make(chan struct{}) + releaseUnrelated := make(chan struct{}) + targetDone := make(chan any, 1) + unrelatedDone := make(chan any, 1) + + go func() { + value, _ := cache.doOrFetch(key, func() (any, error) { + close(targetStarted) + <-releaseTarget + return "stale", nil + }) + targetDone <- value + }() + go func() { + value, _ := cache.doOrFetch(unrelatedKey, func() (any, error) { + close(unrelatedStarted) + <-releaseUnrelated + return "unrelated", nil + }) + unrelatedDone <- value + }() + + <-targetStarted + <-unrelatedStarted + if err := svc.RequestReviewers(context.Background(), "o", "r", 1, []string{"octocat"}); err != nil { + t.Fatalf("RequestReviewers: %v", err) + } + + freshDone := make(chan any, 1) + go func() { + value, _ := cache.doOrFetch(key, func() (any, error) { + return "fresh", nil + }) + freshDone <- value + }() + select { + case value := <-freshDone: + if value != "fresh" { + t.Fatalf("post-invalidation fetch = %v, want fresh", value) + } + case <-time.After(2 * time.Second): + t.Fatal("post-invalidation fetch joined the stale in-flight call") + } + + close(releaseTarget) + close(releaseUnrelated) + <-targetDone + <-unrelatedDone + + if value, ok := cache.get(key); !ok || value != "fresh" { + t.Fatalf("affected cache = %v, %t; want fresh, true", value, ok) + } + if value, ok := cache.get(unrelatedKey); !ok || value != "unrelated" { + t.Fatalf("unrelated cache = %v, %t; want unrelated, true", value, ok) + } + }) + } +} + +func (c *cacheCountingReviewRequestClient) GetPRFeedback(context.Context, string, string, int) (*PRFeedback, error) { + c.feedbackCalls++ + return &PRFeedback{}, nil +} + +func (c *cacheCountingReviewRequestClient) GetPRStatus(context.Context, string, string, int) (*PRStatus, error) { + c.statusCalls++ + return &PRStatus{}, nil +} + +func (c *cacheCountingReviewRequestClient) RequestReviewers(ctx context.Context, owner, repo string, number int, reviewers []string) error { + if c.err != nil { + return c.err + } + return c.MockClient.RequestReviewers(ctx, owner, repo, number, reviewers) +} + +func TestService_RequestReviewers_EvictsOnlyAffectedCachesOnSuccess(t *testing.T) { + client := &cacheCountingReviewRequestClient{MockClient: NewMockClient()} + svc := newTestService(client) + ctx := context.Background() + + for _, number := range []int{1, 2} { + if _, err := svc.GetPRFeedback(ctx, "o", "r", number); err != nil { + t.Fatalf("prime feedback: %v", err) + } + if _, err := svc.GetPRStatus(ctx, "o", "r", number); err != nil { + t.Fatalf("prime status: %v", err) + } + } + if err := svc.RequestReviewers(ctx, "o", "r", 1, []string{"octocat"}); err != nil { + t.Fatalf("RequestReviewers: %v", err) + } + for _, number := range []int{1, 2} { + if _, err := svc.GetPRFeedback(ctx, "o", "r", number); err != nil { + t.Fatalf("fetch feedback: %v", err) + } + if _, err := svc.GetPRStatus(ctx, "o", "r", number); err != nil { + t.Fatalf("fetch status: %v", err) + } + } + if client.feedbackCalls != 3 || client.statusCalls != 3 { + t.Fatalf("calls feedback/status = %d/%d, want 3/3", client.feedbackCalls, client.statusCalls) + } +} + +func TestService_RequestReviewers_KeepsCachesOnFailure(t *testing.T) { + client := &cacheCountingReviewRequestClient{MockClient: NewMockClient(), err: errors.New("GitHub rejected request")} + svc := newTestService(client) + ctx := context.Background() + if _, err := svc.GetPRFeedback(ctx, "o", "r", 1); err != nil { + t.Fatalf("prime feedback: %v", err) + } + if _, err := svc.GetPRStatus(ctx, "o", "r", 1); err != nil { + t.Fatalf("prime status: %v", err) + } + if err := svc.RequestReviewers(ctx, "o", "r", 1, []string{"octocat"}); err == nil { + t.Fatal("expected request error") + } + if _, err := svc.GetPRFeedback(ctx, "o", "r", 1); err != nil { + t.Fatalf("fetch feedback: %v", err) + } + if _, err := svc.GetPRStatus(ctx, "o", "r", 1); err != nil { + t.Fatalf("fetch status: %v", err) + } + if client.feedbackCalls != 1 || client.statusCalls != 1 { + t.Fatalf("calls feedback/status = %d/%d, want 1/1", client.feedbackCalls, client.statusCalls) + } + if requests := client.RequestedReviews(); len(requests) != 0 { + t.Fatalf("failed request recorded mock pending state: %#v", requests) + } +} diff --git a/apps/backend/internal/github/ttl_cache.go b/apps/backend/internal/github/ttl_cache.go index 19e2672258..6de3fb0eb8 100644 --- a/apps/backend/internal/github/ttl_cache.go +++ b/apps/backend/internal/github/ttl_cache.go @@ -22,6 +22,11 @@ type ttlEntry struct { expiresAt time.Time } +type cacheKeyEpoch struct { + epoch uint64 + active int +} + // ttlCache is a tiny TTL map guarded by singleflight to coalesce concurrent // misses for the same key. When size exceeds the cap, entries with the // earliest expiry are dropped — good enough for a sub-minute window. @@ -32,21 +37,23 @@ type ttlEntry struct { // the cache — otherwise the new user could see stale repos from the prior // user for up to one TTL. type ttlCache struct { - mu sync.Mutex - entries map[string]ttlEntry - sf singleflight.Group - ttl time.Duration - maxSize int - now func() time.Time - gen uint64 + mu sync.Mutex + entries map[string]ttlEntry + sf singleflight.Group + ttl time.Duration + maxSize int + now func() time.Time + gen uint64 + keyEpochs map[string]cacheKeyEpoch } func newTTLCache() *ttlCache { return &ttlCache{ - entries: make(map[string]ttlEntry), - ttl: defaultCacheTTL, - maxSize: defaultCacheMaxSize, - now: time.Now, + entries: make(map[string]ttlEntry), + ttl: defaultCacheTTL, + maxSize: defaultCacheMaxSize, + now: time.Now, + keyEpochs: make(map[string]cacheKeyEpoch), } } @@ -112,6 +119,7 @@ func (c *ttlCache) clear() { c.mu.Lock() defer c.mu.Unlock() c.entries = make(map[string]ttlEntry) + c.keyEpochs = make(map[string]cacheKeyEpoch) c.gen++ } @@ -149,6 +157,46 @@ func (c *ttlCache) setIfCurrentGeneration(key string, value any, gen uint64) { c.entries[key] = ttlEntry{value: value, expiresAt: c.now().Add(c.ttl)} } +func (c *ttlCache) beginFill(key string) (uint64, uint64) { + c.mu.Lock() + defer c.mu.Unlock() + state := c.keyEpochs[key] + state.active++ + c.keyEpochs[key] = state + return c.gen, state.epoch +} + +func (c *ttlCache) endFill(key string, gen uint64) { + c.mu.Lock() + defer c.mu.Unlock() + if c.gen != gen { + return + } + state, ok := c.keyEpochs[key] + if !ok { + return + } + state.active-- + if state.active == 0 { + delete(c.keyEpochs, key) + return + } + c.keyEpochs[key] = state +} + +func (c *ttlCache) setIfCurrentVersions(key string, value any, gen, keyEpoch uint64) { + c.mu.Lock() + defer c.mu.Unlock() + state, ok := c.keyEpochs[key] + if c.gen != gen || !ok || state.epoch != keyEpoch { + return + } + if len(c.entries) >= c.maxSize { + c.evictLocked() + } + c.entries[key] = ttlEntry{value: value, expiresAt: c.now().Add(c.ttl)} +} + // evictLocked first drops expired entries; if still over the cap, drops the // entries with the earliest expiry until back under the limit. Caller must // hold c.mu. @@ -191,9 +239,25 @@ func (c *ttlCache) del(key string) { c.mu.Lock() defer c.mu.Unlock() delete(c.entries, key) + c.keyEpochs = make(map[string]cacheKeyEpoch) c.gen++ } +// invalidateKey removes a single key without changing the cache-wide +// generation. A pending fill for that key cannot write back because its key +// epoch no longer matches, while fills for unrelated keys remain cacheable. +func (c *ttlCache) invalidateKey(key string) { + c.mu.Lock() + defer c.mu.Unlock() + delete(c.entries, key) + state, ok := c.keyEpochs[key] + if !ok { + return + } + state.epoch++ + c.keyEpochs[key] = state +} + // cachedErr wraps an error stored in a ttlCache so that a deterministic // upstream failure (e.g. ErrRepoNotResolvable) can be negative-cached // alongside the cache's normal success-value entries. Currently used by @@ -213,14 +277,12 @@ func (c *ttlCache) doOrFetch(key string, fetch func() (any, error)) (any, error) if v, ok := c.get(key); ok { return v, nil } - gen := c.generation() - // Key the singleflight on the generation as well as the cache key. Without - // the generation prefix, a caller arriving after clear() would join an - // already-in-flight fetch from the previous generation and receive its - // stale result — singleflight's whole point is shared results. Bumping - // gen on clear() guarantees the post-clear caller mints its own fetch - // instead of inheriting the old one. - sfKey := fmt.Sprintf("%d|%s", gen, key) + gen, keyEpoch := c.beginFill(key) + defer c.endFill(key, gen) + // Key singleflight on the cache-wide generation and per-key epoch. A + // post-clear or post-key-invalidation caller must mint a fresh fill instead + // of joining a stale in-flight result. + sfKey := fmt.Sprintf("%d|%d|%s", gen, keyEpoch, key) v, err, _ := c.sf.Do(sfKey, func() (any, error) { if v, ok := c.get(key); ok { return v, nil @@ -229,7 +291,7 @@ func (c *ttlCache) doOrFetch(key string, fetch func() (any, error)) (any, error) if err != nil { return nil, err } - c.setIfCurrentGeneration(key, v, gen) + c.setIfCurrentVersions(key, v, gen, keyEpoch) return v, nil }) return v, err diff --git a/apps/backend/internal/github/ttl_cache_test.go b/apps/backend/internal/github/ttl_cache_test.go index d806d46b88..ed0aa06492 100644 --- a/apps/backend/internal/github/ttl_cache_test.go +++ b/apps/backend/internal/github/ttl_cache_test.go @@ -258,3 +258,73 @@ func TestTTLCache_MaxSizeEviction(t *testing.T) { t.Fatalf("cache exceeded maxSize: %d", len(cache.entries)) } } + +func TestTTLCache_InvalidateIdleKeysDoesNotRetainEpochMetadata(t *testing.T) { + cache := newTTLCache() + for i := 0; i < 1000; i++ { + cache.invalidateKey(fmt.Sprintf("pr-%d", i)) + } + if got := len(cache.keyEpochs); got != 0 { + t.Fatalf("idle invalidation retained %d epoch entries, want 0", got) + } +} + +func TestTTLCache_InvalidateInFlightFillReclaimsEpochMetadata(t *testing.T) { + cache := newTTLCache() + oldStarted := make(chan struct{}) + freshStarted := make(chan struct{}) + unrelatedStarted := make(chan struct{}) + releaseOld := make(chan struct{}) + releaseFresh := make(chan struct{}) + releaseUnrelated := make(chan struct{}) + oldDone := make(chan struct{}) + freshDone := make(chan struct{}) + unrelatedDone := make(chan struct{}) + + go func() { + defer close(oldDone) + _, _ = cache.doOrFetch("affected", func() (any, error) { + close(oldStarted) + <-releaseOld + return "stale", nil + }) + }() + go func() { + defer close(unrelatedDone) + _, _ = cache.doOrFetch("unrelated", func() (any, error) { + close(unrelatedStarted) + <-releaseUnrelated + return "unrelated", nil + }) + }() + + <-oldStarted + <-unrelatedStarted + cache.invalidateKey("affected") + + go func() { + defer close(freshDone) + _, _ = cache.doOrFetch("affected", func() (any, error) { + close(freshStarted) + <-releaseFresh + return "fresh", nil + }) + }() + <-freshStarted + close(releaseFresh) + <-freshDone + close(releaseOld) + close(releaseUnrelated) + <-oldDone + <-unrelatedDone + + if value, ok := cache.get("affected"); !ok || value != "fresh" { + t.Fatalf("affected cache = %v, %t; want fresh, true", value, ok) + } + if value, ok := cache.get("unrelated"); !ok || value != "unrelated" { + t.Fatalf("unrelated cache = %v, %t; want unrelated, true", value, ok) + } + if got := len(cache.keyEpochs); got != 0 { + t.Fatalf("completed fills retained %d epoch entries, want 0", got) + } +} diff --git a/apps/web/components/github/pr-detail-panel.test.ts b/apps/web/components/github/pr-detail-panel.test.ts index bfb8d56a39..e08b9bf83e 100644 --- a/apps/web/components/github/pr-detail-panel.test.ts +++ b/apps/web/components/github/pr-detail-panel.test.ts @@ -1,7 +1,74 @@ -import { describe, it, expect } from "vitest"; -import { shouldHideApproveButton } from "./pr-detail-panel"; +import { act, cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react"; +import { createElement, useEffect } from "react"; +import { TooltipProvider } from "@kandev/ui/tooltip"; +import { afterEach, describe, it, expect, vi } from "vitest"; +import { + PRDetailContent, + shouldHideApproveButton, + shouldShowReRequestReviewAction, +} from "./pr-detail-panel"; +import { + clearPRReviewRequestRegistryForTests, + usePRScopedReviewRequest, +} from "./use-pr-scoped-review-request"; import type { TaskPR, PRFeedback, GitHubPR, PRReview } from "@/lib/types/github"; +const feedbackMocks = vi.hoisted(() => ({ + refresh: vi.fn(), + value: null as PRFeedback | null, +})); +const reviewMocks = vi.hoisted(() => ({ requestReviewers: vi.fn(), submitReview: vi.fn() })); +const RE_REQUEST_BUTTON = "pr-rerequest-review-octocat"; +const PENDING_REVIEWER = "pr-pending-reviewer-octocat"; +const DISMISSED_REVIEWED_AT = "2026-01-01T00:00:00Z"; + +vi.mock("@/hooks/domains/github/use-pr-feedback", () => ({ + usePRFeedback: () => ({ + feedback: feedbackMocks.value, + loading: false, + refresh: feedbackMocks.refresh, + }), +})); +vi.mock("@/lib/api/domains/github-review-api", () => ({ + requestPRReviewers: reviewMocks.requestReviewers, + submitPRReview: reviewMocks.submitReview, +})); +vi.mock("@/components/state-provider", () => ({ + useAppStore: (selector: (state: { setTaskPR: () => void }) => unknown) => + selector({ setTaskPR: vi.fn() }), +})); +vi.mock("@/lib/state/slices/comments", () => ({ + isPRFeedbackComment: () => false, + useCommentsStore: ( + selector: (state: { + addComment: () => void; + pendingForChat: string[]; + byId: object; + }) => unknown, + ) => selector({ addComment: vi.fn(), pendingForChat: [], byId: {} }), +})); +vi.mock("@/components/toast-provider", () => ({ useToast: () => ({ toast: vi.fn() }) })); +vi.mock("@/hooks/domains/github/use-github-status", () => ({ + useGitHubStatus: () => ({ status: null }), +})); +vi.mock("./pr-merge-button", () => ({ PRMergeButton: () => null })); +vi.mock("./pr-mergeability-notice", () => ({ + PRMergeabilityNotice: () => null, + buildConflictResolutionMessage: () => "", +})); +vi.mock("./pr-checks-section", () => ({ ChecksSection: () => null })); +vi.mock("./pr-comments-section", () => ({ CommentsSection: () => null })); + +afterEach(() => { + vi.useRealTimers(); + cleanup(); + feedbackMocks.refresh.mockReset(); + feedbackMocks.value = null; + reviewMocks.requestReviewers.mockReset(); + reviewMocks.submitReview.mockReset(); + clearPRReviewRequestRegistryForTests(); +}); + function makeTaskPR(overrides: Partial = {}): TaskPR { return { id: "id", @@ -70,11 +137,51 @@ function makeFeedback( }; } +function ReviewRequestHarness({ + onReady, + requestedReviewers = [], + reviews = [], +}: { + onReady: (reviewRequest: ReturnType) => void; + requestedReviewers?: { login: string; type: "user" }[]; + reviews?: PRReview[]; +}) { + const reviewRequest = usePRScopedReviewRequest( + makeTaskPR(), + requestedReviewers, + reviews, + vi.fn(), + vi.fn(), + ); + useEffect(() => onReady(reviewRequest), [onReady, reviewRequest]); + return null; +} + +function dismissedReview(id = 1): PRReview { + return { + id, + author: "octocat", + author_avatar: "", + state: "DISMISSED", + body: "", + created_at: DISMISSED_REVIEWED_AT, + }; +} + +function renderPRDetail() { + return render( + createElement( + TooltipProvider, + undefined, + createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }), + ), + ); +} + describe("shouldHideApproveButton", () => { it("hides when PR is closed", () => { expect(shouldHideApproveButton(makeTaskPR({ state: "closed" }), null, "bob")).toBe(true); }); - it("hides when PR is merged", () => { expect(shouldHideApproveButton(makeTaskPR({ state: "merged" }), null, "bob")).toBe(true); }); @@ -129,3 +236,395 @@ describe("shouldHideApproveButton", () => { ); }); }); + +describe("shouldShowReRequestReviewAction", () => { + it("only permits dismissed reviews on an open PR", () => { + expect(shouldShowReRequestReviewAction("open", "DISMISSED")).toBe(true); + expect(shouldShowReRequestReviewAction("open", "APPROVED")).toBe(false); + expect(shouldShowReRequestReviewAction("closed", "DISMISSED")).toBe(false); + expect(shouldShowReRequestReviewAction("merged", "DISMISSED")).toBe(false); + }); +}); + +describe("PRDetailContent deferred re-request", () => { + it("keeps a successfully re-requested reviewer pending when feedback refresh is deferred", async () => { + feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] }); + reviewMocks.requestReviewers.mockResolvedValue({ requested: true }); + + render( + createElement( + TooltipProvider, + undefined, + createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }), + ), + ); + + await act(async () => { + fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON)); + }); + + await waitFor(() => { + expect(screen.getByTestId(PENDING_REVIEWER)).not.toBeNull(); + }); + expect(screen.queryByTestId(RE_REQUEST_BUTTON)).toBeNull(); + }); +}); + +describe("PRDetailContent remount lifecycle", () => { + it("keeps an in-flight request locked across a same-PR remount", () => { + feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] }); + reviewMocks.requestReviewers.mockReturnValue(new Promise(() => undefined)); + + const firstPanel = render( + createElement( + TooltipProvider, + undefined, + createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }), + ), + ); + fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON)); + firstPanel.unmount(); + + render( + createElement( + TooltipProvider, + undefined, + createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }), + ), + ); + fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON)); + + expect(reviewMocks.requestReviewers).toHaveBeenCalledOnce(); + }); +}); + +describe("PRDetailContent optimistic review reconciliation", () => { + it("reclaims optimism when a newer submitted review bypasses requested-reviewer feedback", async () => { + feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] }); + reviewMocks.requestReviewers.mockResolvedValue({ requested: true }); + + const view = renderPRDetail(); + await act(async () => { + fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON)); + }); + feedbackMocks.value = makeFeedback({ + reviews: [ + { + id: 2, + author: "octocat", + author_avatar: "", + state: "APPROVED", + body: "Looks good", + created_at: "2026-01-02T00:00:00Z", + }, + ], + }); + view.rerender( + createElement( + TooltipProvider, + undefined, + createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }), + ), + ); + + await waitFor(() => { + expect(screen.queryByTestId(PENDING_REVIEWER)).toBeNull(); + }); + expect(screen.getByTestId("pr-submitted-review-octocat")).not.toBeNull(); + }); +}); + +describe("PRDetailContent same-timestamp review reconciliation", () => { + it("uses the review ID to resolve same-timestamp reviewer state", async () => { + feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] }); + reviewMocks.requestReviewers.mockResolvedValue({ requested: true }); + const view = renderPRDetail(); + await act(async () => fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON))); + + feedbackMocks.value = makeFeedback({ + reviews: [ + dismissedReview(), + { + id: 2, + author: "octocat", + author_avatar: "", + state: "APPROVED", + body: "Looks good", + created_at: DISMISSED_REVIEWED_AT, + }, + ], + }); + view.rerender( + createElement( + TooltipProvider, + undefined, + createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }), + ), + ); + + await waitFor(() => expect(screen.queryByTestId(PENDING_REVIEWER)).toBeNull()); + expect(screen.getByTestId("pr-submitted-review-octocat")).not.toBeNull(); + }); +}); + +describe("PRDetailContent confirmed review request", () => { + it("reclaims confirmed pending state from the persistent registry", async () => { + feedbackMocks.value = makeFeedback({ + reviews: [dismissedReview()], + }); + reviewMocks.requestReviewers.mockResolvedValue({ requested: true }); + const view = render( + createElement( + TooltipProvider, + undefined, + createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }), + ), + ); + await act(async () => { + fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON)); + }); + + feedbackMocks.value = makeFeedback({ + pr: { requested_reviewers: [{ login: "octocat", type: "user" }] }, + reviews: [ + { + id: 1, + author: "octocat", + author_avatar: "", + state: "DISMISSED", + body: "", + created_at: DISMISSED_REVIEWED_AT, + }, + ], + }); + view.rerender( + createElement( + TooltipProvider, + undefined, + createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }), + ), + ); + await waitFor(() => { + expect(screen.getByTestId(PENDING_REVIEWER)).not.toBeNull(); + }); + + feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] }); + view.rerender( + createElement( + TooltipProvider, + undefined, + createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }), + ), + ); + + await waitFor(() => { + expect(screen.getByTestId(RE_REQUEST_BUTTON)).not.toBeNull(); + }); + }); +}); + +describe("PRDetailContent same-tick re-request", () => { + it("posts once when invoked twice before React has a chance to re-render", () => { + reviewMocks.requestReviewers.mockReturnValue(new Promise(() => undefined)); + let reRequest: (reviewer: string) => Promise = async () => undefined; + + render( + createElement(ReviewRequestHarness, { + onReady: (request) => { + reRequest = request.reRequest; + }, + }), + ); + act(() => { + void reRequest("octocat"); + void reRequest("octocat"); + }); + + expect(reviewMocks.requestReviewers).toHaveBeenCalledOnce(); + }); +}); + +describe("PRDetailContent persistent request expiry", () => { + it("keeps an unresolved request locked beyond the optimistic expiry window", () => { + vi.useFakeTimers(); + feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] }); + const deferred = new Promise(() => undefined); + reviewMocks.requestReviewers.mockReturnValue(deferred); + + const view = renderPRDetail(); + fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON)); + act(() => vi.advanceTimersByTime(5 * 60 * 1000)); + view.rerender( + createElement( + TooltipProvider, + undefined, + createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }), + ), + ); + + expect(screen.getByTestId(RE_REQUEST_BUTTON).hasAttribute("disabled")).toBe(true); + vi.useRealTimers(); + }); + + it("expires successful optimism and updates the panel without a rerender", async () => { + vi.useFakeTimers(); + feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] }); + reviewMocks.requestReviewers.mockResolvedValue({ requested: true }); + renderPRDetail(); + await act(async () => fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON))); + expect(vi.getTimerCount()).toBe(1); + + act(() => vi.advanceTimersByTime(5 * 60 * 1000)); + + expect(screen.getByTestId(RE_REQUEST_BUTTON).hasAttribute("disabled")).toBe(false); + vi.useRealTimers(); + }); + + it("clears the expiry timer when feedback confirms the request", async () => { + vi.useFakeTimers(); + feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] }); + reviewMocks.requestReviewers.mockResolvedValue({ requested: true }); + const view = renderPRDetail(); + await act(async () => fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON))); + expect(vi.getTimerCount()).toBe(1); + + feedbackMocks.value = makeFeedback({ + pr: { requested_reviewers: [{ login: "octocat", type: "user" }] }, + }); + view.rerender( + createElement( + TooltipProvider, + undefined, + createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }), + ), + ); + await act(async () => undefined); + + expect(vi.getTimerCount()).toBe(0); + vi.useRealTimers(); + }); + + it("reschedules to the next optimistic expiry after the first expires", async () => { + vi.useFakeTimers(); + reviewMocks.requestReviewers.mockResolvedValue({ requested: true }); + let reviewRequest: ReturnType | undefined; + render( + createElement(ReviewRequestHarness, { + onReady: (value) => { + reviewRequest = value; + }, + }), + ); + + await act(async () => reviewRequest?.reRequest("octocat")); + act(() => vi.advanceTimersByTime(60 * 1000)); + await act(async () => reviewRequest?.reRequest("hubot")); + act(() => vi.advanceTimersByTime(4 * 60 * 1000)); + + expect(reviewRequest?.requestedReviewers).toEqual([{ login: "hubot", type: "user" }]); + vi.useRealTimers(); + }); +}); + +describe("PRDetailContent request operation ownership", () => { + it("does not let an old completion change a newer request", async () => { + let resolveFirst: () => void = () => undefined; + const firstRequest = new Promise((resolve) => { + resolveFirst = resolve; + }); + const secondRequest = new Promise(() => undefined); + reviewMocks.requestReviewers + .mockReturnValueOnce(firstRequest) + .mockReturnValueOnce(secondRequest); + let reviewRequest: ReturnType | undefined; + const onReady = (value: ReturnType) => { + reviewRequest = value; + }; + const view = render(createElement(ReviewRequestHarness, { onReady })); + + act(() => void reviewRequest?.reRequest("octocat")); + view.rerender( + createElement(ReviewRequestHarness, { + onReady, + requestedReviewers: [{ login: "octocat", type: "user" }], + }), + ); + view.rerender(createElement(ReviewRequestHarness, { onReady })); + act(() => void reviewRequest?.reRequest("octocat")); + await act(async () => resolveFirst()); + + expect(reviewRequest?.requestingReviewers).toEqual(["octocat"]); + }); +}); + +describe("PRDetailContent failed feedback refresh", () => { + it("keeps the successful re-request optimistic", async () => { + feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] }); + feedbackMocks.refresh.mockImplementation(() => { + throw new Error("Feedback refresh failed"); + }); + reviewMocks.requestReviewers.mockResolvedValue({ requested: true }); + + renderPRDetail(); + await act(async () => { + fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON)); + }); + + expect(screen.getByTestId(PENDING_REVIEWER)).not.toBeNull(); + }); +}); + +describe("PRDetailContent failed re-request", () => { + it("clears failed writes so the dismissed reviewer can be retried", async () => { + feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] }); + reviewMocks.requestReviewers.mockRejectedValue(new Error("GitHub denied request")); + + renderPRDetail(); + + await act(async () => { + fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON)); + }); + await waitFor(() => { + expect(screen.getByTestId(RE_REQUEST_BUTTON).hasAttribute("disabled")).toBe(false); + }); + + await act(async () => { + fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON)); + }); + expect(reviewMocks.requestReviewers).toHaveBeenCalledTimes(2); + }); +}); + +describe("PRDetailContent PR identity changes", () => { + it("does not retain optimistic reviewers after the repository PR identity changes", async () => { + feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] }); + reviewMocks.requestReviewers.mockResolvedValue({ requested: true }); + + const view = render( + createElement( + TooltipProvider, + undefined, + createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }), + ), + ); + await act(async () => { + fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON)); + }); + await waitFor(() => { + expect(screen.getByTestId(PENDING_REVIEWER)).not.toBeNull(); + }); + + view.rerender( + createElement( + TooltipProvider, + undefined, + createElement(PRDetailContent, { + taskPR: makeTaskPR({ pr_number: 2 }), + sessionId: "session-1", + }), + ), + ); + + expect(screen.getByTestId(RE_REQUEST_BUTTON)).not.toBeNull(); + }); +}); diff --git a/apps/web/components/github/pr-detail-panel.tsx b/apps/web/components/github/pr-detail-panel.tsx index ac7261c844..7df10440e9 100644 --- a/apps/web/components/github/pr-detail-panel.tsx +++ b/apps/web/components/github/pr-detail-panel.tsx @@ -23,7 +23,7 @@ import { useGitHubStatus } from "@/hooks/domains/github/use-github-status"; import { useCommentsStore, isPRFeedbackComment } from "@/lib/state/slices/comments"; import type { PRFeedbackComment } from "@/lib/state/slices/comments"; import { useToast } from "@/components/toast-provider"; -import { submitPRReview } from "@/lib/api/domains/github-api"; +import { submitPRReview } from "@/lib/api/domains/github-review-api"; import type { TaskPR, PRFeedback } from "@/lib/types/github"; import { formatTimeAgo, @@ -38,6 +38,7 @@ import { ReviewStateBadge } from "./pr-reviews-section"; import { ChecksSection } from "./pr-checks-section"; import { ReviewsSection } from "./pr-reviews-section"; import { CommentsSection } from "./pr-comments-section"; +import { usePRScopedReviewRequest } from "./use-pr-scoped-review-request"; // --- Dockview panel wrapper --- @@ -215,8 +216,6 @@ function derivePanelMetrics(taskPR: TaskPR, feedback: PRFeedback | null): PRPane }; } -// --- Main content --- - function DescriptionSection({ body }: { body: string }) { if (!body) return null; return ( @@ -251,6 +250,10 @@ export function shouldHideApproveButton( ); } +export function shouldShowReRequestReviewAction(prState: string, reviewState: string): boolean { + return prState === "open" && reviewState === "DISMISSED"; +} + function ApproveButton({ taskPR, feedback, @@ -305,6 +308,14 @@ function ApproveButton({ export function PRDetailContent({ taskPR, sessionId }: { taskPR: TaskPR; sessionId: string }) { const { feedback, loading, refresh } = usePRFeedback(taskPR.owner, taskPR.repo, taskPR.pr_number); const { addAsContext } = useAddPRFeedbackAsContext(sessionId, taskPR.pr_number); + const { toast } = useToast(); + const reviewRequest = usePRScopedReviewRequest( + taskPR, + feedback?.pr.requested_reviewers ?? [], + feedback?.reviews ?? [], + refresh, + toast, + ); useSyncLivePRState(taskPR, feedback); @@ -350,7 +361,7 @@ export function PRDetailContent({ taskPR, sessionId }: { taskPR: TaskPR; session /> -
+
{loading && !feedback && (
@@ -361,11 +372,14 @@ export function PRDetailContent({ taskPR, sessionId }: { taskPR: TaskPR; session addAsContext("review", msg)} + canReRequest={shouldShowReRequestReviewAction(feedback.pr.state, "DISMISSED")} + requestingReviewers={reviewRequest.requestingReviewers} + onReRequest={reviewRequest.reRequest} /> = { open: "bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400", diff --git a/apps/web/components/github/pr-reviews-section.test.tsx b/apps/web/components/github/pr-reviews-section.test.tsx new file mode 100644 index 0000000000..57f86fd37e --- /dev/null +++ b/apps/web/components/github/pr-reviews-section.test.tsx @@ -0,0 +1,126 @@ +import { afterEach, describe, expect, it, vi } from "vitest"; +import { cleanup, fireEvent, render, screen } from "@testing-library/react"; +import { TooltipProvider } from "@kandev/ui/tooltip"; +import { reconcileReviews, ReviewsSection } from "./pr-reviews-section"; +import type { PRReview, RequestedReviewer } from "@/lib/types/github"; + +function review(author: string, state: string, created_at = "2026-07-23T10:00:00Z"): PRReview { + return { id: 1, author, author_avatar: "", state, body: "", created_at }; +} + +function requested(login: string): RequestedReviewer { + return { login, type: "user" }; +} + +function renderReviews(ui: React.ReactElement) { + return render({ui}); +} + +afterEach(() => cleanup()); + +describe("reconcileReviews", () => { + it("keeps only latest review per author and enables its dismissed re-request action", () => { + const result = reconcileReviews( + [review("octocat", "APPROVED", "2026-07-22T10:00:00Z"), review("octocat", "DISMISSED")], + [], + ); + + expect(result.reviews).toEqual([review("octocat", "DISMISSED")]); + expect(result.pendingReviewers).toEqual([]); + }); + + it("makes current requests win over dismissed history case-insensitively", () => { + const result = reconcileReviews([review("OctoCat", "DISMISSED")], [requested("octocat")]); + + expect(result.reviews).toEqual([]); + expect(result.pendingReviewers).toEqual([requested("octocat")]); + }); + + it("deduplicates current requested reviewers case-insensitively", () => { + const result = reconcileReviews([], [requested("OctoCat"), requested("octocat")]); + + expect(result.pendingReviewers).toEqual([requested("OctoCat")]); + }); +}); + +describe("ReviewsSection re-request action", () => { + it("names dismissed reviewer and blocks repeated submission while busy", () => { + const onReRequest = vi.fn(); + renderReviews( + , + ); + + const action = screen.getByRole("button", { name: "Re-request review from octocat" }); + expect(action).toHaveProperty("disabled", true); + expect(action.className).toContain("min-h-11"); + fireEvent.click(action); + expect(onReRequest).not.toHaveBeenCalled(); + }); + + it("wraps a long reviewer row so the 44px action stays on-screen on phones", () => { + const longLogin = "reviewer-with-a-near-maximum-practical-github-login"; + renderReviews( + , + ); + + const action = screen.getByRole("button", { + name: `Re-request review from ${longLogin}`, + }); + const author = screen.getByRole("link", { name: longLogin }); + expect(action.className).toContain("min-h-11"); + expect(action.parentElement?.className).toContain("basis-full"); + expect(author.className).toContain("inline-block"); + expect(author.className).toContain("max-w-full"); + }); + + it("does not show action for a closed PR or a currently requested reviewer", () => { + const { rerender } = renderReviews( + , + ); + expect(screen.queryByRole("button", { name: "Re-request review from octocat" })).toBeNull(); + + rerender( + + + , + , + ); + expect(screen.queryByRole("button", { name: "Re-request review from octocat" })).toBeNull(); + expect(screen.getByText("OctoCat")).not.toBeNull(); + }); +}); diff --git a/apps/web/components/github/pr-reviews-section.tsx b/apps/web/components/github/pr-reviews-section.tsx index 0f1d9180c8..69f763ea5e 100644 --- a/apps/web/components/github/pr-reviews-section.tsx +++ b/apps/web/components/github/pr-reviews-section.tsx @@ -1,5 +1,6 @@ import { IconCheck, IconX, IconClock } from "@tabler/icons-react"; import { Badge } from "@kandev/ui/badge"; +import { Button } from "@kandev/ui/button"; import type { PRReview, RequestedReviewer } from "@/lib/types/github"; import { CollapsibleSection, FeedbackItemRow } from "./pr-shared"; @@ -59,15 +60,30 @@ function buildAllReviewsMessage(reviews: PRReview[], prUrl: string): string { return parts.join("\n"); } -function deduplicateReviews(reviews: PRReview[]): PRReview[] { +function normalizeLogin(login: string): string { + return login.trim().toLowerCase(); +} + +export function reconcileReviews(reviews: PRReview[], requestedReviewers: RequestedReviewer[]) { const latestByAuthor = new Map(); for (const review of reviews) { - const current = latestByAuthor.get(review.author); + const author = normalizeLogin(review.author); + const current = latestByAuthor.get(author); if (!current || new Date(review.created_at) > new Date(current.created_at)) { - latestByAuthor.set(review.author, review); + latestByAuthor.set(author, review); } } - return Array.from(latestByAuthor.values()); + const requestedByLogin = new Map(); + for (const reviewer of requestedReviewers) { + const login = normalizeLogin(reviewer.login); + if (!requestedByLogin.has(login)) requestedByLogin.set(login, reviewer); + } + return { + reviews: Array.from(latestByAuthor.entries()) + .filter(([author]) => !requestedByLogin.has(author)) + .map(([, review]) => review), + pendingReviewers: Array.from(requestedByLogin.values()), + }; } function formatPendingReviewer(reviewer: RequestedReviewer): string { @@ -114,29 +130,58 @@ function SubmittedReviewRow({ review, prUrl, onAddAsContext, + canReRequest, + isRequesting, + onReRequest, }: { review: PRReview; prUrl: string; onAddAsContext: (message: string) => void; + canReRequest: boolean; + isRequesting: boolean; + onReRequest?: (reviewer: string) => void; }) { const hasActionable = review.state === "CHANGES_REQUESTED" || !!review.body; return ( - } - onAddAsContext={ - hasActionable ? () => onAddAsContext(buildReviewMessage(review, prUrl)) : undefined - } - /> +
+ } + trailingAction={ + canReRequest && review.state === "DISMISSED" && onReRequest ? ( +
+ +
+ ) : undefined + } + onAddAsContext={ + hasActionable ? () => onAddAsContext(buildReviewMessage(review, prUrl)) : undefined + } + /> +
); } function PendingReviewRow({ reviewer }: { reviewer: RequestedReviewer }) { return ( -
+
{formatPendingReviewer(reviewer)} @@ -153,6 +198,9 @@ export function ReviewsSection({ reviewState, pendingReviewCount, onAddAsContext, + canReRequest = false, + requestingReviewers = [], + onReRequest, }: { reviews: PRReview[]; requestedReviewers: RequestedReviewer[]; @@ -160,16 +208,19 @@ export function ReviewsSection({ reviewState: string; pendingReviewCount: number; onAddAsContext: (message: string) => void; + canReRequest?: boolean; + requestingReviewers?: string[]; + onReRequest?: (reviewer: string) => void; }) { - const dedupedReviews = deduplicateReviews(reviews); - const reviewedAuthors = new Set( - dedupedReviews.filter((r) => r.state !== "PENDING").map((r) => r.author), + const { reviews: reconciledReviews, pendingReviewers } = reconcileReviews( + reviews, + requestedReviewers, ); - const pendingOnly = requestedReviewers.filter((r) => !reviewedAuthors.has(r.login)); + const requestingReviewerLogins = new Set(requestingReviewers.map(normalizeLogin)); const { pendingCount, summary, totalCount } = computeSectionSummary( - dedupedReviews, - pendingOnly, + reconciledReviews, + pendingReviewers, pendingReviewCount, ); const pendingText = pendingCount > 0 ? ` (${pendingCount} pending)` : ""; @@ -188,24 +239,27 @@ export function ReviewsSection({ defaultOpen subtitle={subtitle} onAddAll={ - dedupedReviews.length > 0 - ? () => onAddAsContext(buildAllReviewsMessage(dedupedReviews, prUrl)) + reconciledReviews.length > 0 + ? () => onAddAsContext(buildAllReviewsMessage(reconciledReviews, prUrl)) : undefined } addAllLabel="Add all reviews to chat context" > - {dedupedReviews.length === 0 && pendingCount === 0 && ( + {reconciledReviews.length === 0 && pendingCount === 0 && (

No reviews yet

)} - {dedupedReviews.map((review) => ( + {reconciledReviews.map((review) => ( ))} - {pendingOnly.map((reviewer) => ( + {pendingReviewers.map((reviewer) => ( ))} diff --git a/apps/web/components/github/pr-shared.tsx b/apps/web/components/github/pr-shared.tsx index 73bc3d14ae..819f12f970 100644 --- a/apps/web/components/github/pr-shared.tsx +++ b/apps/web/components/github/pr-shared.tsx @@ -68,7 +68,7 @@ export function AuthorLink({ author }: { author: string }) { href={`https://github.com/${author}`} target="_blank" rel="noopener noreferrer" - className="text-xs font-medium hover:underline cursor-pointer" + className="inline-block min-w-0 max-w-full truncate text-xs font-medium hover:underline cursor-pointer sm:max-w-none" > {author} @@ -217,6 +217,7 @@ export function FeedbackItemRow({ createdAt, metaBadge, onAddAsContext, + trailingAction, isReply, }: { author: string; @@ -225,12 +226,13 @@ export function FeedbackItemRow({ createdAt: string; metaBadge?: React.ReactNode; onAddAsContext?: () => void; + trailingAction?: React.ReactNode; isReply?: boolean; }) { return (
-
+
{metaBadge} @@ -238,6 +240,7 @@ export function FeedbackItemRow({ {formatTimeAgo(createdAt)} {onAddAsContext && } + {trailingAction}
{body && }
diff --git a/apps/web/components/github/use-pr-scoped-review-request.ts b/apps/web/components/github/use-pr-scoped-review-request.ts new file mode 100644 index 0000000000..a4f1b79403 --- /dev/null +++ b/apps/web/components/github/use-pr-scoped-review-request.ts @@ -0,0 +1,238 @@ +import { useCallback, useEffect, useSyncExternalStore } from "react"; +import { requestPRReviewers } from "@/lib/api/domains/github-review-api"; +import type { PRReview, RequestedReviewer, TaskPR } from "@/lib/types/github"; + +type Toast = (message: { + title?: string; + description: string; + variant: "error" | "success"; +}) => void; + +type ReviewBaseline = Pick; + +type RequestEntry = { + identity: string; + reviewer: string; + baseline: ReviewBaseline | null; + status: "requesting" | "optimistic"; + operationId: number; + expiresAt: number | null; +}; + +const ENTRY_TTL_MS = 5 * 60 * 1000; +const entries = new Map(); +const listeners = new Set<() => void>(); +let revision = 0; +let nextOperationId = 0; +let expiryTimer: ReturnType | undefined; + +function normalizeLogin(login: string) { + return login.trim().toLowerCase(); +} + +function prIdentity(taskPR: TaskPR) { + return `${taskPR.owner.toLowerCase()}:${taskPR.repo.toLowerCase()}:${taskPR.pr_number}`; +} + +function entryKey(identity: string, reviewer: string) { + return `${identity}:${normalizeLogin(reviewer)}`; +} + +function notify() { + revision += 1; + listeners.forEach((listener) => listener()); +} + +function pruneExpired(now = Date.now()) { + let removed = false; + for (const [key, entry] of entries) { + if (entry.status === "optimistic" && entry.expiresAt !== null && entry.expiresAt <= now) { + entries.delete(key); + removed = true; + } + } + return removed; +} + +function rescheduleExpiryTimer() { + if (expiryTimer !== undefined) { + clearTimeout(expiryTimer); + expiryTimer = undefined; + } + if (typeof window === "undefined") return; + const nextExpiry = Array.from(entries.values()).reduce((nearest, entry) => { + if (entry.status !== "optimistic" || entry.expiresAt === null) return nearest; + return nearest === null || entry.expiresAt < nearest ? entry.expiresAt : nearest; + }, null); + if (nextExpiry === null) return; + expiryTimer = setTimeout( + () => { + expiryTimer = undefined; + if (pruneExpired()) notify(); + rescheduleExpiryTimer(); + }, + Math.max(0, nextExpiry - Date.now()), + ); +} + +function latestReview(reviews: PRReview[], reviewer: string) { + const normalizedReviewer = normalizeLogin(reviewer); + return reviews + .filter((review) => normalizeLogin(review.author) === normalizedReviewer) + .reduce((latest, review) => { + if (!latest) return review; + const reviewTime = new Date(review.created_at).getTime(); + const latestTime = new Date(latest.created_at).getTime(); + return reviewTime > latestTime || (reviewTime === latestTime && review.id > latest.id) + ? review + : latest; + }, null); +} + +function supersedesBaseline(review: PRReview | null, baseline: ReviewBaseline | null) { + if (!review || !baseline || review.state === "DISMISSED") return false; + const reviewTime = new Date(review.created_at).getTime(); + const baselineTime = new Date(baseline.created_at).getTime(); + return reviewTime > baselineTime || (reviewTime === baselineTime && review.id > baseline.id); +} + +function reconcile(identity: string, requestedReviewers: RequestedReviewer[], reviews: PRReview[]) { + let removed = pruneExpired(); + const requestedLogins = new Set( + requestedReviewers.map((reviewer) => normalizeLogin(reviewer.login)), + ); + for (const [key, entry] of entries) { + if (entry.identity !== identity) continue; + if ( + requestedLogins.has(entry.reviewer) || + supersedesBaseline(latestReview(reviews, entry.reviewer), entry.baseline) + ) { + entries.delete(key); + removed = true; + } + } + rescheduleExpiryTimer(); + if (removed) notify(); +} + +function beginRequest(identity: string, reviewer: string, baseline: ReviewBaseline | null) { + const expired = pruneExpired(); + const key = entryKey(identity, reviewer); + if (entries.has(key)) { + if (expired) { + rescheduleExpiryTimer(); + notify(); + } + return null; + } + const operationId = ++nextOperationId; + entries.set(key, { + identity, + reviewer: normalizeLogin(reviewer), + baseline, + status: "requesting", + operationId, + expiresAt: null, + }); + rescheduleExpiryTimer(); + notify(); + return operationId; +} + +function finishRequest( + identity: string, + reviewer: string, + operationId: number, + succeeded: boolean, +) { + const key = entryKey(identity, reviewer); + const entry = entries.get(key); + if (!entry || entry.operationId !== operationId) return; + if (!succeeded) { + entries.delete(key); + } else { + entries.set(key, { ...entry, status: "optimistic", expiresAt: Date.now() + ENTRY_TTL_MS }); + } + rescheduleExpiryTimer(); + notify(); +} + +function getEntries(identity: string) { + return Array.from(entries.values()).filter((entry) => entry.identity === identity); +} + +function subscribe(listener: () => void) { + listeners.add(listener); + return () => listeners.delete(listener); +} + +export function clearPRReviewRequestRegistryForTests() { + entries.clear(); + nextOperationId = 0; + rescheduleExpiryTimer(); + notify(); +} + +export function usePRScopedReviewRequest( + taskPR: TaskPR, + requestedReviewers: RequestedReviewer[], + reviews: PRReview[], + refresh: () => void, + toast: Toast, +) { + const identity = prIdentity(taskPR); + useSyncExternalStore( + subscribe, + () => revision, + () => revision, + ); + + useEffect(() => { + reconcile(identity, requestedReviewers, reviews); + }, [identity, requestedReviewers, reviews]); + + const reRequest = useCallback( + async (reviewer: string) => { + const baseline = latestReview(reviews, reviewer); + const operationId = beginRequest(identity, reviewer, baseline); + if (operationId === null) return; + try { + await requestPRReviewers(taskPR.owner, taskPR.repo, taskPR.pr_number, [reviewer]); + } catch (error) { + finishRequest(identity, reviewer, operationId, false); + toast({ + title: "Failed to re-request review", + description: error instanceof Error ? error.message : "An error occurred", + variant: "error", + }); + return; + } + finishRequest(identity, reviewer, operationId, true); + toast({ description: `Review re-requested from ${reviewer}`, variant: "success" }); + try { + refresh(); + } catch { + // The request remains optimistic until the bounded registry expires or server data resolves it. + } + }, + [identity, refresh, reviews, taskPR.owner, taskPR.pr_number, taskPR.repo, toast], + ); + + const activeEntries = getEntries(identity); + const requestingReviewers = activeEntries + .filter((entry) => entry.status === "requesting") + .map((entry) => entry.reviewer); + const optimisticReviewers = activeEntries + .filter((entry) => entry.status === "optimistic") + .filter( + (entry) => + !requestedReviewers.some((reviewer) => normalizeLogin(reviewer.login) === entry.reviewer), + ) + .map((entry) => ({ login: entry.reviewer, type: "user" as const })); + + return { + reRequest, + requestingReviewers, + requestedReviewers: [...requestedReviewers, ...optimisticReviewers], + }; +} diff --git a/apps/web/components/task/mobile/session-mobile-layout.test.tsx b/apps/web/components/task/mobile/session-mobile-layout.test.tsx index 2e141ac6af..2b6068b725 100644 --- a/apps/web/components/task/mobile/session-mobile-layout.test.tsx +++ b/apps/web/components/task/mobile/session-mobile-layout.test.tsx @@ -1,5 +1,6 @@ import { describe, it, expect, vi, beforeEach } from "vitest"; -import { renderHook, act } from "@testing-library/react"; +import { render, renderHook, act, screen } from "@testing-library/react"; +import { useState } from "react"; import type { OpenFileTab } from "@/lib/types/backend"; vi.mock("@/components/toast-provider", () => ({ @@ -11,7 +12,33 @@ vi.mock("../file-browser-hooks", () => ({ fetchAndOpenFile: (...args: unknown[]) => fetchAndOpenFileMock(...args), })); -import { useMobilePanelHandlers } from "./session-mobile-layout"; +vi.mock("@/hooks/use-visual-viewport-offset", () => ({ + useVisualViewportOffset: () => ({ keyboardOpen: false, bottomOffset: 0 }), +})); + +vi.mock("@/components/review/review-pr-selector", () => ({ + ReviewPRSelector: ({ onSelectPR }: { onSelectPR: (pr: { id: string }) => void }) => ( + + ), +})); + +vi.mock("@/components/github/pr-detail-panel", async () => { + const React = await import("react"); + return { + PRDetailPanelComponent: ({ params }: { params: { prKey: string } }) => { + const [feedback] = React.useState(`feedback for ${params.prKey}`); + return ; + }, + }; +}); + +import { + MobilePanelArea, + resolveMobileReviewSource, + useMobilePanelHandlers, +} from "./session-mobile-layout"; const MOCK_FILE: OpenFileTab = { path: "src/foo.ts", @@ -183,3 +210,54 @@ describe("useMobilePanelHandlers request cancellation", () => { expect(firstOptions.signal.aborted).toBe(true); }); }); + +describe("resolveMobileReviewSource", () => { + it("prefers GitHub when a task has both review providers", () => { + expect(resolveMobileReviewSource(true, true)).toBe("github"); + }); + + it("makes GitHub Review available without a GitLab MR", () => { + expect(resolveMobileReviewSource(true, false)).toBe("github"); + }); + + it("keeps GitLab Review when no GitHub PR exists", () => { + expect(resolveMobileReviewSource(false, true)).toBe("gitlab"); + }); +}); + +describe("MobilePanelArea PR identity", () => { + it("remounts PR detail feedback before the selected PR changes", () => { + function MobileReviewHarness() { + const [prKey, setPrKey] = useState("pr-a"); + return ( + setPrKey("pr-b")} + /> + ); + } + + render(); + expect(screen.getByRole("button", { name: "feedback for pr-a" })).not.toBeNull(); + + act(() => screen.getByRole("button", { name: "Select PR B" }).click()); + + expect(screen.queryByRole("button", { name: "feedback for pr-a" })).toBeNull(); + expect(screen.getByRole("button", { name: "feedback for pr-b" })).not.toBeNull(); + }); +}); diff --git a/apps/web/components/task/mobile/session-mobile-layout.tsx b/apps/web/components/task/mobile/session-mobile-layout.tsx index 3e809484d4..4c53a9dff1 100644 --- a/apps/web/components/task/mobile/session-mobile-layout.tsx +++ b/apps/web/components/task/mobile/session-mobile-layout.tsx @@ -24,12 +24,27 @@ import { fetchAndOpenFile } from "../file-browser-hooks"; import type { MobileSessionPanel } from "@/lib/state/slices/ui/types"; import type { OpenFileTab } from "@/lib/types/backend"; import { useTaskMRs } from "@/hooks/domains/gitlab/use-task-mr"; +import { useReviewPRSelection } from "@/hooks/domains/github/use-review-pr-selection"; +import { PRDetailPanelComponent } from "@/components/github/pr-detail-panel"; +import { prTaskKey } from "@/components/github/pr-utils"; +import { ReviewPRSelector } from "@/components/review/review-pr-selector"; import { MRDetailPanelComponent, mrTaskKey, selectExplicitPanelMR, } from "@/components/gitlab/mr-detail-panel"; +export type MobileReviewSource = "github" | "gitlab" | null; + +export function resolveMobileReviewSource( + hasGitHubPR: boolean, + hasGitLabMR: boolean, +): MobileReviewSource { + if (hasGitHubPR) return "github"; + if (hasGitLabMR) return "gitlab"; + return null; +} + const TOP_NAV_HEIGHT = "3.5rem"; const BOTTOM_NAV_HEIGHT = "3.25rem"; @@ -105,10 +120,15 @@ type MobilePanelAreaProps = { handlePanelChangeAndClearSheet: (panel: MobileSessionPanel) => void; topNavHeight: string; bottomNavHeight: string; + reviewSource: MobileReviewSource; mrKey?: string; + prKey?: string; + reviewPRs: ReturnType["prs"]; + selectedReviewPR: ReturnType["selectedPR"]; + onSelectReviewPR: ReturnType["selectPR"]; }; -function MobilePanelArea({ +export function MobilePanelArea({ currentMobilePanel, activeTaskId, isPassthroughMode, @@ -121,7 +141,12 @@ function MobilePanelArea({ handlePanelChangeAndClearSheet, topNavHeight, bottomNavHeight, + reviewSource, mrKey, + prKey, + reviewPRs, + selectedReviewPR, + onSelectReviewPR, }: MobilePanelAreaProps) { const { keyboardOpen, bottomOffset } = useVisualViewportOffset(); // Keep terminal content's visible bottom glued to the keybar top. When the @@ -189,7 +214,15 @@ function MobilePanelArea({
)} - {currentMobilePanel === "review" && mrKey && ( + {currentMobilePanel === "review" && reviewSource === "github" && prKey && ( + + )} + {currentMobilePanel === "review" && reviewSource === "gitlab" && mrKey && (
@@ -198,6 +231,33 @@ function MobilePanelArea({ ); } +function MobileGitHubReviewPanel({ + prKey, + reviewPRs, + selectedReviewPR, + onSelectReviewPR, +}: Pick & { + prKey: string; +}) { + return ( +
+
+ +
+
+ +
+
+ ); +} + type MobileTopBarStickyProps = { activeTaskId: string | null; workspaceId: string | null; @@ -344,6 +404,7 @@ function useMobileMRSelection( effectiveSessionId: string | null, requestedPanel: MobileSessionPanel, changePanel: (panel: MobileSessionPanel) => void, + hasGitHubPR: boolean, ) { const mrs = useTaskMRs(activeTaskId); const reviewSourcesResolved = useAppStore((state) => { @@ -360,13 +421,16 @@ function useMobileMRSelection( useEffect(() => { const hasInvalidReviewPreference = - requestedPanel === "review" && (!reviewMRKey || (reviewSourcesResolved && !selectedMR)); + !hasGitHubPR && + requestedPanel === "review" && + (!reviewMRKey || (reviewSourcesResolved && !selectedMR)); if (effectiveSessionId && hasInvalidReviewPreference) { setMobileSessionReview(effectiveSessionId, null); } }, [ effectiveSessionId, requestedPanel, + hasGitHubPR, reviewMRKey, reviewSourcesResolved, selectedMR, @@ -449,14 +513,28 @@ export const SessionMobileLayout = memo(function SessionMobileLayout( } = useSessionLayoutState({ sessionId: props.sessionId }); const { selectedFile, handleOpenFileFromChat, handleOpenFile, handlePanelChangeAndClearSheet } = useMobilePanelHandlers({ effectiveSessionId, handlePanelChange }); + const mobilePR = useReviewPRSelection(activeTaskId); const mobileMR = useMobileMRSelection( activeTaskId, effectiveSessionId, currentMobilePanel, handlePanelChangeAndClearSheet, + mobilePR.prs.length > 0, ); + const reviewSource = resolveMobileReviewSource(mobilePR.prs.length > 0, mobileMR.mrs.length > 0); const effectiveMobilePanel = - currentMobilePanel === "review" && !mobileMR.selectedMR ? "chat" : currentMobilePanel; + currentMobilePanel === "review" && !reviewSource ? "chat" : currentMobilePanel; + + const handleMobilePanelChange = useCallback( + (panel: MobileSessionPanel) => { + if (panel === "review" && reviewSource === "github") { + handlePanelChangeAndClearSheet(panel); + return; + } + mobileMR.handlePanelChange(panel); + }, + [handlePanelChangeAndClearSheet, mobileMR.handlePanelChange, reviewSource], + ); return (
@@ -482,16 +560,21 @@ export const SessionMobileLayout = memo(function SessionMobileLayout( handlePanelChangeAndClearSheet={handlePanelChangeAndClearSheet} topNavHeight={TOP_NAV_HEIGHT} bottomNavHeight={BOTTOM_NAV_HEIGHT} + reviewSource={reviewSource} mrKey={mobileMR.selectedMR ? mrTaskKey(mobileMR.selectedMR) : undefined} + prKey={mobilePR.selectedPR ? prTaskKey(mobilePR.selectedPR) : undefined} + reviewPRs={mobilePR.prs} + selectedReviewPR={mobilePR.selectedPR} + onSelectReviewPR={mobilePR.selectPR} /> 0} + hasReview={reviewSource !== null} showStatus={statusDrawerEnabled} onOpenStatus={openStatusDrawer} /> diff --git a/apps/web/e2e/pages/session-page.ts b/apps/web/e2e/pages/session-page.ts index e15d1383a2..24ab72b7d6 100644 --- a/apps/web/e2e/pages/session-page.ts +++ b/apps/web/e2e/pages/session-page.ts @@ -582,6 +582,21 @@ export class SessionPage { return this.page.getByTestId("pr-approve-button"); } + /** Submitted review row scoped by its normalized GitHub author login. */ + prSubmittedReview(author: string): Locator { + return this.page.getByTestId(`pr-submitted-review-${author.trim().toLowerCase()}`); + } + + /** Pending reviewer row scoped by its normalized GitHub author login. */ + prPendingReviewer(author: string): Locator { + return this.page.getByTestId(`pr-pending-reviewer-${author.trim().toLowerCase()}`); + } + + /** Re-request action scoped by its normalized GitHub author login. */ + prReRequestReviewButton(author: string): Locator { + return this.page.getByTestId(`pr-rerequest-review-${author.trim().toLowerCase()}`); + } + // --- PR CI accessors: desktop hover popover + chip + mobile chip drawer --- /** The single-PR hover popover content (visible after hovering the topbar button). */ diff --git a/apps/web/e2e/tests/pr/mobile-pr-rerequest-review.spec.ts b/apps/web/e2e/tests/pr/mobile-pr-rerequest-review.spec.ts new file mode 100644 index 0000000000..1e4627fd6c --- /dev/null +++ b/apps/web/e2e/tests/pr/mobile-pr-rerequest-review.spec.ts @@ -0,0 +1,192 @@ +import { test, expect } from "../../fixtures/test-base"; +import { + assertLocatorWithinViewportX, + assertNoDocumentHorizontalOverflow, +} from "../../helpers/layout-assertions"; +import { SessionPage } from "../../pages/session-page"; + +const OWNER = "testorg"; +const REPO = "testrepo"; +const PR_NUMBER = 418; +const REVIEWER = "reviewer-with-a-near-maximum-practical-github-login"; +const SWITCH_PR_NUMBER = 420; +const SWITCH_SECOND_PR_NUMBER = 421; + +test.describe("mobile PR re-request review", () => { + test("uses bottom-nav Review to re-request a dismissed review without overflow", async ({ + testPage, + apiClient, + seedData, + }) => { + test.setTimeout(120_000); + await testPage.setViewportSize({ width: 320, height: 720 }); + await apiClient.mockGitHubReset(); + await apiClient.mockGitHubSetUser("test-user"); + const task = await apiClient.createTaskWithAgent( + seedData.workspaceId, + "Mobile re-request dismissed review", + seedData.agentProfileId, + { + description: "/e2e:simple-message", + workflow_id: seedData.workflowId, + workflow_step_id: seedData.startStepId, + repository_ids: [seedData.repositoryId], + }, + ); + await apiClient.mockGitHubAssociateTaskPR({ + task_id: task.id, + owner: OWNER, + repo: REPO, + pr_number: PR_NUMBER, + pr_url: `https://github.com/${OWNER}/${REPO}/pull/${PR_NUMBER}`, + pr_title: "Mobile re-request dismissed review", + head_branch: "feat/mobile-rerequest-review", + base_branch: "main", + author_login: "another-user", + state: "open", + }); + await apiClient.mockGitHubSeedPRFeedback({ + owner: OWNER, + repo: REPO, + pr_number: PR_NUMBER, + reviews: [ + { + id: 1, + author: REVIEWER, + state: "DISMISSED", + created_at: "2026-07-23T10:00:00Z", + }, + ], + }); + + await testPage.goto(`/t/${task.id}`); + const session = new SessionPage(testPage); + await session.waitForLoad(); + // The task-PR association can arrive before this route's WS subscription; + // reload to hydrate the linked PR from the authoritative boot payload. + await testPage.reload(); + await session.waitForLoad(); + await expect(session.prTopbarButton()).toHaveCount(0); + + await testPage.getByRole("button", { name: "Review", exact: true }).tap(); + const panel = testPage.getByTestId("mobile-pr-review-panel"); + await expect(panel).toBeVisible({ timeout: 15_000 }); + await assertLocatorWithinViewportX(panel, "mobile PR review panel"); + + const action = session.prReRequestReviewButton(REVIEWER); + await expect(action).toBeVisible(); + const box = await action.boundingBox(); + expect(box, "re-request review action has no bounding box").not.toBeNull(); + if (box) { + expect(box.width, "re-request review action width").toBeGreaterThanOrEqual(44); + expect(box.height, "re-request review action height").toBeGreaterThanOrEqual(44); + } + await assertLocatorWithinViewportX(action, "mobile re-request review action"); + const reRequestResponse = testPage.waitForResponse( + (response) => + response.request().method() === "POST" && + response + .url() + .includes(`/api/v1/github/prs/${OWNER}/${REPO}/${PR_NUMBER}/requested-reviewers`), + ); + await action.tap(); + await reRequestResponse; + + await expect(session.prPendingReviewer(REVIEWER)).toContainText("Pending review"); + await expect(session.prSubmittedReview(REVIEWER)).toHaveCount(0); + await expect(session.prReRequestReviewButton(REVIEWER)).toHaveCount(0); + await assertNoDocumentHorizontalOverflow(testPage, "mobile PR re-request review"); + }); + + test("drops PR A feedback before delayed PR B feedback can receive PR A's action", async ({ + testPage, + apiClient, + seedData, + }) => { + test.setTimeout(120_000); + await apiClient.mockGitHubReset(); + await apiClient.mockGitHubSetUser("test-user"); + const task = await apiClient.createTaskWithAgent( + seedData.workspaceId, + "Mobile PR identity switch", + seedData.agentProfileId, + { + description: "/e2e:simple-message", + workflow_id: seedData.workflowId, + workflow_step_id: seedData.startStepId, + repository_ids: [seedData.repositoryId], + }, + ); + for (const prNumber of [SWITCH_PR_NUMBER, SWITCH_SECOND_PR_NUMBER]) { + await apiClient.mockGitHubAssociateTaskPR({ + task_id: task.id, + owner: OWNER, + repo: REPO, + pr_number: prNumber, + pr_url: `https://github.com/${OWNER}/${REPO}/pull/${prNumber}`, + pr_title: `PR ${prNumber}`, + head_branch: `feat/pr-${prNumber}`, + base_branch: "main", + author_login: "another-user", + state: "open", + }); + } + await apiClient.mockGitHubSeedPRFeedback({ + owner: OWNER, + repo: REPO, + pr_number: SWITCH_PR_NUMBER, + reviews: [ + { id: 1, author: REVIEWER, state: "DISMISSED", created_at: "2026-07-23T10:00:00Z" }, + ], + }); + await apiClient.mockGitHubSeedPRFeedback({ + owner: OWNER, + repo: REPO, + pr_number: SWITCH_SECOND_PR_NUMBER, + reviews: [], + }); + + let releaseSecondFeedback!: () => void; + const secondFeedbackHeld = new Promise((resolve) => { + releaseSecondFeedback = resolve; + }); + let observeSecondFeedback!: () => void; + const secondFeedbackRequested = new Promise((resolve) => { + observeSecondFeedback = resolve; + }); + await testPage.route( + `**/api/v1/github/prs/${OWNER}/${REPO}/${SWITCH_SECOND_PR_NUMBER}`, + async (route) => { + const response = await route.fetch(); + observeSecondFeedback(); + await secondFeedbackHeld; + await route.fulfill({ response }); + }, + ); + const mutationUrls: string[] = []; + testPage.on("request", (request) => { + if (request.method() === "POST" && request.url().includes("/requested-reviewers")) { + mutationUrls.push(request.url()); + } + }); + + await testPage.goto(`/t/${task.id}`); + const session = new SessionPage(testPage); + await session.waitForLoad(); + await testPage.getByRole("button", { name: "Review", exact: true }).tap(); + const action = session.prReRequestReviewButton(REVIEWER); + await expect(action).toBeVisible({ timeout: 15_000 }); + + await testPage.getByTestId("mobile-review-pr-selector-trigger").tap(); + await testPage + .getByTestId(`mobile-review-pr-selector-item-${OWNER}-${REPO}-${SWITCH_SECOND_PR_NUMBER}`) + .tap(); + await secondFeedbackRequested; + + await expect(action).toHaveCount(0); + await expect(session.prReRequestReviewButton(REVIEWER)).toHaveCount(0); + expect(mutationUrls).toEqual([]); + + releaseSecondFeedback(); + }); +}); diff --git a/apps/web/e2e/tests/pr/pr-rerequest-review.spec.ts b/apps/web/e2e/tests/pr/pr-rerequest-review.spec.ts new file mode 100644 index 0000000000..f961d2fb18 --- /dev/null +++ b/apps/web/e2e/tests/pr/pr-rerequest-review.spec.ts @@ -0,0 +1,73 @@ +import { test, expect } from "../../fixtures/test-base"; +import { SessionPage } from "../../pages/session-page"; + +const OWNER = "testorg"; +const REPO = "testrepo"; +const PR_NUMBER = 417; +const REVIEWER = "OctoCat"; + +test.describe("PR re-request review", () => { + test("re-requests a dismissed review from the PR detail panel", async ({ + testPage, + apiClient, + seedData, + }) => { + test.setTimeout(120_000); + await apiClient.mockGitHubReset(); + await apiClient.mockGitHubSetUser("test-user"); + const task = await apiClient.createTaskWithAgent( + seedData.workspaceId, + "Desktop re-request dismissed review", + seedData.agentProfileId, + { + description: "/e2e:simple-message", + workflow_id: seedData.workflowId, + workflow_step_id: seedData.startStepId, + repository_ids: [seedData.repositoryId], + }, + ); + await apiClient.mockGitHubAssociateTaskPR({ + task_id: task.id, + owner: OWNER, + repo: REPO, + pr_number: PR_NUMBER, + pr_url: `https://github.com/${OWNER}/${REPO}/pull/${PR_NUMBER}`, + pr_title: "Re-request dismissed review", + head_branch: "feat/rerequest-review", + base_branch: "main", + author_login: "another-user", + state: "open", + }); + await apiClient.mockGitHubSeedPRFeedback({ + owner: OWNER, + repo: REPO, + pr_number: PR_NUMBER, + reviews: [ + { + id: 1, + author: REVIEWER, + state: "DISMISSED", + created_at: "2026-07-23T10:00:00Z", + }, + ], + }); + + await testPage.goto(`/t/${task.id}`); + const session = new SessionPage(testPage); + await session.waitForLoad(); + await expect(session.prTopbarButton()).toBeVisible({ timeout: 15_000 }); + await session.prTopbarButton().click(); + await expect(session.prDetailPanel()).toBeVisible(); + + const submitted = session.prSubmittedReview(REVIEWER); + await expect(submitted).toContainText("Dismissed"); + await session.prReRequestReviewButton(REVIEWER).click(); + + await expect( + testPage.getByText(`Review re-requested from ${REVIEWER}`, { exact: true }), + ).toBeVisible(); + await expect(session.prPendingReviewer(REVIEWER)).toContainText("Pending review"); + await expect(session.prSubmittedReview(REVIEWER)).toHaveCount(0); + await expect(session.prReRequestReviewButton(REVIEWER)).toHaveCount(0); + }); +}); diff --git a/apps/web/lib/api/domains/github-api.ts b/apps/web/lib/api/domains/github-api.ts index 8989e28c82..f56b054c84 100644 --- a/apps/web/lib/api/domains/github-api.ts +++ b/apps/web/lib/api/domains/github-api.ts @@ -190,25 +190,6 @@ export async function getPRStatusesBatch(refs: PRStatusRef[], options?: ApiReque }); } -// Submit PR review -export async function submitPRReview( - owner: string, - repo: string, - number: number, - event: "APPROVE" | "COMMENT" | "REQUEST_CHANGES", - body?: string, -) { - return fetchJson<{ submitted: boolean }>( - `/api/v1/github/prs/${owner}/${repo}/${number}/reviews`, - { - init: { - method: "POST", - body: JSON.stringify({ event, body: body ?? "" }), - }, - }, - ); -} - // Merge a pull request. Omit mergeMethod to let the backend pick the first // method the repo allows (avoids GitHub's "default to merge commit" 405 on // squash-only / rebase-only repos). diff --git a/apps/web/lib/api/domains/github-review-api.test.ts b/apps/web/lib/api/domains/github-review-api.test.ts new file mode 100644 index 0000000000..8ae4ba04ca --- /dev/null +++ b/apps/web/lib/api/domains/github-review-api.test.ts @@ -0,0 +1,57 @@ +import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; +import { requestPRReviewers, submitPRReview } from "./github-review-api"; + +vi.mock("@/lib/config", () => ({ + getBackendConfig: () => ({ apiBaseUrl: "http://api.test" }), +})); + +type FetchInput = Parameters[0]; +type FetchInit = Parameters[1]; + +const fetchSpy = vi.fn<(...args: [FetchInput, FetchInit?]) => Promise>(); + +beforeEach(() => { + fetchSpy.mockReset(); + vi.stubGlobal("fetch", fetchSpy); +}); + +afterEach(() => { + vi.unstubAllGlobals(); +}); + +function jsonResponse(body: unknown): Response { + return new Response(JSON.stringify(body), { + status: 200, + headers: { "Content-Type": "application/json" }, + }); +} + +describe("PR review writes", () => { + it("posts review events and an empty default body to the reviews endpoint", async () => { + fetchSpy.mockResolvedValueOnce(jsonResponse({ submitted: true })); + + await expect(submitPRReview("acme", "site", 42, "APPROVE")).resolves.toEqual({ + submitted: true, + }); + + const call = fetchSpy.mock.calls.at(-1); + expect(String(call?.[0])).toBe("http://api.test/api/v1/github/prs/acme/site/42/reviews"); + expect(call?.[1]?.method).toBe("POST"); + expect(JSON.parse(String(call?.[1]?.body))).toEqual({ event: "APPROVE", body: "" }); + }); + + it("posts reviewer logins to the pull request review-request endpoint", async () => { + fetchSpy.mockResolvedValueOnce(jsonResponse({ requested: true })); + + await expect(requestPRReviewers("acme", "site", 42, ["octocat"])).resolves.toEqual({ + requested: true, + }); + + const call = fetchSpy.mock.calls.at(-1); + expect(String(call?.[0])).toBe( + "http://api.test/api/v1/github/prs/acme/site/42/requested-reviewers", + ); + expect(call?.[1]?.method).toBe("POST"); + expect(JSON.parse(String(call?.[1]?.body))).toEqual({ reviewers: ["octocat"] }); + }); +}); diff --git a/apps/web/lib/api/domains/github-review-api.ts b/apps/web/lib/api/domains/github-review-api.ts new file mode 100644 index 0000000000..bca5a91738 --- /dev/null +++ b/apps/web/lib/api/domains/github-review-api.ts @@ -0,0 +1,36 @@ +import { fetchJson } from "../client"; + +export async function submitPRReview( + owner: string, + repo: string, + number: number, + event: "APPROVE" | "COMMENT" | "REQUEST_CHANGES", + body?: string, +) { + return fetchJson<{ submitted: boolean }>( + `/api/v1/github/prs/${owner}/${repo}/${number}/reviews`, + { + init: { + method: "POST", + body: JSON.stringify({ event, body: body ?? "" }), + }, + }, + ); +} + +export async function requestPRReviewers( + owner: string, + repo: string, + number: number, + reviewers: string[], +) { + return fetchJson<{ requested: boolean }>( + `/api/v1/github/prs/${owner}/${repo}/${number}/requested-reviewers`, + { + init: { + method: "POST", + body: JSON.stringify({ reviewers }), + }, + }, + ); +} diff --git a/docs/plans/github-pr-review-rerequest/plan.md b/docs/plans/github-pr-review-rerequest/plan.md new file mode 100644 index 0000000000..c745043eab --- /dev/null +++ b/docs/plans/github-pr-review-rerequest/plan.md @@ -0,0 +1,140 @@ +--- +spec: docs/specs/ui/github-pr-review-actions.md +created: 2026-07-23 +status: completed +--- + +# Implementation Plan: GitHub PR Review Re-request + +## Overview + +Add the missing GitHub review-request write contract, expose it beside a +dismissed review, and reuse that PR detail surface on phones. Backend and core +frontend work can proceed in parallel because the route and payload are fixed +by the spec; mobile composition and E2E follow after the shared action works. + +## Backend + +### GitHub client contract and implementations + +- Add `RequestReviewers(ctx, owner, repo, number, reviewers)` to + `apps/backend/internal/github/client.go`. +- Implement GitHub REST + `POST /repos/{owner}/{repo}/pulls/{number}/requested_reviewers` in + `gh_client.go` and `pat_client.go`. +- Keep `noop_client.go` fail-closed. +- Make `mock_client.go` record the request and update the seeded PR's + `RequestedReviewers`, so integration and browser tests observe the same + transition as GitHub. + +### Service and HTTP route + +- Add a service method in `service_pr.go` that delegates the write and deletes + the affected `prFeedbackCache` and `prStatusCache` key after success. +- Register + `POST /api/v1/github/prs/:owner/:repo/:number/requested-reviewers` in + `controller.go`. +- Validate the PR number and a non-empty list of non-blank reviewer logins. + Return the established GitHub/configuration error response and + `{"requested": true}` on success. + +## Frontend + +### API and dismissed-review action + +- Add `requestPRReviewers` to + `apps/web/lib/api/domains/github-api.ts`. +- In `pr-detail-panel.tsx`, own mutation state, success/error toast, and + feedback refresh using the existing approve-action pattern. +- In `pr-reviews-section.tsx`, reconcile review history with explicit current + requests case-insensitively. Only the latest `DISMISSED` review on an open PR + gets a re-request action, and a requested reviewer renders once as pending. +- Add a small accessible trailing action to `pr-shared.tsx` only if needed by + the existing row layout. Use a compact direct sync action on wider screens + and a minimum 44px touch target on phone/coarse-pointer layouts. + +### Mobile design contract + +- **Desktop outcome:** request the dismissed reviewer from the existing PR + detail review row. +- **Phone entry:** task bottom navigation **Review**. +- **Exemplar:** GitLab's full-height mobile review in + `apps/web/components/task/mobile/session-mobile-layout.tsx`, plus + `ReviewPRSelector` for multi-PR selection. +- **Hierarchy/surface:** optional PR selector, then one full-height PR detail + surface; the dismissed-review action remains inside its review row. +- **Scroll/geometry:** mobile layout owns `100dvh`; PR content keeps one + internal vertical scroll owner; existing bottom-nav safe-area padding stays + authoritative; no document horizontal overflow. +- **Shared logic:** the same feedback hook, request handler, PR selection, and + reviews component serve every viewport. Only mobile composition differs. +- **Primary action:** visible re-request control with an accessible reviewer + name and at least a 44px active touch dimension. + +## Tests + +- Backend transport tests assert gh/PAT method, endpoint, and reviewer JSON. +- Backend mock/service/controller tests assert mutation, validation, error + behavior, and per-PR cache eviction. +- Frontend API tests assert method, path, and body. +- Review reconciliation tests cover dismissed-only eligibility, + case-insensitive current requests, duplicate suppression, and closed PRs. +- Mobile layout tests cover GitHub PR Review availability and fallback to the + existing GitLab surface when no GitHub PR exists. + +## E2E Tests + +- Desktop: seed an open PR with a dismissed review, use the PR detail row + action, and assert the reviewer becomes pending with no duplicate action. +- Mobile: enter Review from bottom navigation, perform the same request, and + assert pending state, 44px action geometry, viewport containment, and no + document horizontal overflow. + +## Implementation Waves + +Wave 1 (parallel): + +- [x] [Task 01: Backend review-request contract](task-01-backend-review-request.md) — done +- [x] [Task 02: Dismissed-review action](task-02-frontend-dismissed-review-action.md) — done + +Wave 2: + +- [x] [Task 03: Mobile GitHub PR review surface](task-03-mobile-github-pr-review.md) — done + +Wave 3: + +- [x] [Task 04: Desktop and mobile E2E](task-04-e2e-rerequest-review.md) — done +- [x] [Task 05: Public review-flow docs](task-05-public-review-flow-docs.md) — done + +Review remediation (parallel): + +- [x] [Task 06: PR-scoped optimistic request state](task-06-pr-scoped-request-state.md) — done +- [x] [Task 07: Mobile PR identity and narrow-row safety](task-07-mobile-pr-identity-layout.md) — done +- [x] [Task 08: Reviewer input hardening](task-08-reviewer-input-hardening.md) — done +- [x] [Task 09: Key-scoped PR cache invalidation](task-09-key-scoped-cache-invalidation.md) — done +- [x] [Task 10: Persistent review-request lifecycle](task-10-persistent-request-lifecycle.md) — done +- [x] [Task 11: Reclaim key invalidation metadata](task-11-reclaim-cache-epochs.md) — done + +## Verification + +After targeted task checks, run formatting before the full pipeline: + +```bash +make fmt +make typecheck test lint +``` + +Then run focused production-build browser coverage: + +```bash +cd apps/web +pnpm e2e:run tests/pr/pr-rerequest-review.spec.ts tests/pr/mobile-pr-rerequest-review.spec.ts +``` + +## Risks + +- GitHub keeps the old dismissed review in review history after a new request; + explicit `requested_reviewers` must win during rendering. +- Feedback/status caches can otherwise make a successful mutation look stale. +- Adding GitHub to the phone Review destination must not remove the existing + GitLab fallback for tasks without a GitHub PR. diff --git a/docs/plans/github-pr-review-rerequest/task-01-backend-review-request.md b/docs/plans/github-pr-review-rerequest/task-01-backend-review-request.md new file mode 100644 index 0000000000..02c0156419 --- /dev/null +++ b/docs/plans/github-pr-review-rerequest/task-01-backend-review-request.md @@ -0,0 +1,60 @@ +--- +id: "01-backend-review-request" +title: "Backend review-request contract" +status: done +wave: 1 +depends_on: [] +plan: "plan.md" +spec: "../../specs/ui/github-pr-review-actions.md" +--- + +# Task 01: Backend review-request contract + +## Acceptance + +- Every GitHub client implementation satisfies a typed reviewer-request + method; gh/PAT send the official endpoint and JSON reviewer list. +- The Kandev route validates input, delegates one request, and returns + `{"requested": true}` on success. +- Success evicts only the affected PR feedback/status cache key, and the mock + makes the requested reviewer visible on the next feedback fetch. + +## Verification + +```bash +cd apps/backend +go test ./internal/github -run 'RequestReview' +go test ./internal/github +``` + +## Files likely touched + +- `apps/backend/internal/github/client.go` +- `apps/backend/internal/github/gh_client.go` +- `apps/backend/internal/github/gh_client_test.go` +- `apps/backend/internal/github/pat_client.go` +- `apps/backend/internal/github/pat_client_test.go` +- `apps/backend/internal/github/mock_client.go` +- `apps/backend/internal/github/mock_client_test.go` +- `apps/backend/internal/github/noop_client.go` +- `apps/backend/internal/github/noop_client_test.go` +- `apps/backend/internal/github/service_pr.go` +- `apps/backend/internal/github/service_request_review_test.go` +- `apps/backend/internal/github/controller.go` +- `apps/backend/internal/github/controller_test.go` + +## Dependencies + +None. + +## Inputs + +- Spec API surface, permissions, failure modes, and first five scenarios. +- Existing `SubmitReview` client/service/controller path. +- Official GitHub request-reviewers endpoint. + +## Output contract + +Report summary, files changed, RED/GREEN/REFACTOR evidence, commands/results, +blockers, risks, and set only this task file's status to `done`. Do not edit +`plan.md`. diff --git a/docs/plans/github-pr-review-rerequest/task-02-frontend-dismissed-review-action.md b/docs/plans/github-pr-review-rerequest/task-02-frontend-dismissed-review-action.md new file mode 100644 index 0000000000..05f7277110 --- /dev/null +++ b/docs/plans/github-pr-review-rerequest/task-02-frontend-dismissed-review-action.md @@ -0,0 +1,58 @@ +--- +id: "02-frontend-dismissed-review-action" +title: "Dismissed-review action" +status: done +wave: 1 +depends_on: [] +plan: "plan.md" +spec: "../../specs/ui/github-pr-review-actions.md" +--- + +# Task 02: Dismissed-review action + +## Acceptance + +- An open PR's latest dismissed review exposes one reviewer-named re-request + action; other states and non-open PRs do not. +- Current requested-reviewer state wins over dismissed history + case-insensitively, renders once as pending, and blocks duplicate requests. +- The action sends the fixed API payload, exposes busy state, refreshes after + success, and shows success/error toasts with retry preserved on failure. + +## Verification + +```bash +cd apps +pnpm --filter @kandev/web test -- --run \ + lib/api/domains/github-api.test.ts \ + components/github/pr-reviews-section.test.tsx \ + components/github/pr-detail-panel.test.ts +``` + +## Files likely touched + +- `apps/web/lib/api/domains/github-api.ts` +- `apps/web/lib/api/domains/github-api.test.ts` +- `apps/web/components/github/pr-detail-panel.tsx` +- `apps/web/components/github/pr-detail-panel.test.ts` +- `apps/web/components/github/pr-reviews-section.tsx` +- `apps/web/components/github/pr-reviews-section.test.tsx` +- `apps/web/components/github/pr-shared.tsx` + +## Dependencies + +None. The route/payload contract is fixed by the spec; browser integration +waits for Task 01. + +## Inputs + +- Spec `What`, failure modes, and desktop scenarios. +- `ApproveButton` mutation/toast/refresh pattern. +- Mobile-parity touch-target rules, though phone composition belongs to Task + 03. + +## Output contract + +Report summary, files changed, RED/GREEN/REFACTOR evidence, commands/results, +blockers, risks, and set only this task file's status to `done`. Do not edit +`plan.md`. diff --git a/docs/plans/github-pr-review-rerequest/task-03-mobile-github-pr-review.md b/docs/plans/github-pr-review-rerequest/task-03-mobile-github-pr-review.md new file mode 100644 index 0000000000..5f4e489a64 --- /dev/null +++ b/docs/plans/github-pr-review-rerequest/task-03-mobile-github-pr-review.md @@ -0,0 +1,55 @@ +--- +id: "03-mobile-github-pr-review" +title: "Mobile GitHub PR review surface" +status: done +wave: 2 +depends_on: ["02-frontend-dismissed-review-action"] +plan: "plan.md" +spec: "../../specs/ui/github-pr-review-actions.md" +--- + +# Task 03: Mobile GitHub PR review surface + +## Acceptance + +- A phone task with a linked GitHub PR shows **Review** in bottom navigation + and opens the shared GitHub PR detail content. +- Multi-PR tasks use shared PR selection; tasks with no GitHub PR retain the + existing GitLab MR Review behavior. +- Surface keeps one scroll owner, safe-area/bottom-nav clearance, touch-sized + actions, and no viewport-wide horizontal overflow. + +## Verification + +```bash +cd apps +pnpm --filter @kandev/web test -- --run \ + components/task/mobile/session-mobile-layout.test.tsx \ + hooks/domains/github/use-review-pr-selection.test.ts +``` + +## Files likely touched + +- `apps/web/components/task/mobile/session-mobile-layout.tsx` +- `apps/web/components/task/mobile/session-mobile-layout.test.tsx` +- `apps/web/components/review/review-pr-selector.tsx` (only if composition + needs an existing selector prop/test hook) +- `apps/web/hooks/domains/github/use-review-pr-selection.ts` +- `apps/web/hooks/domains/github/use-review-pr-selection.test.ts` + +## Dependencies + +Task 02. + +## Inputs + +- Plan mobile design contract. +- Existing GitLab mobile Review implementation in + `session-mobile-layout.tsx`. +- Existing shared `ReviewPRSelector` and `useReviewPRSelection`. + +## Output contract + +Report summary, files changed, RED/GREEN/REFACTOR evidence, commands/results, +blockers, risks, and set only this task file's status to `done`. Do not edit +`plan.md`. diff --git a/docs/plans/github-pr-review-rerequest/task-04-e2e-rerequest-review.md b/docs/plans/github-pr-review-rerequest/task-04-e2e-rerequest-review.md new file mode 100644 index 0000000000..8d92d03283 --- /dev/null +++ b/docs/plans/github-pr-review-rerequest/task-04-e2e-rerequest-review.md @@ -0,0 +1,55 @@ +--- +id: "04-e2e-rerequest-review" +title: "Desktop and mobile E2E" +status: done +wave: 3 +depends_on: + - "01-backend-review-request" + - "02-frontend-dismissed-review-action" + - "03-mobile-github-pr-review" +plan: "plan.md" +spec: "../../specs/ui/github-pr-review-actions.md" +--- + +# Task 04: Desktop and mobile E2E + +## Acceptance + +- Desktop E2E proves dismissed review to requested/pending transition through + the user-visible PR panel. +- Mobile E2E enters through **Review**, proves the same transition, and checks + touch target, viewport containment, and no document horizontal overflow. +- Tests seed via mock APIs, act only through the UI, and use stable + reviewer-specific selectors. + +## Verification + +```bash +cd apps/web +pnpm e2e:run tests/pr/pr-rerequest-review.spec.ts tests/pr/mobile-pr-rerequest-review.spec.ts +``` + +## Files likely touched + +- `apps/web/e2e/tests/pr/pr-rerequest-review.spec.ts` +- `apps/web/e2e/tests/pr/mobile-pr-rerequest-review.spec.ts` +- `apps/web/e2e/pages/session-page.ts` +- `apps/web/e2e/helpers/api-client.ts` (only if existing seed helpers cannot + express the scenario) + +## Dependencies + +Tasks 01, 02, and 03. + +## Inputs + +- All spec scenarios. +- `apps/web/e2e/tests/pr/pr-approve-button.spec.ts`. +- `apps/web/e2e/tests/gitlab/mobile-gitlab-parity.spec.ts`. +- Mobile parity and E2E skills. + +## Output contract + +Report summary, files changed, RED/GREEN/REFACTOR evidence, commands/results, +failure-artifact paths when relevant, blockers, risks, and set only this task +file's status to `done`. Do not edit `plan.md`. diff --git a/docs/plans/github-pr-review-rerequest/task-05-public-review-flow-docs.md b/docs/plans/github-pr-review-rerequest/task-05-public-review-flow-docs.md new file mode 100644 index 0000000000..9f123b224c --- /dev/null +++ b/docs/plans/github-pr-review-rerequest/task-05-public-review-flow-docs.md @@ -0,0 +1,49 @@ +--- +id: "05-public-review-flow-docs" +title: "Public review-flow docs" +status: done +wave: 3 +depends_on: + - "01-backend-review-request" + - "02-frontend-dismissed-review-action" + - "03-mobile-github-pr-review" +plan: "plan.md" +spec: "../../specs/ui/github-pr-review-actions.md" +--- + +# Task 05: Public review-flow docs + +## Acceptance + +- Public session/review docs explain that an open GitHub PR can re-request a + dismissed reviewer from the linked PR detail panel. +- Docs name GitHub permission as authoritative and mention the phone **Review** + destination without documenting internal implementation details. +- Public-doc validators pass. + +## Verification + +```bash +node --test scripts/validate-public-docs.test.mjs +node scripts/validate-public-docs.mjs +``` + +## Files likely touched + +- `docs/public/sessions-and-review.md` + +## Dependencies + +Tasks 01, 02, and 03. + +## Inputs + +- Shipped behavior and the feature spec. +- Existing GitHub in-app PR review paragraph under + `docs/public/sessions-and-review.md`. +- Docs-maintainer skill. + +## Output contract + +Report summary, files changed, commands/results, blockers, risks, and set only +this task file's status to `done`. Do not edit `plan.md`. diff --git a/docs/plans/github-pr-review-rerequest/task-06-pr-scoped-request-state.md b/docs/plans/github-pr-review-rerequest/task-06-pr-scoped-request-state.md new file mode 100644 index 0000000000..a75339d70b --- /dev/null +++ b/docs/plans/github-pr-review-rerequest/task-06-pr-scoped-request-state.md @@ -0,0 +1,36 @@ +--- +id: "06-pr-scoped-request-state" +title: "PR-scoped optimistic request state" +status: done +wave: 4 +depends_on: + - "02-frontend-dismissed-review-action" +plan: "plan.md" +spec: "../../specs/ui/github-pr-review-actions.md" +--- + +# Task 06: PR-scoped optimistic request state + +## Acceptance + +- A successful re-request immediately reconciles the reviewer to pending and + cannot be replayed while refreshed feedback is delayed or fails. +- Failed writes clear only the in-flight state and remain retryable. +- Mutation state cannot survive a PR identity change. +- Extracted code keeps frontend file and function complexity within enforced + limits. +- Deferred-success, refresh-failure, write-failure, and identity-reset behavior + have focused tests. + +## Ownership + +- `apps/web/components/github/pr-detail-panel.tsx` +- `apps/web/components/github/pr-detail-panel.test.ts` +- A new focused hook/helper and test beside the GitHub PR components, if useful. + +Do not edit the review-row or mobile-layout files owned by Task 07. + +## Output contract + +Use TDD. Report RED/GREEN evidence, exact checks, files changed, residual risks, +and set only this task file's status to `done`. diff --git a/docs/plans/github-pr-review-rerequest/task-07-mobile-pr-identity-layout.md b/docs/plans/github-pr-review-rerequest/task-07-mobile-pr-identity-layout.md new file mode 100644 index 0000000000..d42d6fdd96 --- /dev/null +++ b/docs/plans/github-pr-review-rerequest/task-07-mobile-pr-identity-layout.md @@ -0,0 +1,40 @@ +--- +id: "07-mobile-pr-identity-layout" +title: "Mobile PR identity and narrow-row safety" +status: done +wave: 4 +depends_on: + - "03-mobile-github-pr-review" + - "04-e2e-rerequest-review" +plan: "plan.md" +spec: "../../specs/ui/github-pr-review-actions.md" +--- + +# Task 07: Mobile PR identity and narrow-row safety + +## Acceptance + +- Switching the phone PR selector remounts or synchronously resets the detail + surface before the next PR can receive actions. +- A delayed-fetch multi-PR test proves PR A's dismissed action cannot target PR + B after selection changes. +- A maximum-practical-length reviewer login at a 320px phone viewport keeps the + complete action inside the viewport with no document overflow. +- Desktop row density and accessible reviewer naming remain intact. + +## Ownership + +- `apps/web/components/task/mobile/session-mobile-layout.tsx` +- `apps/web/components/task/mobile/session-mobile-layout.test.tsx` +- `apps/web/components/github/pr-shared.tsx` +- `apps/web/components/github/pr-reviews-section.tsx` +- `apps/web/components/github/pr-reviews-section.test.tsx` +- `apps/web/e2e/tests/pr/mobile-pr-rerequest-review.spec.ts` +- Relevant E2E page/helper files only when required. + +Do not edit PR mutation-state files owned by Task 06. + +## Output contract + +Use TDD. Report RED/GREEN evidence, exact checks, screenshots/traces on failure, +files changed, residual risks, and set only this task file's status to `done`. diff --git a/docs/plans/github-pr-review-rerequest/task-08-reviewer-input-hardening.md b/docs/plans/github-pr-review-rerequest/task-08-reviewer-input-hardening.md new file mode 100644 index 0000000000..677ffa9e06 --- /dev/null +++ b/docs/plans/github-pr-review-rerequest/task-08-reviewer-input-hardening.md @@ -0,0 +1,35 @@ +--- +id: "08-reviewer-input-hardening" +title: "Reviewer input hardening" +status: done +wave: 4 +depends_on: + - "01-backend-review-request" +plan: "plan.md" +spec: "../../specs/ui/github-pr-review-actions.md" +--- + +# Task 08: Reviewer input hardening + +## Acceptance + +- The HTTP boundary caps request-body bytes, reviewer count, and individual + login length before GitHub client delegation. +- Reviewer logins are trimmed and deduplicated case-insensitively while + preserving first-seen display casing and order. +- Empty-after-normalization, oversized, and over-count payloads return 400 + without invoking the client. +- Controller tests cover missing configuration and upstream rejection responses. + +## Ownership + +- `apps/backend/internal/github/controller.go` +- `apps/backend/internal/github/controller_test.go` +- New narrowly scoped controller tests if preferable. + +Do not change GitHub transport, cache, frontend, or docs files. + +## Output contract + +Use TDD. Report RED/GREEN evidence, exact checks, files changed, chosen limits +and rationale, residual risks, and set only this task file's status to `done`. diff --git a/docs/plans/github-pr-review-rerequest/task-09-key-scoped-cache-invalidation.md b/docs/plans/github-pr-review-rerequest/task-09-key-scoped-cache-invalidation.md new file mode 100644 index 0000000000..667a1748a3 --- /dev/null +++ b/docs/plans/github-pr-review-rerequest/task-09-key-scoped-cache-invalidation.md @@ -0,0 +1,36 @@ +--- +id: "09-key-scoped-cache-invalidation" +title: "Key-scoped PR cache invalidation" +status: done +wave: 4 +depends_on: + - "01-backend-review-request" +plan: "plan.md" +spec: "../../specs/ui/github-pr-review-actions.md" +--- + +# Task 09: Key-scoped PR cache invalidation + +## Acceptance + +- Review re-request invalidation prevents an older fill for the affected PR + from repopulating either feedback or status cache. +- An unrelated PR's concurrent cache fill still completes and remains cached. +- Existing cache-wide clear and repository-error invalidation race guarantees + remain unchanged. +- Deterministic barrier tests cover same-key and unrelated-key concurrent fills. + +## Ownership + +- `apps/backend/internal/github/ttl_cache.go` +- `apps/backend/internal/github/ttl_cache_test.go` +- `apps/backend/internal/github/service_pr.go` +- `apps/backend/internal/github/service_request_review_test.go` + +Do not convert repository-error caching or edit controllers, transports, +frontend, E2E, docs, spec, or `plan.md`. + +## Output contract + +Use TDD. Report RED/GREEN evidence, exact race-enabled checks, files changed, +compatibility risks, and set only this task file's status to `done`. diff --git a/docs/plans/github-pr-review-rerequest/task-10-persistent-request-lifecycle.md b/docs/plans/github-pr-review-rerequest/task-10-persistent-request-lifecycle.md new file mode 100644 index 0000000000..b5615f8af6 --- /dev/null +++ b/docs/plans/github-pr-review-rerequest/task-10-persistent-request-lifecycle.md @@ -0,0 +1,45 @@ +--- +id: "10-persistent-request-lifecycle" +title: "Persistent review-request lifecycle" +status: done +wave: 5 +depends_on: + - "06-pr-scoped-request-state" + - "07-mobile-pr-identity-layout" +plan: "plan.md" +spec: "../../specs/ui/github-pr-review-actions.md" +--- + +# Task 10: Persistent Review-request Lifecycle + +## Acceptance + +- An in-flight or successful optimistic request survives keyed panel unmounts + and remounts for the same immutable PR identity. +- A deterministic deferred-write A → B → A test proves only one POST and no + re-enabled dismissed action. +- The atomic duplicate guard does not depend on a React render occurring + between clicks. +- Optimistic pending clears when current requested-reviewer data confirms it + or when a newer review by that reviewer supersedes the dismissed baseline, + even if no refresh ever observed the intermediate requested state. +- Failed writes remain retryable and lifecycle metadata is reclaimed after a + terminal server state. +- Obsolete duplicate mutation helpers/tests are removed. + +## Ownership + +- `apps/web/components/github/use-pr-scoped-review-request.ts` +- `apps/web/components/github/pr-detail-panel.tsx` and `.test.ts` +- `apps/web/components/github/pr-reviews-section.tsx` and `.test.tsx` only if + the callback needs review identity data. +- `apps/web/e2e/tests/pr/mobile-pr-rerequest-review.spec.ts` +- Task 10 status only. + +Do not alter mobile layout geometry, backend, public docs, spec, or `plan.md`. + +## Output contract + +Use TDD. Report RED/GREEN evidence for both lifecycle races, exact checks, +state-lifetime/cleanup rationale, files changed, and set only this task file to +`done`. diff --git a/docs/plans/github-pr-review-rerequest/task-11-reclaim-cache-epochs.md b/docs/plans/github-pr-review-rerequest/task-11-reclaim-cache-epochs.md new file mode 100644 index 0000000000..3f6204a167 --- /dev/null +++ b/docs/plans/github-pr-review-rerequest/task-11-reclaim-cache-epochs.md @@ -0,0 +1,37 @@ +--- +id: "11-reclaim-cache-epochs" +title: "Reclaim key invalidation metadata" +status: done +wave: 5 +depends_on: + - "09-key-scoped-cache-invalidation" +plan: "plan.md" +spec: "../../specs/ui/github-pr-review-actions.md" +--- + +# Task 11: Reclaim Key Invalidation Metadata + +## Acceptance + +- Per-key invalidation still prevents affected stale fills and preserves + unrelated fills. +- Version metadata is retained only while an in-flight call can still write + under that key; completed/high-cardinality invalidations do not grow an + unbounded map. +- Cache-wide `clear()` and repository-error `del()` semantics remain unchanged. +- Deterministic race tests and a high-cardinality reclamation test cover the + lifecycle. + +## Ownership + +- `apps/backend/internal/github/ttl_cache.go` +- `apps/backend/internal/github/ttl_cache_test.go` +- `apps/backend/internal/github/service_request_review_test.go` only if needed. +- Task 11 status only. + +Do not edit service/controller/client/frontend/E2E/docs/spec/`plan.md`. + +## Output contract + +Use TDD, avoid sleeps, run race-enabled tests, report exact checks and +compatibility risk, and set only this task file to `done`. diff --git a/docs/public/sessions-and-review.md b/docs/public/sessions-and-review.md index acd3aa780e..ecf38db633 100644 --- a/docs/public/sessions-and-review.md +++ b/docs/public/sessions-and-review.md @@ -175,7 +175,7 @@ The creation dialog requires a title, defaults it from the task title, accepts a - Azure Repos uses `az repos pr create` and requires Azure CLI, the `azure-devops` extension, and either `az login` or `AZURE_DEVOPS_EXT_PAT`. - Other Git hosts do not have a built-in creation path. Use that host's tooling from the terminal. -GitHub has the complete in-app PR review path. A linked PR detail panel shows checks, reviews, comments, conflicts, and merge readiness. It can add PR feedback to agent context, submit an approval when allowed, ask an agent to address conflicts, and merge using a method allowed by the repository. Branch protection remains authoritative; merge is enabled only when required checks, review state, and mergeability are ready. +GitHub has the complete in-app PR review path. A linked PR detail panel shows checks, reviews, comments, conflicts, and merge readiness. It can add PR feedback to agent context, submit an approval when allowed, ask an agent to address conflicts, and merge using a method allowed by the repository. On an open PR, use the reviews list to re-request a reviewer whose review was dismissed. On a phone, open **Review** from the task bottom navigation to reach the same PR detail. GitHub permissions and repository policy remain authoritative; merge is enabled only when required checks, review state, and mergeability are ready. GitLab has a provider-specific linked-MR panel. It shows overview and branch state, approvals and pipeline rollup, files, commits, reviewers, assignees, labels, and threaded discussions. It can add selected feedback to agent context, reply or resolve discussions, approve or unapprove, update people and labels, toggle MR notifications, merge, refresh, and unlink. GitLab permissions and project policy remain authoritative. See [Integrations](integrations.md#gitlab) for linking and watch limits. diff --git a/docs/specs/INDEX.md b/docs/specs/INDEX.md index 346b23cbd2..c276f99c86 100644 --- a/docs/specs/INDEX.md +++ b/docs/specs/INDEX.md @@ -112,6 +112,7 @@ Subscription quota tracking and per-agent cheap-model profile routing. | Spec | Status | |---|---| | [ci-pr-automation](ui/ci-pr-automation.md) | draft | +| [github-pr-review-actions](ui/github-pr-review-actions.md) | shipped | | [comment-markdown](ui/comment-markdown.md) | shipped | | [empty-turn-notice](ui/empty-turn-notice.md) | shipped | | [acp-shell-command-output](ui/acp-shell-command-output.md) | shipped | diff --git a/docs/specs/ui/github-pr-review-actions.md b/docs/specs/ui/github-pr-review-actions.md new file mode 100644 index 0000000000..f17ac6f653 --- /dev/null +++ b/docs/specs/ui/github-pr-review-actions.md @@ -0,0 +1,103 @@ +--- +status: shipped +created: 2026-07-23 +owner: Kandev +--- + +# GitHub PR Review Actions + +## Why + +Pull-request authors can see dismissed GitHub reviews in Kandev, but must leave +Kandev to ask that reviewer to review again. Re-requesting a review should be +available where the dismissed review is already visible. + +## What + +- An open GitHub pull request shows a **Re-request review** action on each + reviewer's latest review when that review is `DISMISSED`. +- The action identifies the reviewer in its accessible name and uses the + dismissed review's author login as the new requested reviewer. +- A reviewer already present in GitHub's current `requested_reviewers` list is + shown as pending and cannot be requested again. +- A current request takes precedence over dismissed review history: after a + successful re-request, the reviewer is shown once as pending even though the + old dismissed review remains in GitHub's review history. +- While a request is in flight, repeated submission for that reviewer is + blocked. +- Success refreshes pull-request feedback and shows a success notification. + Failure leaves the action available and shows the returned error. +- Desktop and tablet use the existing GitHub PR detail panel. On phones, a task + with a linked GitHub PR exposes the existing **Review** bottom-navigation + destination and renders the same PR detail behavior in a full-height, + single-scroll surface. +- When a task has multiple linked GitHub PRs, the phone Review surface uses the + shared task PR selection so the user can reach the dismissed review on the + intended PR. + +## API surface + +Kandev exposes: + +```http +POST /api/v1/github/prs/:owner/:repo/:number/requested-reviewers +Content-Type: application/json + +{"reviewers":["octocat"]} +``` + +- `reviewers` contains one or more non-empty GitHub user logins. +- Success returns `200` with `{"requested": true}`. +- Invalid PR numbers or an empty/invalid reviewer list return `400`. +- The backend requests the reviewers through GitHub's pull-request review + request API and invalidates cached feedback/status for that PR before the UI + refreshes. + +## Permissions + +GitHub remains the authorization authority. The action uses the active +workspace's GitHub credentials and requires GitHub pull-request write +permission. Kandev does not elevate or emulate that permission. + +## Failure modes + +- Missing GitHub configuration fails without changing local state and surfaces + a useful error. +- GitHub permission, eligibility, validation, rate-limit, or transport failures + return a non-success response; the UI shows the error and permits retry. +- A failed request does not mark the reviewer pending. +- A successful request must not be hidden by stale PR feedback; affected + feedback and status cache entries are evicted before refresh. + +## Scenarios + +- **GIVEN** an open PR whose latest review from `octocat` is `DISMISSED` and + `octocat` is not currently requested, **WHEN** the user activates + **Re-request review from octocat**, **THEN** GitHub receives a review request, + Kandev shows success, and refreshed feedback shows `octocat` pending. +- **GIVEN** a dismissed review whose author is already in + `requested_reviewers`, **WHEN** the reviews section renders, **THEN** the + author appears once as pending and no re-request action is available. +- **GIVEN** a review whose latest state is `APPROVED`, + `CHANGES_REQUESTED`, `COMMENTED`, or `PENDING`, **WHEN** the reviews section + renders, **THEN** no re-request action is shown for that review. +- **GIVEN** a closed or merged PR with a dismissed review, **WHEN** its detail + panel renders, **THEN** no re-request action is available. +- **GIVEN** GitHub rejects a re-request, **WHEN** the action completes, + **THEN** Kandev shows the error, does not show the reviewer as pending, and + leaves the action available for retry. +- **GIVEN** a phone-sized task view with a linked GitHub PR and dismissed + review, **WHEN** the user opens **Review** and re-requests that reviewer, + **THEN** the same pending outcome is visible without horizontal document + overflow and all action targets remain touch-usable. + +## Out of scope + +- Choosing arbitrary new reviewers or teams. +- Dismissing GitHub reviews. +- Changing GitLab merge-request reviewer behavior. +- Re-requesting reviews on closed or merged pull requests. + +## Implementation plan + +[Implementation plan](../../plans/github-pr-review-rerequest/plan.md)