"use client";
import { useEffect, useState, type ReactNode } from "react";
import { IconChevronDown, IconEdit, IconInfoCircle, IconRefresh } from "@tabler/icons-react";
import { Button } from "@kandev/ui/button";
import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "@kandev/ui/collapsible";
import { Label } from "@kandev/ui/label";
import { Popover, PopoverContent, PopoverTrigger } from "@kandev/ui/popover";
import { Switch } from "@kandev/ui/switch";
import { Tooltip, TooltipContent, TooltipTrigger } from "@kandev/ui/tooltip";
import { useResponsiveBreakpoint } from "@/hooks/use-responsive-breakpoint";
import {
autoFixRoundForState,
type CIAutomationQueueRecoveryState,
deriveCIAutomationQueueState,
} from "@/lib/github/ci-automation";
import type {
TaskCIAutomationPatch,
TaskCIPRAutomationState,
TaskPR,
TaskPRAutomationOptions,
} from "@/lib/types/github";
import { useTranslation } from "react-i18next";
/**
* Element-id scope unique per (task, repository, PR) so simultaneously
* mounted PR tabs in MultiPRCIPopover never share a Switch id/htmlFor pair.
*/
export function prAutomationScopeKey(pr: TaskPR): string {
return `${pr.task_id}-${pr.repository_id ?? "none"}-${pr.pr_number}`;
}
export function CIAutomationInfoButton() {
const { t } = useTranslation();
return (
{t("github:ciAutomationQueueRecoveryHelp")}
);
}
export function CIAutomationRow({
id,
label,
checked,
disabled,
onCheckedChange,
help,
supportingText,
describedBy,
}: {
id: string;
label: string;
checked: boolean;
disabled: boolean;
onCheckedChange: (checked: boolean) => void;
help?: ReactNode;
supportingText?: ReactNode;
describedBy?: string;
}) {
const { isFinePointer, isMobile } = useResponsiveBreakpoint();
const minHeight = isMobile || !isFinePointer ? "min-h-11" : "min-h-7";
return (
{help}
{supportingText ? (
{supportingText}
) : null}
);
}
export function CIAutomationErrorRow({
error,
loading,
actionLabel,
onAction,
}: {
error: string;
loading: boolean;
actionLabel: string;
onAction: () => void;
}) {
return (
{error}
);
}
export function CIAutomationHelpButton({
ariaLabel,
testId,
children,
}: {
ariaLabel: string;
testId: string;
children: ReactNode;
}) {
const { isFinePointer } = useResponsiveBreakpoint();
const [open, setOpen] = useState(false);
const trigger = (
);
if (!isFinePointer) {
return (
{trigger}
{children}
);
}
return (
{trigger}
{children}
);
}
function CIAutoFixRoundHelpButton({
state,
maxRounds,
}: {
state: TaskCIPRAutomationState | undefined;
maxRounds: number | null | undefined;
}) {
const { t } = useTranslation();
const round = autoFixRoundForState(state, maxRounds);
return (
{t("github:autoFixRoundExplanation", { current: round.current, max: round.max })}
);
}
function PRAgentPromptRows({
scopeKey,
prOptions,
disabled,
patchOption,
}: {
scopeKey: string;
prOptions: TaskPRAutomationOptions;
disabled: boolean;
patchOption: (patch: TaskCIAutomationPatch) => void;
}) {
const { t } = useTranslation();
const terminalHelpID = `task-pr-terminal-help-${scopeKey}`;
const terminalHelp = t("github:wakeAgentOnTerminalPrState");
return (
<>
{terminalHelp}
patchOption({ prompt_on_merged: checked })}
help={
{terminalHelp}
}
/>
patchOption({ prompt_on_closed: checked })}
/>
>
);
}
export function ReviewFollowUpSection({
scopeKey,
prOptions,
disabled,
patchOption,
}: {
scopeKey: string;
prOptions: TaskPRAutomationOptions;
disabled: boolean;
patchOption: (patch: TaskCIAutomationPatch) => void;
}) {
const { t } = useTranslation();
const { isFinePointer, isMobile } = useResponsiveBreakpoint();
const [open, setOpen] = useState(false);
const lifecycleEnabled =
prOptions.prompt_on_review_requested ||
prOptions.prompt_on_merged ||
prOptions.prompt_on_closed;
const minHeight = isMobile || !isFinePointer ? "min-h-11" : "min-h-7";
useEffect(() => {
if (lifecycleEnabled) setOpen(true);
}, [lifecycleEnabled]);
return (
);
}
function ReviewRequestedPromptRow({
scopeKey,
prOptions,
disabled,
patchOption,
}: {
scopeKey: string;
prOptions: TaskPRAutomationOptions;
disabled: boolean;
patchOption: (patch: TaskCIAutomationPatch) => void;
}) {
const { t } = useTranslation();
const helpID = `task-pr-review-requested-prompt-${scopeKey}-description`;
const help = t("github:wakeAgentOnReviewRequest");
return (
<>
{help}
patchOption({ prompt_on_review_requested: checked })}
help={
{help}
}
/>
>
);
}
type CIAutomationTranslate = (key: string, options?: Record) => string;
function queueContextTitle(
t: CIAutomationTranslate,
context: CIAutomationQueueRecoveryState["context"],
): string {
switch (context) {
case "queued":
return t("github:mergeQueueAutomation");
case "recovery":
return t("github:mergeQueueRecovery");
default:
return t("github:automation");
}
}
function queueRemovalCauseLabel(
t: CIAutomationTranslate,
cause: CIAutomationQueueRecoveryState["removalCause"],
): string {
switch (cause) {
case "checks_failed":
return t("github:mergeQueueRemovalCauseChecksFailed");
case "checks_timed_out":
return t("github:mergeQueueRemovalCauseChecksTimedOut");
case "conflict":
return t("github:mergeQueueRemovalCauseConflict");
default:
return "";
}
}
function autoFixQueueSupport(
t: CIAutomationTranslate,
queueState: CIAutomationQueueRecoveryState,
enabled: boolean,
): string | undefined {
switch (queueState.status) {
case "queued":
return t("github:autoFixQueueSupportQueued");
case "removed_actionable":
return enabled ? undefined : t("github:autoFixQueueSupportEnable");
case "repair_requested":
return t("github:autoFixQueueSupportRequested");
case "removed_not_actionable":
return t("github:autoFixQueueSupportNotActionable");
case "waiting_for_checks":
return t("github:autoFixQueueSupportNewHead");
default:
return undefined;
}
}
function autoMergeQueueSupport(
t: CIAutomationTranslate,
queueState: CIAutomationQueueRecoveryState,
enabled: boolean,
): string | undefined {
switch (queueState.status) {
case "queued":
return t("github:autoMergeQueueSupportQueued");
case "repair_requested":
case "waiting_for_commit":
return t("github:autoMergeQueueSupportWaitingForCommit");
case "waiting_for_checks":
return t("github:autoMergeQueueSupportWaitingForChecks");
default:
if (queueState.context !== "recovery") return undefined;
return enabled
? t("github:autoMergeQueueSupportNewHead")
: t("github:autoMergeQueueSupportDisabled");
}
}
export function CIAutomationHeader({
pr,
queueState,
disabled,
onEditPrompt,
}: {
pr: TaskPR;
queueState: CIAutomationQueueRecoveryState;
disabled: boolean;
onEditPrompt: () => void;
}) {
const { t } = useTranslation();
const title = queueContextTitle(t, queueState.context);
let subtitle = t("github:automationForPr", { number: pr.pr_number });
if (queueState.context === "queued") {
subtitle = t("github:automationForPrQueued", { number: pr.pr_number });
} else if (queueState.context === "recovery") {
const cause = queueRemovalCauseLabel(t, queueState.removalCause);
if (cause) {
subtitle = t("github:automationForPrRemoved", { number: pr.pr_number, cause });
} else {
subtitle = t("github:automationForPrRemovedGeneric", { number: pr.pr_number });
}
}
return (
);
}
export function CIAutomationQueueStatusRow({
queueState,
}: {
queueState: CIAutomationQueueRecoveryState;
}) {
const { t } = useTranslation();
if (queueState.status === "none") return null;
let message: string;
switch (queueState.status) {
case "queued":
message = t("github:mergeQueueRecoveryStatusQueued");
break;
case "removed_actionable":
message = t("github:mergeQueueRecoveryStatusActionable");
break;
case "removed_not_actionable":
message = t("github:mergeQueueRecoveryStatusNotActionable");
break;
case "repair_requested":
if (queueState.waitingForCommit) {
message = t("github:mergeQueueRecoveryStatusRepairRequestedWaiting");
} else {
message = t("github:mergeQueueRecoveryStatusRepairRequested");
}
break;
case "waiting_for_commit":
message = t("github:mergeQueueRecoveryStatusWaitingForCommit");
break;
case "waiting_for_checks":
message = t("github:mergeQueueRecoveryStatusWaitingForChecks");
break;
}
return (
{message}
);
}
export function CIAutomationOptionRows({
pr,
prOptions,
autoFixMaxRounds,
disabled,
patchOption,
automationState,
}: {
pr: TaskPR;
prOptions: TaskPRAutomationOptions;
autoFixMaxRounds: number | null | undefined;
disabled: boolean;
patchOption: (patch: TaskCIAutomationPatch) => void;
automationState: TaskCIPRAutomationState | undefined;
}) {
const { t } = useTranslation();
const scopeKey = prAutomationScopeKey(pr);
const queueState = deriveCIAutomationQueueState(pr, prOptions, automationState);
const autoFixSupportingText = autoFixQueueSupport(t, queueState, prOptions.auto_fix_enabled);
const autoMergeSupportingText = autoMergeQueueSupport(
t,
queueState,
prOptions.auto_merge_enabled,
);
return (
<>
patchOption({ auto_fix_enabled: checked })}
supportingText={autoFixSupportingText}
help={
prOptions.auto_fix_enabled ? (
) : null
}
/>
patchOption({ auto_merge_enabled: checked })}
supportingText={autoMergeSupportingText}
/>
>
);
}