import type { ProjectId, ScopedThreadRef, ThreadPullRequestLink } from "@t3tools/contracts";
import {
sourceControlClients,
UNKNOWN_SOURCE_CONTROL_CLIENT,
} from "@t3tools/client-runtime/source-control-clients";
import {
type PullRequestListLine,
pullRequestListLines,
resolveThreadPullRequestChains,
visibleThreadPullRequests,
} from "@t3tools/client-runtime/thread-pull-requests";
import {
ArrowUpRightIcon,
EyeIcon,
EyeOffIcon,
LinkIcon,
MoreHorizontalIcon,
PlusIcon,
} from "lucide-react";
import { LegendList } from "@legendapp/list/react";
import { memo, useState } from "react";
import {
COMPOSER_PULL_REQUEST_DRAG_TYPE,
encodePullRequestDragPayload,
} from "~/components/chat/composerMentionDrag";
import { writeTextToClipboard } from "~/hooks/useCopyToClipboard";
import { findProjectForChangeRequest } from "@t3tools/client-runtime/change-request-links";
import { useOpenPrLink } from "~/lib/openPullRequestLink";
import { cn } from "~/lib/utils";
import { useShortcutModifierState } from "~/shortcutModifierState";
import { useProjects, useServerConfigs, useThreadShell } from "~/state/entities";
import { PullRequestChangeBreakdownStat } from "./PullRequestChangeBreakdownStat";
import { PullRequestsUnavailableState } from "./PullRequestsUnavailableState";
import { threadEnvironment } from "~/state/threads";
import { useAtomCommand } from "~/state/use-atom-command";
import { RelativeTime } from "~/components/RelativeTime";
import { Button } from "../ui/button";
import { Menu, MenuItem, MenuPopup, MenuTrigger } from "../ui/menu";
import { MiddleTruncate } from "../ui/middle-truncate";
import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip";
import { openLinkPullRequestDialog } from "./LinkPullRequestDialog";
import {
PULL_REQUEST_ROW_CLASS,
PULL_REQUEST_ROW_NUMBER_CLASS,
PullRequestRowAuthor,
PullRequestRowBranches,
PullRequestRowGlyph,
PullRequestRowLines,
} from "./PullRequestListRow";
import {
PullRequestDiffStat,
PullRequestReviewDecisionGlyph,
pullRequestChecksStatePresentation,
} from "./pullRequestPresentation";
import { PullRequestGlyph } from "./pullRequestIcons";
import { pullRequestQuickActions } from "./pullRequestList.logic";
import { PullRequestSpeedActions, PullRequestSpeedModeContext } from "./PullRequestSpeedActions";
const SOURCE_LABELS: Record<ThreadPullRequestLink["source"], string> = {
manual: "Linked by you",
created: "Created from this thread",
agent: "Linked by the agent",
stack: "Found in the stack",
"stack-dismissed": "Dismissed",
};
function ChecksGlyph({
state,
}: {
state: NonNullable<ThreadPullRequestLink["snapshot"]>["checksState"] & string;
}) {
const presentation = pullRequestChecksStatePresentation(state);
return (
<Tooltip>
<TooltipTrigger render={<span className="inline-flex shrink-0" />}>
<presentation.Icon
role="img"
aria-label={presentation.label}
className={cn("size-3.5", presentation.toneClassName)}
/>
</TooltipTrigger>
<TooltipPopup>{presentation.label}</TooltipPopup>
</Tooltip>
);
}
function LinkRowImpl({
line,
threadRef,
projectId,
speedMode,
onUnlink,
onSetWatching,
}: {
line: PullRequestListLine;
threadRef: ScopedThreadRef;
projectId: ProjectId | null;
speedMode: boolean;
onUnlink: (link: ThreadPullRequestLink) => void;
onSetWatching: ((link: ThreadPullRequestLink, watching: boolean) => void) | null;
}) {
const openPrLink = useOpenPrLink(threadRef);
const [menuOpen, setMenuOpen] = useState(false);
const [menuPosition, setMenuPosition] = useState<{ x: number; y: number } | null>(null);
const menuAnchor = menuPosition
? { getBoundingClientRect: () => new DOMRect(menuPosition.x, menuPosition.y, 0, 0) }
: undefined;
const { link, depth, stack } = line;
const snapshot = link.snapshot;
const open = snapshot === null || snapshot.state === "open";
const watching = link.watch !== undefined;
const linkHost =
sourceControlClients.findByChangeRequestUrl(link.url) ?? UNKNOWN_SOURCE_CONTROL_CLIENT;
const linkHostActions = linkHost.changeRequestActions;
const actionEntry =
projectId !== null && snapshot !== null && snapshot.state !== "merged"
? {
environmentId: threadRef.environmentId,
projectId,
host: link.host,
repository: link.repository,
number: link.number,
state: snapshot.state,
isDraft: snapshot.isDraft,
...(link.stack === null ? {} : { stack: link.stack }),
}
: null;
const hasQuickActions =
actionEntry !== null && pullRequestQuickActions(actionEntry, linkHostActions).length > 0;
return (
<div
className={cn(PULL_REQUEST_ROW_CLASS, "relative hover:bg-accent/60")}
onContextMenu={(event) => {
event.preventDefault();
event.stopPropagation();
setMenuPosition({ x: event.clientX, y: event.clientY });
setMenuOpen(true);
}}
style={{ paddingLeft: `${0.5 + Math.min(depth, 3) * 1.25}rem` }}
>
{depth > 0 ? <span aria-hidden className="-ml-2 h-6 w-px shrink-0 bg-border/70" /> : null}
{snapshot === null ? (
<PullRequestGlyph.pullRequest
aria-label="Waiting for host state"
className="size-4 shrink-0 text-muted-foreground"
/>
) : (
<PullRequestRowGlyph
state={snapshot.state}
isDraft={snapshot.isDraft}
mergeability={snapshot.mergeability}
baseBranch={snapshot.baseBranch}
/>
)}
<a
href={link.url}
onClick={(event) => openPrLink(event, link.url, threadRef)}
// Outside drops use the URL; the composer uses this context-chip payload.
onDragStart={
snapshot === null
? undefined
: (event) =>
event.dataTransfer.setData(
COMPOSER_PULL_REQUEST_DRAG_TYPE,
encodePullRequestDragPayload({
number: link.number,
title: snapshot.title,
url: link.url,
headBranch: snapshot.headBranch,
baseBranch: snapshot.baseBranch,
state: snapshot.state,
isDraft: snapshot.isDraft,
}),
)
}
className="flex min-w-0 flex-1"
>
<PullRequestRowLines
number={
<Tooltip>
<TooltipTrigger render={<span className={PULL_REQUEST_ROW_NUMBER_CLASS} />}>
#{link.number}
</TooltipTrigger>
<TooltipPopup>
{SOURCE_LABELS[link.source]} · <RelativeTime timestamp={link.linkedAt} />
</TooltipPopup>
</Tooltip>
}
title={snapshot?.title ?? link.repository}
signals={
open ? (
<>
{watching ? (
<Tooltip>
<TooltipTrigger render={<span className="inline-flex shrink-0" />}>
<EyeIcon role="img" aria-label="Watching" className="size-3.5" />
</TooltipTrigger>
<TooltipPopup>
Watching: the agent wakes when checks finish, someone comments, or the branch
conflicts
</TooltipPopup>
</Tooltip>
) : null}
{snapshot?.checksState ? <ChecksGlyph state={snapshot.checksState} /> : null}
{snapshot?.reviewDecision ? (
<PullRequestReviewDecisionGlyph decision={snapshot.reviewDecision} />
) : null}
</>
) : null
}
status={
projectId === null ? (
<PullRequestDiffStat
additions={snapshot?.additions ?? 0}
deletions={snapshot?.deletions ?? 0}
className="font-mono"
/>
) : (
<PullRequestChangeBreakdownStat
environmentId={threadRef.environmentId}
reference={{
projectId,
host: link.host,
repository: link.repository,
number: link.number,
}}
additions={snapshot?.additions ?? 0}
deletions={snapshot?.deletions ?? 0}
className="font-mono"
/>
)
}
meta={
<>
{stack ? (
<Tooltip>
<TooltipTrigger
render={
<span className="inline-flex shrink-0 items-center gap-0.5 text-foreground/70" />
}
>
<PullRequestGlyph.stack aria-hidden className="size-3" />
{stack.size}
</TooltipTrigger>
<TooltipPopup>
{stack.kind === "native"
? `${sourceControlClients.hostLabelForChangeRequestUrl(link.url)} stack of ${stack.size}: merging a layer lands the ones below it.`
: `${stack.size} ${linkHost.changeRequest.plural} chained by base branch.`}
</TooltipPopup>
</Tooltip>
) : null}
{snapshot?.author ? (
<PullRequestRowAuthor
actor={snapshot.author}
className="shrink-0"
labelClassName="max-w-28"
/>
) : null}
{snapshot !== null ? (
<>
<Tooltip>
<TooltipTrigger render={<span className="flex min-w-0 max-w-32 font-mono" />}>
<MiddleTruncate value={link.repository} showTitle={false} />
</TooltipTrigger>
<TooltipPopup>{link.repository}</TooltipPopup>
</Tooltip>
<PullRequestRowBranches head={snapshot.headBranch} base={snapshot.baseBranch} />
</>
) : (
<span className="truncate font-mono">
{link.host}/{link.repository}
</span>
)}
</>
}
updatedAt={snapshot?.updatedAt}
/>
</a>
{actionEntry !== null ? (
<PullRequestSpeedActions
entry={actionEntry}
hostActions={linkHostActions}
terminology={linkHost.changeRequest}
/>
) : null}
<span
className={cn(
"absolute right-0 bottom-0.5 flex items-center rounded-r-md bg-background pr-1 pl-5",
"[mask-image:linear-gradient(to_right,transparent,black_1rem)]",
// Hidden controls would intercept link taps on touch screens.
"pointer-events-none opacity-0 group-hover/pr-row:pointer-events-auto group-hover/pr-row:opacity-100",
"has-[[data-popup-open]]:pointer-events-auto has-[[data-popup-open]]:opacity-100",
"has-[:focus-visible]:pointer-events-auto has-[:focus-visible]:opacity-100",
"group-has-[[data-pull-request-action-pending=true]]/pr-row:hidden",
speedMode && hasQuickActions && "hidden",
)}
>
<span aria-hidden className="absolute inset-0 bg-accent/60" />
<Menu
open={menuOpen}
onOpenChange={(open) => {
setMenuOpen(open);
if (!open) setMenuPosition(null);
}}
>
<MenuTrigger
render={
<Button
variant="ghost"
size="icon-micro"
aria-label={`Actions for #${link.number}`}
className="relative"
>
<MoreHorizontalIcon className="size-3.5" />
</Button>
}
/>
<MenuPopup
anchor={menuAnchor}
align={menuPosition ? "start" : "end"}
side="bottom"
sideOffset={menuPosition ? 0 : 4}
>
<MenuItem onClick={() => void writeTextToClipboard(link.url, "link")}>
<LinkIcon className="size-3.5" />
Copy link
</MenuItem>
<MenuItem onClick={(event) => openPrLink(event, link.url, threadRef)}>
<ArrowUpRightIcon className="size-3.5" />
Open
</MenuItem>
{onSetWatching !== null && open ? (
<MenuItem onClick={() => onSetWatching(link, !watching)}>
{watching ? <EyeOffIcon className="size-3.5" /> : <EyeIcon className="size-3.5" />}
{watching ? "Stop watching" : "Watch for changes"}
</MenuItem>
) : null}
<MenuItem onClick={() => onUnlink(link)}>
<PullRequestGlyph.unlink className="size-3.5" />
{link.source === "stack" ? "Dismiss from thread" : "Unlink from thread"}
</MenuItem>
</MenuPopup>
</Menu>
</span>
</div>
);
}
const LinkRow = memo(LinkRowImpl);
function latestSyncedAt(links: ReadonlyArray<ThreadPullRequestLink>): string | null {
let latest: string | null = null;
for (const link of links) {
const at = link.snapshot?.syncedAt;
if (at !== undefined && (latest === null || at > latest)) latest = at;
}
return latest;
}
const lineKey = (line: PullRequestListLine) =>
`${line.link.host}/${line.link.repository}#${line.link.number}`;
export function ThreadPullRequestsPanel({ threadRef }: { threadRef: ScopedThreadRef }) {
const configs = useServerConfigs();
if (configs.get(threadRef.environmentId) === undefined) {
return (
<PullRequestsUnavailableState
title="Linked pull requests unavailable"
error="This environment does not support multiple linked pull requests."
/>
);
}
return <EnabledThreadPullRequestsPanel threadRef={threadRef} />;
}
function EnabledThreadPullRequestsPanel({ threadRef }: { threadRef: ScopedThreadRef }) {
const thread = useThreadShell(threadRef);
const projects = useProjects();
const environmentProjects = projects
.filter((project) => project.environmentId === threadRef.environmentId)
.toSorted((left, right) =>
left.id === thread?.projectId ? -1 : right.id === thread?.projectId ? 1 : 0,
);
// Derive lines before later hooks to preserve compiler caching and avoid LegendList renders.
const links = visibleThreadPullRequests(thread?.pullRequests ?? []);
const lines = pullRequestListLines(resolveThreadPullRequestChains(links));
const openCount = links.filter(
(link) => link.snapshot === null || link.snapshot.state === "open",
).length;
const lastSynced = latestSyncedAt(links);
const linkCount = links.length;
const modifiers = useShortcutModifierState(true);
const speedMode =
modifiers.shiftKey && !modifiers.metaKey && !modifiers.ctrlKey && !modifiers.altKey;
const openLinkDialog = () => openLinkPullRequestDialog(threadRef);
const unlink = useAtomCommand(threadEnvironment.unlinkPullRequest, { reportFailure: true });
const watch = useAtomCommand(threadEnvironment.watchPullRequest, { reportFailure: true });
const capabilities = useServerConfigs().get(threadRef.environmentId)?.environment.capabilities;
const supportsWatch = capabilities?.threadPullRequestWatch === true;
const handleUnlink = (link: ThreadPullRequestLink) => {
void unlink({
environmentId: threadRef.environmentId,
input: {
threadId: threadRef.threadId,
host: link.host,
repository: link.repository,
number: link.number,
},
});
};
const handleSetWatching = (link: ThreadPullRequestLink, watching: boolean) => {
void watch({
environmentId: threadRef.environmentId,
input: {
threadId: threadRef.threadId,
host: link.host,
repository: link.repository,
number: link.number,
watching,
},
});
};
// Legend rows update only for data/extraData changes; include all external inputs.
const rowInputs = { speedMode, environmentProjects, capabilities, supportsWatch, thread };
if (linkCount === 0) {
return (
<div className="flex h-full flex-col items-center justify-center gap-2 p-6 text-center">
<PullRequestGlyph.link aria-hidden className="size-6 text-muted-foreground/60" />
<p className="text-sm font-medium">No linked pull requests</p>
<p className="max-w-60 text-xs text-muted-foreground">
Pull requests the agent opens from this thread land here. Link one yourself from a URL or
a number.
</p>
<Button size="sm" variant="outline" onClick={openLinkDialog}>
<PlusIcon className="size-3.5" />
Link pull request
</Button>
</div>
);
}
return (
<PullRequestSpeedModeContext value={speedMode}>
<div className="flex h-full min-h-0 flex-col">
{/* Threads that run a stack or a sweep link hundreds of pull requests; only the rows in
view are mounted. */}
<LegendList<PullRequestListLine>
data={lines}
keyExtractor={lineKey}
extraData={rowInputs}
renderItem={({ item: line }) => (
<LinkRow
line={line}
threadRef={threadRef}
projectId={
capabilities !== undefined
? (findProjectForChangeRequest(environmentProjects, line.link)?.id ??
thread?.projectId ??
null)
: null
}
speedMode={speedMode}
onUnlink={handleUnlink}
onSetWatching={supportsWatch ? handleSetWatching : null}
/>
)}
estimatedItemSize={44}
drawDistance={440}
className="min-h-0 flex-1 overscroll-contain p-1.5"
/>
<footer className="flex items-center justify-between border-t border-border/60 px-2 py-1.5 text-2xs text-muted-foreground">
<span>
{openCount} open · {linkCount} linked
{lastSynced ? (
<>
{" · synced "}
<RelativeTime timestamp={lastSynced} />
</>
) : null}
</span>
<Button size="xs" variant="ghost" onClick={openLinkDialog}>
<PlusIcon className="size-3.5" />
Link
</Button>
</footer>
</div>
</PullRequestSpeedModeContext>
);
}