apps/web/app/routes/workspace/work/item.tsx · flagon-io/g1t

? `${state} work item #${item.number} in ${params.owner}, opened by ${item.author.username}${item.requestedBy ? ` for ${item.requestedBy.username}` : ""}.${body ? ` ${body}` : ""}`

63

: null,

64

// The card shows the title and the state.

65

version: item ? [item.title, item.state, item.reason] : undefined,

type: "article",

});

}

/** `owner/name` as a repository path. */

71

function pathOf(path: string): { namespace: string; name: string } {

72

const [namespace = "", name = ""] = path.split("/");

73

return { namespace, name };

74

}

75

76

export async function loader({ params, context }: Route.LoaderArgs) {

77

const viewer = getViewer(context);

78

const workspace = params.owner.toLowerCase();

79

const number = Number(params.number);

80

if (!Number.isInteger(number) || number < 1) throw notFound("page");

81

const member = roleIn(viewer, workspace) != null;

82

// The item is what the page is about: without it there is no page.

83

// Everything beside it is a part (lib/partial.ts), which says it could

84

// not be loaded in its own place when its service fails.

85

const [found, labels, milestones, members, teams, coordination, ended, agentSetup] = await Promise.all([

86

work.getWorkItem(workspace, number, viewer),

87

part(work.listLabels(workspace, viewer), "Labels"),

88

// Open ones to choose from, and the one it is in, with its progress.

89

part(work.listMilestones(workspace, viewer), "Milestones"),

90

// A member picks assignees from the workspace's people.

91

member ? part(identity.listMembers(workspace, viewer), "The workspace's people") : null,

92

// The teams a member can mention, for the comment box: only a

93

// suggestion, so the box quietly does without them.

94

member ? identity.listTeams(viewer, workspace).catch(() => null) : null,

95

// Its repositories with their pull requests and what landed where, who

96

// is on it, its sessions, what it waits on, and what it may also need

97

// (services/work `get_work`).

98

part(work.getWork(workspace, number, viewer), "Work"),

99

// Its claims that ended, shown muted under the active ones: history

100

// the panel can do without when it cannot be read.

101

Promise.all((["released", "expired", "handed_off"] as const).map((state) => work.listClaims(workspace, viewer, { state, item: number }).catch(() => null))),

102

// Whether a member can start a session on the workspace's Anthropic

103

// account: the button is simply not offered when this cannot be read.

104

member ? agentSessions.setup(workspace, viewer).catch(() => null) : null,

105

]);

106

if (!found.ok) {

107

// Work items and pull requests share the workspace's numbers: this may be a pull request.

108

const to = await refPath(viewer, { workspace }, number);

109

if (to && to !== itemPath(workspace, number)) throw redirect(to);

110

throw notFound("page");

111

}

112

const { item } = found.value;

113

const origin = originOf(item.repos);

114

// Who may do what follows the item: the better of their role in the

115

// workspace and on its origin repository (lib/work-access.ts).

116

const [originRepo, links, subscription, sessionTrees] = await Promise.all([

117

origin ? repos.getById(origin.repoId, viewer).catch(() => null) : null,

118

// What it is tied to outside g1t. Shown only once the item is known visible.

119

part(integrations.links(workspace, number), "Links from outside g1t"),

120

// Whether the viewer hears of it, for the sidebar's Notifications.

121

viewer ? part(inbox.subscription(viewer, { itemId: item.id, number }), "Notifications") : null,

122

// Every session tied to it in its repositories, with their subagents, for the Work panel's trees.

123

part(

124

Promise.all(item.repos.slice(0, 6).map((linked) => work.listWorkSessions(pathOf(linked.path), viewer, { item: number, subagents: true }))).then((lists) =>

125

lists.flatMap((list) => (list.ok ? list.value : [])),

),

"Sessions",

),

]);

const ref = originRepo?.ok ? { id: originRepo.value.id, namespace: originRepo.value.namespace, isPrivate: originRepo.value.isPrivate } : null;

131

const can = itemAbilities(viewer, workspace, ref);

132

// The repositories that can be linked, for whoever may link them.

133

const projects = can.triage ? await part(workspaceProjects(workspace, viewer), "Repositories") : null;

134

return {

135

repos:

136

projects == null || isFailed(projects) || !projects.ok

137

? null

138

: projects.value

139

.filter((p) => p.workspace.toLowerCase() === workspace)

.map((p) => p.slug)

.sort(),

...found.value,

workspace,

viewer,

member,

labels: isFailed(labels) ? labels : labels.ok ? labels.value : [],

147

milestones: isFailed(milestones) ? milestones : milestones.ok ? milestones.value : [],

148

links,

149

subscription,

150

coordination: isFailed(coordination) ? coordination : coordination.ok ? coordination.value : null,

151

sessionTrees,

152

// Only when it can start: the button is not shown otherwise.

153

agentSetup: agentSetup?.ok && agentSetup.value.available ? agentSetup.value : null,

154

endedClaims: ended

155

.flatMap((claims) => (claims?.ok ? claims.value : []))

156

.sort((a, b) => Date.parse(b.endedAt ?? b.createdAt) - Date.parse(a.endedAt ?? a.createdAt)),

157

members: members == null ? [] : isFailed(members) ? members : members.ok ? members.value.map((m) => m.username) : [],

158

handles: teams?.ok ? teams.value.map((team) => `@${team.workspace}/${team.slug}`) : [],

159

// The author can close and reopen their own work item, and whoever g1t's

160

// agent filed one for, that one; Triage and up, anyone's.

161

canManage: viewer != null && (viewer.id === workOwner(item).id || can.triage),

162

// Maintain and up edit and delete anyone's comments; everyone, their own.

163

canModerate: can.manage_settings,

can,

};

}

/** The repository a form names, by path, if it is one the item is linked to (or, to link, one of the workspace). */

169

function formRepo(form: FormData, workspace: string): { namespace: string; name: string } | null {

170

return repoFilter(workspace, String(form.get("repo") ?? "").trim());

171

}

172

173

export async function action({ request, params, context }: Route.ActionArgs) {

174

assertSameOrigin(request);

175

const user = requireUser(context, request);

176

const workspace = params.owner.toLowerCase();

177

const number = Number(params.number);

178

const thread = { workspace, number };

179

const form = await request.formData();

180

const intent = String(form.get("action") ?? "");

181

// Subscribing to it, from the sidebar's Notifications (components/notifications.tsx).

182

const choice = subscriptionFromForm(form);

183

if (choice) {

184

const found = await work.getWorkItem(workspace, number, user);

185

if (!found.ok) return data({ error: "That work item could not be found." }, { status: 404 });

186

const subscription = await inbox.subscribe(user, { itemId: found.value.item.id, number }, choice.subscribed, choice.ignored).catch(() => null);

187

return subscription ? { error: null, subscription } : data({ error: "That did not save. Try again in a moment." }, { status: 503 });

188

}

189

// Who may do each is checked by the work service, against the item's

190

// workspace and origin; what it refuses says why.

191

switch (intent) {

192

case "open-pull": {

193

const repo = formRepo(form, workspace);

194

if (!repo) return { error: "Choose the repository to open it in.", action: intent };

195

const result = await work.openPull(user, repo, { item: number, agent: String(form.get("agent") ?? ""), runtime: "external" });

196

if (!result.ok) return { error: result.error.message, action: intent };

197

throw redirect(`/${repo.namespace}/${repo.name}/pull/${result.value.number}`);

198

}

199

// A session on the workspace's Anthropic account, in one of its

200

// repositories, which the integrations service checks the person may

201

// start; then its page.

202

case "start-session": {

203

const repo = formRepo(form, workspace);

204

if (!repo) return { error: "Link a repository for it to work in first.", action: intent };

205

const mode = AGENT_MODES.find((one) => one.mode === form.get("mode"))?.mode ?? "implement";

206

const instruction = String(form.get("instruction") ?? "").trim();

207

const result = await agentSessions.start(user, repo, { item: number, mode, instruction: instruction || undefined, handoff: false }).catch(() => null);

208

if (!result) return { error: "The session could not be started. Try again in a moment.", action: intent };

209

if (!result.ok) return { error: result.error.message, action: intent };

210

const started = result.value;

211

const to = sitePath(started.sessionUrl, request.url) ?? (started.session ? sessionPath(repo.namespace, started.session.id) : null);

212

if (!to) return { error: "No session was started.", action: intent };

throw redirect(to);

}

case "comment": {

const result = await work.addComment(user, thread, { body: String(form.get("body") ?? "") });

217

return result.ok ? null : { error: result.error.message };

218

}

219

// A reaction to the item or one of its comments, or taking one back.

220

case "react": {

221

const content = REACTIONS.find((one) => one.content === form.get("content"))?.content;

222

if (!content) return { error: "Pick a reaction.", action: intent };

223

const result = await work.react(user, thread, {

224

commentId: String(form.get("comment") ?? "") || undefined,

225

content,

226

remove: form.get("remove") === "1",

227

});

228

return result.ok ? null : { error: result.error.message, action: intent };

229

}

230

case "assign": {

231

const result = await work.updateWorkItem(user, workspace, number, {

232

assignees: [...form.getAll("assignee").map(String), ...String(form.get("others") ?? "").split(/[\s,]+/)].filter(Boolean),

233

});

234

return result.ok ? null : { error: result.error.message };

235

}

236

case "labels": {

237

const result = await work.setLabels(user, thread, form.getAll("label").map(String));

238

return result.ok ? null : { error: result.error.message, action: intent };

239

}

240

case "blocked-by": {

241

const blockedBy = parseBlockedBy(String(form.get("blocked_by") ?? ""));

242

if (!blockedBy) return { error: "List work item numbers, such as #12, #14.", action: intent };

243

const result = await work.updateWorkItem(user, workspace, number, { blocked_by: blockedBy });

244

return result.ok ? null : { error: result.error.message, action: intent };

245

}

246

case "milestone": {

247

const result = await work.updateWorkItem(user, workspace, number, { milestone: Number(form.get("milestone")) || 0 });

248

return result.ok ? null : { error: result.error.message, action: intent };

249

}

250

// Linking a repository in a role (a suggestion's Add as target is one), or unlinking one.

251

case "link":

252

case "unlink": {

253

const repo = formRepo(form, workspace);

254

if (!repo) return { error: "Choose a repository of the workspace.", action: "link" };

255

const role = LINK_ROLES.find((one) => one === form.get("role")) ?? "target";

256

const result =

257

intent === "link" ? await work.linkWorkItem(user, workspace, number, repo, role) : await work.unlinkWorkItem(user, workspace, number, repo);

258

return result.ok ? { linked: intent } : { error: result.error.message, action: "link" };

259

}

260

case "reopen": {

261

const result = await work.reopenWorkItem(user, workspace, number);

262

return result.ok ? null : { error: result.error.message };

263

}

264

// A comment's own text, changed or taken away: its author's to do, or

265

// a maintainer's, which work checks.

266

case "edit-comment":

267

case "delete-comment": {

268

const id = String(form.get("comment") ?? "");

269

const result =

270

intent === "edit-comment"

271

? await work.editComment(user, { workspace }, id, String(form.get("body") ?? ""))

272

: await work.deleteComment(user, { workspace }, id);

273

return result.ok ? null : { error: result.error.message, action: intent, comment: id };

274

}

275

case "close-completed":

276

case "close-not-planned": {

277

const result = await work.closeWorkItem(user, workspace, number, intent === "close-not-planned" ? "not_planned" : "completed");

278

return result.ok ? null : { error: result.error.message };

279

}

280

}

281

throw data(null, { status: 400 });

282

}

283

284

/** The path of a page of this site an address names, to redirect to; null for none or another site's. */

285

function sitePath(url: string | null | undefined, here: string): string | null {

286

if (!url) return null;

287

try {

288

const parsed = new URL(url, here);

289

const own = parsed.origin === new URL(here).origin || parsed.hostname === "g1t.sh";

290

return own ? parsed.pathname + parsed.search : null;

} catch {

return null;

}

}

/** What became of a pull request, in a few words. */

297

function outcome(pull: { status: Pull["status"] } & Partial<Pick<Pull, "mergedBy" | "supersededBy">>): string {

298

if (pull.status === "merged") return pull.mergedBy ? `Merged by ${pull.mergedBy}` : "Merged";

299

if (pull.supersededBy != null) return `Closed · #${pull.supersededBy} was merged instead`;

300

if (pull.status === "closed") return "Closed without merging";

301

if (pull.status === "draft") return "Draft · in progress";

302

return "Ready for review";

303

}

304

305

/** One of a repository's pull requests for the item, as a line under the repository. */

306

function RepoPullLine({ repo, pull, full }: { repo: string; pull: WorkPull; full?: Pull }) {

307

const merged = pull.status === "merged";

return (

<li>

<Link

to={`/${repo}/pull/${pull.number}`}

312

prefetch="intent"

313

className={`flex min-w-0 items-start gap-2.5 rounded-lg px-2 py-2 transition-colors hover:bg-raised ${pull.status === "closed" ? "opacity-70" : ""}`}

>

</span>

{pull.title} <span className="font-normal text-faint">#{pull.number}</span>

</span>

{outcome({ status: pull.status, mergedBy: full?.mergedBy, supersededBy: full?.supersededBy })}

325

</span>

326

<span>· {pull.author.username}</span>

327

{full && <ChangeSize files={full.files} />}

328

329

{pull.queue && <span>· in the merge queue, {pull.queue.position === 1 ? "next" : `#${pull.queue.position}`}</span>}

</span>

</span>

</Link>

</li>

);

}

/**

* One repository the item is linked to: its path and role, whether what

339

* closes the item has landed there (or, for a target, that it is still

340

* missing), and its pull requests for it. With Triage, the cross unlinks

341

* it (never its origin).

342

*/

343

function RepoCard({ repo, pulls, full, canLink }: { repo: ItemRepo; pulls: WorkPull[]; full: Map<string, Pull>; canLink: boolean }) {

344

const missing = repo.role === "target" && !repo.landed;

return (

{repo.path && repo.deleted ? (

349

// Deleted, and restorable until it is purged: its name, nothing to open.

350

351

352

{repo.path} <span className="font-sans text-xs text-faint">deleted</span>

</span>

</Hint>

) : repo.path ? (

{repo.path}

</Link>

) : (

// Deleted before work items: nothing to link to, and no name kept.

361

<span className="min-w-0 truncate text-sm text-muted">A deleted repository</span>

362

)}

363

364

{repo.legacyNumber != null && (

<Hint

label={

repo.path

? `It was ${repo.path}#${repo.legacyNumber} before work items, and that still leads here.`

369

: `It was #${repo.legacyNumber} there before work items.`

370

}

371

>

372

<span className="shrink-0 text-xs text-faint">was #{repo.legacyNumber}</span>

</Hint>

)}

{repo.landed ? (

Landed

</span>

) : missing ? (

Missing

</span>

) : null}

{canLink && repo.role !== "origin" && (

</Button>

</Hint>

</Form>

)}

</span>

</div>

{pulls.length > 0 ? (

401

402

{pulls.map((pull) => (

))}

</ul>

) : (

<p className="mt-1 text-xs text-faint">{repo.role === "touched" ? "Touched by a commit." : "No pull request for it here yet."}</p>

)}

</li>

);

}

/** Link a repository: one of the workspace's, in a role. A sheet from the bottom on a phone. */

414

function LinkRepository({

workspace,

repos,

linked,

error,

wide = false,

}: {

workspace: string;

/** The workspace's repositories by name; null when they could not be read. */

423

repos: string[] | null;

424

linked: string[];

425

error?: string | null;

426

wide?: boolean;

427

}) {

428

const [open, setOpen] = useState(Boolean(error));

429

const choices = (repos ?? []).filter((name) => !linked.includes(`${workspace}/${name}`.toLowerCase()));

return (

Link a repository

</Button>

</DialogTrigger>

<Form method="post" className="grid gap-5" onSubmit={() => setOpen(false)}>

440

441

442

<DialogTitle>Link a repository</DialogTitle>

443

444

A target is where the work is meant to land: the item closes once every target has landed. Touched marks one it reached without having to land

there.

</DialogDescription>

</DialogHeader>

{repos == null ? (

) : (

<SelectField

name="repo"

aria-label="Repository"

454

defaultValue={choices[0] ?? ""}

455

options={choices.length > 0 ? choices.map((name) => ({ value: name, label: name })) : [{ value: "", label: "No other repository to link" }]}

/>

)}

<SelectField

name="role"

aria-label="Role"

defaultValue="target"

462

options={(["target", "touched"] as LinkRole[]).map((role) => ({ value: role, label: ROLE_LABELS[role] }))}

463

/>

464

{error && <ErrorText>{error}</ErrorText>}

Link

</SubmitButton>

</DialogFooter>

</Form>

</DialogContent>

</Dialog>

);

}

/** A repository the work may also belong in, with why, and Add as target. */

477

function SuggestionLine({ suggestion, workspace, canLink }: { suggestion: SuggestedTarget; workspace: string; canLink: boolean }) {

return (

{shortPath(suggestion.path, workspace)}

484

</Link>

485

<span className="mt-0.5 block text-xs text-muted">{suggestion.why}</span>

</span>

{canLink && (

Add as target

</SubmitButton>

</Form>

)}

</li>

);

}

export default function WorkItemPage({ loaderData, actionData }: Route.ComponentProps) {

502

const { item, pulls, comments, viewer, labels, members, canManage, can, workspace } = loaderData;

503

// Its Work, when it could be read; a failure says so in its places.

504

const coordination = isFailed(loaderData.coordination) ? null : loaderData.coordination;

505

const sessionTrees = isFailed(loaderData.sessionTrees) ? null : loaderData.sessionTrees;

506

// What changes to it (comments, labels, links, its pull requests) shows as it happens.

507

useWorkspaceLive({ workspace, member: loaderData.member, match: workPages.item(item.number), followBottom: true });

508

// Follow pull requests at work without a manual reload.

509

useRefreshWhile(pulls.some((pull) => pull.status === "draft" || pull.checkStatus === "queued" || pull.checkStatus === "running"));

510

// Claims lapse and sessions go idle with no event to say so: looked at again now and then.

511

useRefreshWhile((coordination?.claims.length ?? 0) > 0 || (coordination?.sessions.some((session) => session.state !== "ended") ?? false), 30_000);

512

const now = Date.now();

513

514

const open = item.state === "open";

515

const reference = `${workspace}#${item.number}`;

516

const canLink = can.triage;

517

// Each repository with its pull requests for the item: from its work

518

// context, else from the item's own pull requests.

519

const bySlug = new Map(item.repos.map((repo) => [repo.repoId, repo.path]));

520

const full = new Map(pulls.map((pull) => [`${pull.repoId}#${pull.number}`, pull]));

521

const repoRows: { repo: ItemRepo; pulls: WorkPull[] }[] = coordination

522

? coordination.repos.map((repo: WorkRepo) => ({ repo, pulls: repo.pulls }))

523

: item.repos.map((repo) => ({

524

repo,

525

pulls: pulls

526

.filter((pull) => pull.repoId === repo.repoId)

.map((pull) => ({

repo: repo.path,

number: pull.number,

title: pull.title,

status: pull.status,

branch: pull.branch,

headCommit: pull.headCommit,

534

author: { id: pull.author.id, username: pull.author.username },

535

checkStatus: pull.checkStatus,

536

requiredChecks: [],

537

mergeable: "unknown" as const,

overlaps: [],

queue: null,

})),

}));

const missing = coordination?.missing ?? missingTargets(item.repos);

543

const suggestions = (coordination?.suggestedTargets ?? []).filter((one) => !item.repos.some((repo) => repo.repoId === one.repoId));

544

// Where each session's page is: under the repository it was recorded in.

545

const sessionBase = (session: { repoId: string }) => `/${bySlug.get(session.repoId) ?? item.repos[0]?.path ?? workspace}`;

546

// Its decisions as a story, oldest first; the failure that still stands, with what answered it.

547

const decisions = coordination ? [...coordination.decisions].reverse() : [];

548

const failure = coordination?.lastIntegrationFailure ?? null;

549

const resolution = failure ? resolutionOf(coordination!.decisions, failure) : null;

550

// A decision or the merge queue names a pull request by number: link it in the repository that has it, or not at all.

551

const pullHref = pullHrefs(repoRows.map(({ repo, pulls: repoPulls }) => ({ path: repo.path, pulls: repoPulls })));

552

const failureBase = `/${originOf(item.repos)?.path || workspace}`;

553

// Where a pull request or a session would be opened: a target still missing, else where it was filed.

554

// A deleted repository takes no pull request.

555

const openable = item.repos.filter((repo) => repo.path && !repo.deleted);

556

const workIn = missing[0] ?? item.repos.find((repo) => repo.role === "target")?.path ?? originOf(item.repos)?.path ?? null;

557

const linkError = actionData && "action" in actionData && actionData.action === "link" ? actionData.error : null;

558

const sideError = actionData && "action" in actionData && ["blocked-by", "start-session", "react", "link", "open-pull"].includes(String(actionData.action));

559

560

return (

561

// On a phone: the title, then the item, its repositories and the

562

// conversation, then the sidebar as a Details disclosure; beside it

563

// from lg up. Its main actions sit at the bottom, within a thumb's reach.

{item.title} <span className="font-normal text-faint">#{item.number}</span>

</h1>

<PersonLink name={item.author.username} className="font-medium text-fg hover:underline" /> opened this{" "}

576

{item.requestedBy && (

577

<>

578

for <PersonLink name={item.requestedBy.username} className="font-medium text-fg-soft hover:underline" />{" "}

</>

)}

</span>

</span>

{item.labels.map((name) => (

585

// Without the workspace's labels, a chip still names its label, in the plain color.

586

<LabelChip key={name} name={name} color={isFailed(labels) ? undefined : labels.find((label) => label.name === name)?.color} />

587

))}

588

{open && item.agent && <Assignee agent={item.agent} />}

</div>

</header>

{item.resolutions.length > 0 && (

594

595

{item.resolutions.map((landed, index) => (

596

597

<Link

598

to={landed.pull != null ? `/${landed.repo}/pull/${landed.pull}` : `/${landed.repo}/commit/${landed.commit ?? ""}`}

599

className="flex items-start gap-3 rounded-xl border border-merged/40 bg-merged/5 px-4 py-3 text-sm transition-colors hover:border-merged/70"

600

>

601

{landed.pull != null ? (

) : (

)}

Landed in <span className="font-mono font-medium">{landed.repo}</span> by{" "}

608

{landed.pull != null ? (

609

<span className="font-medium">#{landed.pull}</span>

610

) : (

611

<span className="font-mono font-medium">{landed.commit?.slice(0, 7)}</span>

612

)}

613

{landed.pushedBy && <span className="text-muted">, pushed by {landed.pushedBy}</span>}

</span>

</Link>

</li>

))}

</ul>

)}

{item.body ? (

<div className={`${item.resolutions.length > 0 ? "mt-5" : "lg:mt-5"} rounded-xl border border-line bg-surface p-4 sm:p-5`}>

</div>

) : (

(loaderData.reactions?.length ?? 0) > 0 && <Reactions reactions={loaderData.reactions} viewer={viewer?.username ?? null} className="mt-3 lg:mt-5" />

)}

Repositories

</h2>

{missing.length > 0 && open && (

637

638

{missing.length} {missing.length === 1 ? "target" : "targets"} still to land

</span>

)}

{canLink && (

<LinkRepository

workspace={workspace}

645

repos={loaderData.repos}

646

linked={item.repos.map((repo) => repo.path.toLowerCase())}

error={linkError}

/>

</span>

)}

</span>

</div>

{isFailed(loaderData.coordination) && (

</div>

)}

{repoRows.length === 0 ? (

659

660

661

Filed in the workspace itself. Link the repositories it should land in, and it closes once each of them has.

</EmptyState>

</div>

) : (

<ul>

{repoRows.map(({ repo, pulls: repoPulls }) => (

))}

</ul>

</Card>

)}

{suggestions.length > 0 && open && (

674

<>

675

<h3 className="mt-5 text-sm font-medium">Suggested</h3>

676

<p className="mt-0.5 text-xs text-muted">Repositories it may also need, and why.</p>

677

678

<ul>

679

{suggestions.map((suggestion) => (

))}

</ul>

</Card>

</>

)}

{linkError && (

<ErrorText>{linkError}</ErrorText>

</div>

)}

</section>

{pulls.length === 0 && open && (

694

695

696

Point your own agent at <code className="font-mono">{reference}</code>.

</EmptyState>

</div>

)}

{failure && (

)}

{isFailed(loaderData.coordination) ? (

706

<>

707

<h2 className="mt-10 font-semibold tracking-tight">Decisions</h2>

</div>

</>

) : (

decisions.length > 0 && (

714

<>

715

716

<h2 className="font-semibold tracking-tight">Decisions</h2>

</div>

</div>

</>

)

)}

<h2 className="mt-10 font-semibold tracking-tight">Discussion</h2>

727

728

729

{isFailed(loaderData.sessionTrees) && <Unavailable what="Its sessions" compact />}

730

<CommentList

731

comments={comments}

732

workspace={workspace}

733

viewerId={viewer?.id ?? null}

734

viewerName={viewer?.username ?? null}

735

extra={(sessionTrees ?? [])

736

.filter((session) => !session.parentId)

737

.map((session) => ({ id: session.id, at: session.startedAt, node: <TimelineSession session={session} base={sessionBase(session)} /> }))}

738

canModerate={loaderData.canModerate}

739

failed={actionData && "comment" in actionData ? { comment: String(actionData.comment), error: actionData.error } : null}

/>

</div>

{canManage && (

{open ? (

<>

Close as not planned

</SubmitButton>

Close work item

</SubmitButton>

</>

) : (

Reopen work item

</SubmitButton>

)}

</Form>

)}

</div>

</div>

{/* A refused comment edit says so under the comment; the sidebar's own say so there. */}

766

{!(actionData && ("comment" in actionData || sideError)) && <ErrorText>{actionData && "error" in actionData ? actionData.error : null}</ErrorText>}

767

</div>

768

769

{/* On a phone, its main actions at the bottom, above the tab bar and clear of the keyboard. */}

770

{(canManage || canLink) && (

{canLink && (

<LinkRepository workspace={workspace} repos={loaderData.repos} linked={item.repos.map((repo) => repo.path.toLowerCase())} error={null} wide />

</div>

)}

{canManage && (

{open ? (

Close

</SubmitButton>

) : (

Reopen

</SubmitButton>

)}

</Form>

)}

</div>

)}

</div>

<DetailsDisclosure

className="max-lg:order-2 lg:col-start-2 lg:row-span-2 lg:row-start-1"

796

summary={detailsSummary([

797

[coordination?.claims.length ?? 0, "claim", "claims"],

798

[item.assignees.length, "assignee", "assignees"],

799

[item.labels.length, "label", "labels"],

800

[item.milestone ? 1 : 0, "milestone", "milestones"],

801

])}

802

>

803

{isFailed(loaderData.coordination) ? (

</div>

</section>

) : (

coordination && (

<ItemWorkPanel

work={coordination}

ended={loaderData.endedClaims}

base={sessionBase}

now={now}

canEdit={canManage}

error={actionData && "action" in actionData && actionData.action === "blocked-by" ? actionData.error : null}

820

sessions={sessionTrees}

821

start={

822

loaderData.agentSetup && open && workIn ? (

823

<StartSessionDialog

824

setup={loaderData.agentSetup}

825

repo={workIn}

826

error={actionData && "action" in actionData && actionData.action === "start-session" ? actionData.error : null}

/>

) : undefined

}

/>

</Boundary>

)

)}

{isFailed(loaderData.links) ? (

835

836

<h3 className="text-sm font-medium">From outside g1t</h3>

</div>

</section>

) : (

loaderData.links.length > 0 && (

843

844

<h3 className="text-sm font-medium">From outside g1t</h3>

845

846

{loaderData.links.map((link) => (

<a

href={link.url}

target="_blank"

rel="noreferrer"

className="group flex items-center gap-2 rounded-lg border border-line px-2.5 py-2 transition-colors hover:border-line-strong"

>

{PROVIDERS[link.provider].label} <span className="font-mono text-muted">{link.key}</span>

857

</span>

858

859

{link.count > 1 ? `Seen ${link.count} times, last ` : "Linked "}

860

<TimeAgo at={link.count > 1 ? link.lastSeen : link.firstSeen} />

</span>

</span>

</a>

</li>

))}

</ul>

</section>

)

)}

<h3 className="text-sm font-medium">Assignees</h3>

873

874

{item.assignees.map((name) => (

</li>

))}

{item.assignees.length === 0 && <li className="px-1 text-xs text-faint">Nobody yet</li>}

881

</ul>

882

{!coordination && item.blockedBy.length > 0 && (

883

884

Depends on{" "}

885

{item.blockedBy.map((number, index) => (

{index > 0 && ", "}

#{number}

</Link>

</span>

))}

{open ? ", which has to land first." : "."}

894

</p>

895

)}

896

{viewer && can.triage && open && (

897

898

{/* g1t takes it on in a session on the workspace's Claude, as whoever assigned it. */}

899

{loaderData.agentSetup && !item.assignees.includes("g1t") && (

900

901

902

{item.assignees.map((name) => (

))}

Assign to g1t

</SubmitButton>

</div>

</Form>

)}

{!item.assignees.includes(viewer.username) && (

915

916

917

{item.assignees.map((name) => (

))}

Assign yourself

</SubmitButton>

</div>

</Form>

)}

<summary className="cursor-pointer text-xs text-faint hover:text-fg">Assign people</summary>

930

931

932

{/* Without the workspace's people the picker still holds who is

933

assigned now, so saving never clears them. */}

934

{isFailed(members) && <Unavailable what="The workspace's people" compact />}

Save assignees

</SubmitButton>

</Form>

</details>

</div>

)}

</section>

{/* Another way to start the work: not once a pull request is doing it. */}

946

{open && !pulls.some((pull) => pull.status === "open" || pull.status === "draft") && (

947

948

949

<h3 className="text-sm font-medium">Bring your own agent</h3>

950

<p className="mt-1 text-xs text-muted">With g1t connected to your agent, ask it to work on this work item.</p>

</div>

{viewer && openable.length > 0 ? (

955

956

957

<p className="text-xs text-muted">Or open a draft pull request yourself and get a fork to push to.</p>

958

<SelectField

959

name="repo"

960

aria-label="Repository"

961

defaultValue={openable.some((repo) => repo.path === workIn) ? workIn! : openable[0]!.path}

962

options={openable.map((repo) => ({ value: repo.path, label: `${repo.path} (${ROLE_LABELS[repo.role].toLowerCase()})` }))}

/>

Open pull request

</SubmitButton>

</div>

{actionData && "action" in actionData && actionData.action === "open-pull" && <ErrorText>{actionData.error}</ErrorText>}

971

{workIn && (

972

973

Already pushed a branch?{" "}

974

975

Open a pull request from it

</Link>

.

</p>

)}

</Form>

) : (

!viewer && (

Sign in

</Link>{" "}

to open a pull request.

</p>

)

)}

</section>

</Card>

)}

{isFailed(labels) ? (

) : (

<LabelsBox

labels={labels}

chosen={item.labels}

canEdit={canManage}

canCreate={can.manage_labels}

1003

manageUrl={can.manage_labels ? workPath(workspace, "labels") : undefined}

1004

/>

1005

)}

1006

{isFailed(loaderData.milestones) ? (

) : (

)}

{viewer &&

(isFailed(loaderData.subscription) ? (

) : (

))}

</DetailsDisclosure>

</div>

</AttachImages>

);

}

/** A sidebar section, under its usual heading, that could not be loaded. */

1024

function SideUnavailable({ heading, what }: { heading: string; what: string }) {

1025

return (

1026

1027

<h3 className="text-sm font-medium">{heading}</h3>

</div>

</section>

);

}