"use client"; import { useCallback, useEffect, useState } from "react"; import { setPanelTitle } from "@/lib/layout/panel-portal-manager"; import { IconRefresh, IconPlus, IconMinus, IconGitMerge, IconCheck, IconLoader2, } from "@tabler/icons-react"; import { Badge } from "@kandev/ui/badge"; import { Button } from "@kandev/ui/button"; import { Separator } from "@kandev/ui/separator"; import { ScrollArea } from "@kandev/ui/scroll-area"; import { Tooltip, TooltipContent, TooltipTrigger } from "@kandev/ui/tooltip"; import { useAppStore } from "@/components/state-provider"; import { useActiveTaskPR, useTaskPR } from "@/hooks/domains/github/use-task-pr"; import { prPanelLabel, prTaskKey } from "@/components/github/pr-utils"; import { usePRFeedback } from "@/hooks/domains/github/use-pr-feedback"; import { useGitHubStatus } from "@/hooks/domains/github/use-github-status"; import { getGitHubMutationActor } from "@/lib/github-auth"; 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-pr-api"; import type { TaskPR, PRFeedback } from "@/lib/types/github"; import { formatTimeAgo, AuthorLink, getTimeAgoColor, CollapsibleSection, PRMarkdownBody, } from "./pr-shared"; import { PRMergeButton } from "./pr-merge-button"; import { PRMergeabilityNotice, buildConflictResolutionMessage } from "./pr-mergeability-notice"; 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"; import { Trans, useTranslation } from "react-i18next"; // --- Dockview panel wrapper --- type PRDetailPanelProps = { panelId: string; /** Per-PR params; multi-repo panels carry prKey="//". */ params?: { prKey?: string }; }; export function PRDetailPanelComponent({ panelId, params }: PRDetailPanelProps) { const { t } = useTranslation(); const activeTaskId = useAppStore((s) => s.tasks.activeTaskId); const { prs } = useTaskPR(activeTaskId); const activePR = useActiveTaskPR(); const sessionId = useAppStore((s) => s.tasks.activeSessionId); // Multi-repo: when the panel was opened with a prKey, render the matching // TaskPR. Falls back to the active (primary) PR for legacy single-repo // panels that pre-date the prKey param. const pr = (params?.prKey ? prs.find((p) => prTaskKey(p) === params.prKey) : null) ?? activePR; useEffect(() => { const title = pr ? prPanelLabel(pr.pr_number) : "Pull Request"; setPanelTitle(panelId, title); }, [pr, panelId]); if (!pr || !sessionId) { return (
{t("github:noPullRequestLinkedToThis")}
); } return (
); } // --- Add PR feedback as chat context --- function useAddPRFeedbackAsContext(sessionId: string, prNumber: number) { const { t } = useTranslation(); const { toast } = useToast(); const addComment = useCommentsStore((s) => s.addComment); const addAsContext = useCallback( (feedbackType: PRFeedbackComment["feedbackType"], content: string) => { const comment: PRFeedbackComment = { id: `pr-feedback-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`, sessionId, text: content, createdAt: new Date().toISOString(), status: "pending", source: "pr-feedback", prNumber, feedbackType, content, }; addComment(comment); toast({ description: t("github:addedToChatContext") }); }, [sessionId, prNumber, addComment, toast], ); return { addAsContext }; } // Sync live feedback data back to the store so topbar/other consumers stay up to date. // Use primitive deps to avoid re-render loops from object reference changes. // Guard: never regress the store to a less-terminal state (e.g. merged → open) // because the feedback fetch may return stale data from before a backend poll update. function useSyncLivePRState(taskPR: TaskPR, feedback: PRFeedback | null) { const setTaskPR = useAppStore((s) => s.setTaskPR); const prState = taskPR.state; const prMergedAt = taskPR.merged_at ?? null; const prClosedAt = taskPR.closed_at ?? null; const prAdditions = taskPR.additions; const prDeletions = taskPR.deletions; const prMergeableState = taskPR.mergeable_state; const prTaskId = taskPR.task_id; useEffect(() => { if (!feedback) return; const livePR = feedback.pr; // State priority: merged > closed > open. Never regress to a less-terminal state. const stateRank = (s: string) => { if (s === "merged") return 2; if (s === "closed") return 1; return 0; }; const effectiveState = stateRank(livePR.state) >= stateRank(prState) ? livePR.state : prState; const effectiveMergedAt = effectiveState === prState ? prMergedAt : (livePR.merged_at ?? null); const effectiveClosedAt = effectiveState === prState ? prClosedAt : (livePR.closed_at ?? null); // Live mergeable_state is authoritative when present; otherwise keep the stored value. const effectiveMergeableState = livePR.mergeable_state ?? prMergeableState; if ( effectiveState !== prState || effectiveMergedAt !== prMergedAt || effectiveClosedAt !== prClosedAt || livePR.additions !== prAdditions || livePR.deletions !== prDeletions || effectiveMergeableState !== prMergeableState ) { setTaskPR(prTaskId, { ...taskPR, state: effectiveState as TaskPR["state"], additions: livePR.additions, deletions: livePR.deletions, merged_at: effectiveMergedAt, closed_at: effectiveClosedAt, mergeable_state: effectiveMergeableState, }); } // eslint-disable-next-line react-hooks/exhaustive-deps }, [ feedback, prState, prMergedAt, prClosedAt, prAdditions, prDeletions, prMergeableState, prTaskId, setTaskPR, ]); } type PRPanelMetrics = { reviewCount: number; pendingReviewCount: number; commentCount: number; reviewState: TaskPR["review_state"]; }; function computeLiveReviewState(feedback: PRFeedback, fallbackState: TaskPR["review_state"]) { const requestedReviewers = feedback.pr.requested_reviewers ?? []; const reviews = feedback.reviews ?? []; if (reviews.length === 0) { return requestedReviewers.length > 0 ? "pending" : fallbackState || ""; } const latestByAuthor = new Map(); for (const review of reviews) { const current = latestByAuthor.get(review.author); const createdAt = new Date(review.created_at).getTime(); if (!current || createdAt > current.createdAt) { latestByAuthor.set(review.author, { state: review.state, createdAt }); } } let hasChangesRequested = false; let allApproved = true; for (const review of latestByAuthor.values()) { if (review.state === "CHANGES_REQUESTED") hasChangesRequested = true; if (review.state !== "APPROVED") allApproved = false; } if (hasChangesRequested) return "changes_requested"; if (allApproved) return "approved"; return "pending"; } function derivePanelMetrics(taskPR: TaskPR, feedback: PRFeedback | null): PRPanelMetrics { if (!feedback) { return { reviewCount: taskPR.review_count, pendingReviewCount: taskPR.pending_review_count, commentCount: taskPR.comment_count, reviewState: taskPR.review_state, }; } const pendingReviewCount = feedback.pr.requested_reviewers?.length ?? taskPR.pending_review_count; return { reviewCount: (feedback.reviews ?? []).length, pendingReviewCount, commentCount: (feedback.comments ?? []).length, reviewState: computeLiveReviewState(feedback, taskPR.review_state), }; } function DescriptionSection({ body }: { body: string }) { const { t } = useTranslation(); if (!body) return null; return (
); } // GitHub logins are case-insensitive; normalize before comparing. // Fails closed when the current user is unknown — without that identity we // can't tell whether the viewer is the PR author, and GitHub rejects // self-approval, so the button would only ever produce a failed request. // Exported for unit testing. export function shouldHideApproveButton( taskPR: TaskPR, feedback: PRFeedback | null, currentUser: string | null, hasMutationActor = !!currentUser?.trim(), ): boolean { const liveState = feedback?.pr.state ?? taskPR.state; if (liveState !== "open") return true; const normalizedUser = currentUser?.trim().toLowerCase(); if (!normalizedUser) return !hasMutationActor; const prAuthor = feedback?.pr.author_login ?? taskPR.author_login; if (prAuthor?.trim().toLowerCase() === normalizedUser) return true; return ( feedback?.reviews?.some( (r) => r.state === "APPROVED" && r.author?.trim().toLowerCase() === normalizedUser, ) ?? false ); } export function shouldShowReRequestReviewAction(prState: string, reviewState: string): boolean { return prState === "open" && reviewState === "DISMISSED"; } function ApproveButton({ workspaceId, taskPR, feedback, onRefresh, }: { workspaceId: string | null; taskPR: TaskPR; feedback: PRFeedback | null; onRefresh: () => void; }) { const { t } = useTranslation(); const { toast } = useToast(); const [submitting, setSubmitting] = useState(false); // Ensures status (and thus the authenticated username) is fetched even when // the PR panel is the first GitHub-aware surface the user opens; without // this, currentUser is null on first render and shouldHideApproveButton has // no identity to compare against the PR author. const { status } = useGitHubStatus(); const currentUser = status?.username ?? null; const mutationActor = getGitHubMutationActor(status); if (shouldHideApproveButton(taskPR, feedback, currentUser, !!mutationActor)) return null; const handleApprove = async () => { if (!workspaceId) return; setSubmitting(true); try { await submitPRReview( workspaceId, { owner: taskPR.owner, repo: taskPR.repo, number: taskPR.pr_number }, "APPROVE", ); toast({ description: t("github:prApproved"), variant: "success" }); onRefresh(); } catch (e) { toast({ title: t("github:failedToApprove"), description: e instanceof Error ? e.message : t("github:anErrorOccurred"), variant: "error", }); } finally { setSubmitting(false); } }; return ( ); } /** * True once a conflict prompt for this PR is already queued — avoids piling up * identical instructions if the user clicks "Resolve conflicts" again. Extracted * from PRDetailContent, which is at the 100-line function cap. */ function useConflictQueued(sessionId: string, prNumber: number): boolean { return useCommentsStore((s) => s.pendingForChat.some((id) => { const c = s.byId[id]; return ( !!c && isPRFeedbackComment(c) && c.feedbackType === "conflict" && c.sessionId === sessionId && c.prNumber === prNumber ); }), ); } export function PRDetailContent({ taskPR, sessionId }: { taskPR: TaskPR; sessionId: string }) { const { t } = useTranslation(); const workspaceId = useAppStore((state) => state.workspaces.activeId); const { feedback, loading, refresh } = usePRFeedback( workspaceId, taskPR.owner, taskPR.repo, taskPR.pr_number, ); const { addAsContext } = useAddPRFeedbackAsContext(sessionId, taskPR.pr_number); const { toast } = useToast(); const reviewRequest = usePRScopedReviewRequest(taskPR, { workspaceId, requestedReviewers: feedback?.pr.requested_reviewers ?? [], reviews: feedback?.reviews ?? [], refresh, toast, }); useSyncLivePRState(taskPR, feedback); const metrics = derivePanelMetrics(taskPR, feedback); const conflictQueued = useConflictQueued(sessionId, taskPR.pr_number); const onResolveConflicts = useCallback(() => { if (conflictQueued) return; addAsContext( "conflict", buildConflictResolutionMessage({ prNumber: taskPR.pr_number, headBranch: taskPR.head_branch, baseBranch: taskPR.base_branch, }), ); }, [addAsContext, conflictQueued, taskPR.pr_number, taskPR.head_branch, taskPR.base_branch]); return (
{loading && !feedback && (
)} {feedback && ( <> addAsContext("review", msg)} canReRequest={shouldShowReRequestReviewAction(feedback.pr.state, "DISMISSED")} requestingReviewers={reviewRequest.requestingReviewers} onReRequest={reviewRequest.reRequest} /> addAsContext("check", msg)} /> addAsContext("comment", msg)} /> )}
{taskPR.last_synced_at && ( <>
{t("github:lastSynced")} {formatTimeAgo(taskPR.last_synced_at)}
)}
); } function StateBadge({ state }: { state: string }) { const styles: Record = { open: "bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400", draft: "bg-orange-100 text-orange-700 dark:bg-orange-900/30 dark:text-orange-400", merged: "bg-purple-100 text-purple-700 dark:bg-purple-900/30 dark:text-purple-400", closed: "bg-red-100 text-red-700 dark:bg-red-900/30 dark:text-red-400", }; return ( {state} ); } function HeaderTitleRow({ taskPR, loading, onRefresh, }: { taskPR: TaskPR; loading: boolean; onRefresh: () => void; }) { const { t } = useTranslation(); return (
{taskPR.pr_title} {t("github:refresh")}
); } function HeaderDateLine({ taskPR }: { taskPR: TaskPR }) { const { t } = useTranslation(); return (
by · {t("github:openedAgo", { time: formatTimeAgo(taskPR.created_at) })} {taskPR.merged_at && ( <> · {t("github:mergedAgo", { time: formatTimeAgo(taskPR.merged_at) })} )} {taskPR.closed_at && !taskPR.merged_at && ( <> · {t("github:closedAgo", { time: formatTimeAgo(taskPR.closed_at) })} )}
); } function HeaderStatsLine({ taskPR, metrics }: { taskPR: TaskPR; metrics: PRPanelMetrics }) { const { t } = useTranslation(); return (
{taskPR.additions} {taskPR.deletions} · {t("github:reviewCount", { count: metrics.reviewCount })} {metrics.pendingReviewCount > 0 && ( {" "} {t("github:pendingReviewCount", { count: metrics.pendingReviewCount })} )} · {t("github:commentCount", { count: metrics.commentCount })} {metrics.reviewState && }
); } function PRHeader({ workspaceId, taskPR, feedback, metrics, loading, onRefresh, onResolveConflicts, conflictQueued, }: { workspaceId: string | null; taskPR: TaskPR; feedback: PRFeedback | null; metrics: PRPanelMetrics; loading: boolean; onRefresh: () => void; onResolveConflicts: () => void; conflictQueued: boolean; }) { const liveState = feedback?.pr.state ?? taskPR.state; const isDraft = feedback?.pr.draft ?? false; const isMergeable = feedback?.pr.mergeable ?? true; // Prefer the live feedback state (refreshed by the panel's Refresh button); // fall back to the polled store value before feedback loads. const mergeableState = feedback?.pr.mergeable_state ?? taskPR.mergeable_state; return (
#{taskPR.pr_number} {taskPR.head_branch} → {taskPR.base_branch}
); }