@andrioid/paseo-attention-span 0.0.0-stage → 0.1.1

package/server/fixture.ts

@@ -0,0 +1,220 @@
+import type { AgentSummary, ItemDetails, Target } from "../shared/attention";
+import type { Actor, Comment, Details, IssueNode, MentionNode, PickableNode, PullRequestNode, SearchResult } from "./github-types";
+
+// Made-up GitHub data for tests and for previews without GitHub (PASEO_ATTENTION_SPAN_FIXTURE=1).
+
+export const REPO = "acme/shop";
+// Issues kept apart from the code, as some orgs do; its code lives in REPO [SES-07].
+export const ISSUES_REPO = "acme/issues";
+// What the settings screen can add in previews [SRC-02]; anything else isn't found.
+export const FIXTURE_ORGS = ["acme"];
+export const FIXTURE_REPOS = [REPO, ISSUES_REPO, "acme/web"];
+const repository = { nameWithOwner: REPO, squashMergeAllowed: true, defaultBranchRef: { name: "main" } };
+const avatar = (id: number) => `https://avatars.githubusercontent.com/u/${id}?v=4`;
+
+export const me: Actor = { __typename: "User", login: "me" };
+export const alice: Actor = { __typename: "User", login: "alice", avatarUrl: avatar(1) };
+export const bob: Actor = { __typename: "User", login: "bob", avatarUrl: avatar(2) };
+export const bot: Actor = { __typename: "Bot", login: "reviewbot" };
+
+export function builders(now: Date) {
+  const daysAgo = (days: number) => new Date(now.getTime() - days * 86_400_000).toISOString();
+  const commit = (ci: string | null, days = 1) => ({ nodes: [{ commit: { committedDate: daysAgo(days), statusCheckRollup: ci ? { state: ci } : null } }] });
+  const thread = (author: Actor, days: number, isResolved = false) => ({ isResolved, comments: { nodes: [comment(author, "", days)] } });
+  let comments = 0;
+
+  function pr(number: number, overrides: Partial<PullRequestNode> = {}, ci: string | null = "SUCCESS"): PullRequestNode {
+    return {
+      id: `PR_${number}`,
+      number,
+      title: `PR ${number}`,
+      url: `https://github.com/${REPO}/pull/${number}`,
+      isDraft: false,
+      createdAt: daysAgo(2),
+      updatedAt: daysAgo(1),
+      author: me,
+      repository,
+      baseRefName: "main",
+      headRefName: `branch-${number}`,
+      headRefOid: `oid${number}`,
+      mergeable: "MERGEABLE",
+      reviewDecision: "REVIEW_REQUIRED",
+      assignees: { nodes: [] },
+      closingIssuesReferences: { nodes: [] },
+      commits: commit(ci),
+      reviewRequests: { nodes: [] },
+      latestReviews: { nodes: [] },
+      reviewThreads: { nodes: [] },
+      comments: { nodes: [] },
+      ...overrides,
+    };
+  }
+
+  function comment(author: Actor, body: string, days: number, extra: Partial<Comment> = {}): Comment {
+    comments += 1;
+    return { id: `IC_${comments}`, author, body, createdAt: daysAgo(days), url: `https://github.com/${REPO}/issues/1#c${comments}`, reactionGroups: [], ...extra };
+  }
+
+  function mention(number: number, comments: Comment[], overrides: Partial<MentionNode> = {}): MentionNode {
+    return {
+      __typename: "Issue",
+      number,
+      title: `Issue ${number}`,
+      url: `https://github.com/${REPO}/issues/${number}`,
+      createdAt: daysAgo(5),
+      author: alice,
+      body: "no mention here",
+      repository,
+      comments: { nodes: comments },
+      ...overrides,
+    };
+  }
+
+  function issue(number: number, comments: Comment[] = [], title = `Issue ${number}`): IssueNode {
+    return { number, title, url: `https://github.com/${REPO}/issues/${number}`, repository, comments: { nodes: comments } };
+  }
+
+  function pickable(number: number, fields: Record<string, string>, createdDaysAgo = 10, type = "Bug", title = `Issue ${number}`, repo = REPO): PickableNode {
+    return {
+      number,
+      title,
+      url: `https://github.com/${repo}/issues/${number}`,
+      createdAt: daysAgo(createdDaysAgo),
+      repository: repo === REPO ? repository : { nameWithOwner: repo, defaultBranchRef: { name: "main" } },
+      issueType: { name: type },
+      issueFieldValues: { nodes: Object.entries(fields).map(([field, name]) => ({ name, field: { name: field } })) },
+    };
+  }
+
+  function search(parts: Partial<{ [K in Exclude<keyof SearchResult, "viewer">]: SearchResult[K]["nodes"] }>): SearchResult {
+    const nodes = <K extends keyof typeof parts>(key: K) => ({ nodes: parts[key] ?? [] });
+    return {
+      viewer: { login: "me", id: "U_me" },
+      mine: nodes("mine") as SearchResult["mine"],
+      reviews: nodes("reviews") as SearchResult["reviews"],
+      mentions: nodes("mentions") as SearchResult["mentions"],
+      commented: nodes("commented") as SearchResult["commented"],
+      assigned: nodes("assigned") as SearchResult["assigned"],
+      unclaimed: nodes("unclaimed") as SearchResult["unclaimed"],
+      merged: nodes("merged") as SearchResult["merged"],
+      reviewed: nodes("reviewed") as SearchResult["reviewed"],
+      closed: nodes("closed") as SearchResult["closed"],
+    };
+  }
+
+  return { daysAgo, commit, thread, pr, comment, mention, issue, pickable, search };
+}
+
+// One of everything the screen can show.
+export function fixture(now: Date): { data: SearchResult; details: Details } {
+  const { daysAgo, commit, thread, pr, comment, mention, issue, pickable, search } = builders(now);
+  const key = (n: number) => `${REPO}#${n}`;
+  const closes = (number: number, title: string) => ({ nodes: [{ number, title, url: `https://github.com/${REPO}/issues/${number}`, repository }] });
+  const fields = (priority: string, effort: string, scope: string) => ({ Priority: priority, Effort: effort, Scope: scope });
+  const merged = (number: number, title: string, days: number, closesIssue?: number) => ({
+    number,
+    title,
+    url: `https://github.com/${REPO}/pull/${number}`,
+    mergedAt: daysAgo(days),
+    repository,
+    closingIssuesReferences: { nodes: closesIssue ? [{ number: closesIssue, repository }] : [] },
+  });
+  const closed = (number: number, title: string, days: number, stateReason = "COMPLETED") => ({
+    number,
+    title,
+    url: `https://github.com/${REPO}/issues/${number}`,
+    closedAt: daysAgo(days),
+    stateReason,
+    repository,
+  });
+
+  const data = search({
+    mine: [
+      pr(101, { title: "Show delivery dates on the order page" }, "FAILURE"),
+      pr(102, { title: "Retry webhook deliveries with backoff", reviewThreads: { nodes: [thread(alice, 1), thread(bot, 2)] } }),
+      pr(103, { title: "Fetch supplier price files nightly", reviewDecision: "APPROVED", closingIssuesReferences: closes(90, "Supplier prices are a week out of date") }),
+      pr(104, { title: "Move price-file login into a service", isDraft: true, baseRefName: "branch-103", headRefName: "branch-104" }),
+      pr(105, { title: "Dialog focus returns to the trigger", reviewDecision: "APPROVED", headRefName: "a11y-1" }),
+      pr(106, { title: "Keyboard navigation for calendar cards", isDraft: true, baseRefName: "a11y-1", headRefName: "a11y-2", reviewDecision: "APPROVED" }),
+      pr(107, { title: "Calendar: jump between weeks with keys", isDraft: true, baseRefName: "a11y-2", headRefName: "a11y-3" }, "FAILURE"),
+      pr(108, { title: "Company-scoped database layer", mergeable: "CONFLICTING" }),
+      pr(109, { title: "Store uploads locally in development", commits: commit("SUCCESS", 6) }),
+      pr(110, { title: "requirements.yaml for the shop", isDraft: true, updatedAt: daysAgo(64) }),
+      pr(111, { title: "Faster product search", reviewRequests: { nodes: [{ requestedReviewer: bob }] }, commits: commit("SUCCESS", 0.3) }),
+      pr(112, { title: "Translate the checkout emails", reviewDecision: "CHANGES_REQUESTED", latestReviews: { nodes: [{ author: alice, state: "CHANGES_REQUESTED", submittedAt: daysAgo(2) }] }, commits: commit("SUCCESS", 1) }),
+      pr(113, { title: "Upgrade the payment SDK" }, "PENDING"),
+      pr(114, { title: "Cache exchange rates daily", reviewDecision: "APPROVED" }),
+      pr(115, { title: "Split the settings page into tabs", isDraft: true, mergeable: "CONFLICTING" }),
+      pr(116, { title: "Try a faster PDF renderer", isDraft: true }, "FAILURE"),
+      pr(117, { title: "Harden the upload endpoint", reviewThreads: { nodes: [thread(bot, 1)] } }),
+      pr(118, { title: "Send reminders for unpaid invoices", closingIssuesReferences: closes(95, "Customers forget unpaid invoices") }),
+      pr(119, { title: "Show stock levels on product cards", isDraft: true }),
+      pr(122, { title: "Round VAT per line, not per invoice", reviewDecision: "APPROVED", repository: { ...repository, autoMergeAllowed: true } }, "PENDING"),
+      pr(123, { title: "Archive offers older than a year", reviewDecision: "APPROVED", autoMergeRequest: { enabledAt: daysAgo(0.1) } }, "PENDING"),
+    ],
+    reviews: [pr(120, { title: "Add a status page", author: bob }), pr(121, { title: "Rework the cart totals", author: alice })],
+    mentions: [
+      mention(95, [comment(bob, "@me should reminders go out on weekends too, or only on workdays?", 0.5)], { title: "Customers forget unpaid invoices", author: bob }),
+      mention(121, [comment(alice, "@me could you look at the rounding in `totals.ts` first? That's the **risky** part.", 0.2)], { __typename: "PullRequest", title: "Rework the cart totals" }),
+      mention(
+        130,
+        [
+          comment(alice, "Can we make it easy to get in touch? @me do you see anything harmful here?", 3),
+          comment(
+            bob,
+            "@me also, should the contact be the shared `security@` inbox or a person? I'd rather not put a personal address in a public file.\n\n- shared inbox: nobody owns it\n- a person: leaves with them\n\nSee [RFC 9116](https://www.rfc-editor.org/rfc/rfc9116).",
+            2,
+          ),
+        ],
+        { __typename: "PullRequest", title: "Publish security.txt" },
+      ),
+      mention(131, [], {
+        __typename: "PullRequest",
+        title: "Close two privilege escalations",
+        reviewThreads: { nodes: [{ isResolved: false, comments: { nodes: [comment(bot, "@me this endpoint leaks the API key in its response", 1)] } }] },
+      }),
+    ],
+    commented: [issue(140, [comment(alice, "", 9), comment(me, "Which customers see this?", 1)], "Invoice totals round wrong"), issue(141, [comment(me, "Is this still needed?", 12)], "Rotate the analytics token")],
+    assigned: [
+      pickable(150, fields("🏔 P1 High", "🐇 Small (0.5-2d)", "🔙 Backend"), 20, "Bug", "Orders export times out for big shops"),
+      pickable(151, fields("🏕P2 Medium", "🐟 Tiny (< 4h)", "🔙 Backend"), 5, "Bug", "Price list import skips quoted rows", ISSUES_REPO),
+    ],
+    unclaimed: [
+      pickable(160, fields("🏕P2 Medium", "🐂 Medium (2-5d)", "🕵 Full-stack"), 40, "Feature", "Follow-up emails for unanswered offers"),
+      pickable(161, fields("🏝 P3 Low", "🐟 Tiny (< 4h)", "🔙 Backend"), 15, "Bug", "Deleted employee still shows in the calendar"),
+      pickable(162, fields("🏝 P3 Low", "🐇 Small (0.5-2d)", "🔙 Backend"), 30, "Debt", "Merge the two import commands"),
+      pickable(163, fields("🏝 P3 Low", "🐇 Small (0.5-2d)", "🖌 Frontend"), 8, "Bug", "Moving a task in the calendar loses its colour"),
+      pickable(164, fields("🏝 P3 Low", "🦑 Large (1-2w)", "📱 Mobile app"), 60, "Feature", "Offline mode for time tracking"),
+      pickable(165, {}, 3, "Task", "Devcontainers for pull requests"),
+    ],
+    merged: [merged(170, "Nightly backup check", 1, 171), merged(172, "Fix VAT on credit notes", 3), merged(173, "Speed up the order list", 9, 174), merged(175, "Remove the old importer", 16)],
+    reviewed: [
+      { number: 180, title: "New onboarding checklist", url: `https://github.com/${REPO}/pull/180`, mergedAt: daysAgo(2), repository, author: alice },
+      { number: 181, title: "Bump dependencies", url: `https://github.com/${REPO}/pull/181`, mergedAt: daysAgo(4), repository, author: bob },
+      { number: 182, title: "Sentry release tracking", url: `https://github.com/${REPO}/pull/182`, mergedAt: daysAgo(11), repository, author: alice },
+    ],
+    closed: [closed(171, "Backups are never verified", 1), closed(174, "Order list takes 8 seconds", 9), closed(176, "Dark mode for the admin", 10, "NOT_PLANNED")],
+  });
+  return { data, details: { behind: { [key(103)]: 1, [key(106)]: 12, [key(108)]: 139, [key(110)]: 2307, [key(114)]: 3, [key(115)]: 40 }, fieldOptions: { Priority: ["🌋 P0 Urgent", "🏔 P1 High", "🏕P2 Medium", "🏝 P3 Low"] } } };
+}
+
+// Sessions the preview shows as started from items: working, needs me, failed, idle.
+const agent = (id: string, status: string, requiresAttention = false): AgentSummary => ({ id, status, requiresAttention, title: `Fixture session ${id}`, workspaceId: null });
+export const FIXTURE_AGENTS: Record<string, AgentSummary> = {
+  [`${REPO}#101`]: agent("agent-101", "running"),
+  [`${REPO}#102`]: agent("agent-102", "idle", true),
+  [`${REPO}#108`]: agent("agent-108", "error"),
+  [`${REPO}#150`]: agent("agent-150", "idle"),
+};
+
+export const FIXTURE_CONTEXT = "Context from GitHub would go here (fixture mode).";
+
+// What a sheet shows, made up: a size, the linked issue, and failing checks for Rerun.
+export function fixtureDetails(subject: { kind: "pr" | "issue"; repo: string; number: number }, target: Target | undefined, checks: boolean): ItemDetails {
+  const pr = target?.kind === "pr" ? target : undefined;
+  return {
+    size: pr ? { additions: 84 + (pr.number % 7) * 13, deletions: 12 + (pr.number % 5), files: 2 + (pr.number % 4) } : undefined,
+    linked: subject.number === 120 ? [{ number: 200, title: "Customers can't tell when the shop is down", url: `https://github.com/${REPO}/issues/200`, state: "OPEN" }] : [],
+    failing: checks && pr ? [{ pr: pr.number, checks: [{ name: "lint", rerunnable: true }, { name: "e2e (chromium)", rerunnable: true }], runs: [{ id: 9001, attempt: 1 }] }] : [],
+  };
+}

package/server/gh.ts

@@ -0,0 +1,36 @@
+import { spawn } from "node:child_process";
+
+// Everything goes through the host's existing gh login; no token is stored [SEC-01].
+
+// Previews run on made-up data and never reach GitHub.
+export const FIXTURE = process.env.PASEO_ATTENTION_SPAN_FIXTURE === "1";
+
+export function runGh(args: string[], input?: string): Promise<{ code: number; stdout: string; stderr: string }> {
+  if (FIXTURE) return Promise.reject(new Error("GitHub is off in fixture mode."));
+  return new Promise((resolve, reject) => {
+    const child = spawn("gh", args, { stdio: ["pipe", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => (stdout += chunk));
+    child.stderr.on("data", (chunk) => (stderr += chunk));
+    child.on("error", (error: NodeJS.ErrnoException) =>
+      reject(error.code === "ENOENT" ? new Error("The GitHub CLI (gh) isn't on the daemon's PATH.") : error),
+    );
+    child.on("close", (code) => resolve({ code: code ?? 1, stdout, stderr }));
+    child.stdin.end(input ?? "");
+  });
+}
+
+// Partial errors (e.g. a deleted branch in a compare) still return the data that resolved.
+export async function graphql<T>(query: string, variables: Record<string, unknown> = {}): Promise<T> {
+  const { code, stdout, stderr } = await runGh(["api", "graphql", "--input", "-"], JSON.stringify({ query, variables }));
+  let parsed: { data?: T; errors?: { message: string }[] } | undefined;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    // Not JSON: an auth or network failure.
+  }
+  if (parsed?.data) return parsed.data;
+  const message = parsed?.errors?.map((error) => error.message).join("; ") || stderr.trim() || `gh exited with ${code}`;
+  throw new Error(message);
+}

package/server/github-types.ts

@@ -0,0 +1,114 @@
+// Shapes returned by the queries in queries.ts.
+
+type Nodes<T> = { nodes: T[] };
+type Repo = { nameWithOwner: string; defaultBranchRef?: { name: string } | null };
+
+export interface Actor {
+  __typename?: string; // "User", "Bot", ...
+  login: string;
+  avatarUrl?: string;
+}
+
+export interface Comment {
+  id?: string;
+  author: Actor | null;
+  body?: string;
+  createdAt: string;
+  url?: string;
+  reactionGroups?: { viewerHasReacted: boolean }[];
+}
+
+export interface ReviewThread {
+  isResolved: boolean;
+  opener?: Nodes<Comment>;
+  comments: Nodes<Comment>;
+}
+
+export interface PullRequestNode {
+  id: string;
+  number: number;
+  title: string;
+  url: string;
+  isDraft: boolean;
+  createdAt: string;
+  updatedAt: string;
+  author: Actor | null;
+  repository: Repo & { squashMergeAllowed?: boolean; mergeCommitAllowed?: boolean; autoMergeAllowed?: boolean };
+  baseRefName: string;
+  headRefName: string;
+  headRefOid: string;
+  isCrossRepository?: boolean;
+  mergeable: "MERGEABLE" | "CONFLICTING" | "UNKNOWN";
+  reviewDecision: "APPROVED" | "CHANGES_REQUESTED" | "REVIEW_REQUIRED" | null;
+  autoMergeRequest?: { enabledAt: string } | null;
+  assignees: Nodes<{ login: string }>;
+  closingIssuesReferences: Nodes<{ number: number; title: string; url: string; repository: Repo }>;
+  commits: Nodes<{ commit: { committedDate: string; statusCheckRollup: { state: string } | null } }>;
+  reviewRequests: Nodes<{ requestedReviewer: Actor | null }>;
+  latestReviews: Nodes<{ author: Actor | null; state: string; submittedAt: string | null }>;
+  reviewThreads: Nodes<ReviewThread>;
+  comments: Nodes<Comment>;
+}
+
+// A search hit from mentions:@me, with bodies for finding the mention.
+export interface MentionNode {
+  __typename: "Issue" | "PullRequest";
+  id?: string;
+  reactionGroups?: { viewerHasReacted: boolean }[];
+  number: number;
+  title: string;
+  url: string;
+  createdAt: string;
+  author: Actor | null;
+  body: string;
+  repository: Repo;
+  comments: Nodes<Comment>;
+  reviews?: Nodes<{ author: Actor | null; submittedAt: string | null }>;
+  reviewThreads?: Nodes<ReviewThread>;
+}
+
+export interface IssueNode {
+  number: number;
+  title: string;
+  url: string;
+  repository: Repo;
+  comments: Nodes<Comment>;
+}
+
+export interface PickableNode {
+  number: number;
+  title: string;
+  url: string;
+  createdAt: string;
+  repository: Repo;
+  issueType: { name: string } | null;
+  issueFieldValues: Nodes<{ name?: string; field?: { name: string } }>;
+}
+
+// One request per search, merged [GH-01].
+export interface LiveResult {
+  viewer: { login: string; id: string };
+  mine: Nodes<PullRequestNode>;
+  reviews: Nodes<PullRequestNode>;
+  mentions: Nodes<MentionNode>;
+  commented: Nodes<IssueNode>;
+  assigned: Nodes<PickableNode>;
+  unclaimed: Nodes<PickableNode>;
+}
+
+// One request for all three [HIS-01, HIS-02].
+export interface HistoryResult {
+  merged: Nodes<{ number: number; title: string; url: string; mergedAt: string; repository: Repo; closingIssuesReferences: Nodes<{ number: number; repository: Repo }> }>;
+  reviewed: Nodes<{ number: number; title: string; url: string; mergedAt: string; repository: Repo; author: Actor | null }>;
+  closed: Nodes<{ number: number; title: string; url: string; closedAt: string; stateReason: string | null; repository: Repo }>;
+}
+
+export type SearchResult = LiveResult & HistoryResult;
+
+// From the request after my PRs and Next up's issues.
+export interface Details {
+  // "owner/name#number" -> commits the head is behind its base.
+  behind: Record<string, number>;
+  // Issue field name -> its options in order.
+  fieldOptions: Record<string, string[]>;
+}

package/server/markdown.ts

@@ -0,0 +1,73 @@
+// GitHub Markdown for the screen: whole comments to render in the 👍 picker, and plain text for quotes cut anywhere.
+
+const FENCE = /^\s*(```|~~~)/;
+
+// Markdown cut after whole blocks only, so a cut never breaks a link or code block [MEN-07].
+// HTML comments (PR templates) and images go; other HTML tags, like <details>, keep only their text.
+export function excerpt(body: string | undefined, max = 600): string | null {
+  const blocks = markdownBlocks(
+    (body ?? "")
+      .replace(/\r/g, "")
+      .replace(/<!--[\s\S]*?-->/g, "")
+      .replace(/!\[[^\]]*\]\([^)]*\)/g, ""),
+  );
+  if (blocks.length === 0) return null;
+  const kept: string[] = [];
+  let length = 0;
+  for (const block of blocks) {
+    if (length + block.length > max) return kept.length ? `${kept.join("\n\n")}\n\n…` : cutBlock(block, max);
+    kept.push(block);
+    length += block.length;
+  }
+  return kept.join("\n\n");
+}
+
+// Paragraphs, lists and code blocks, split at blank lines outside code; HTML tags stripped outside code.
+function markdownBlocks(text: string): string[] {
+  const blocks: string[] = [];
+  let lines: string[] = [];
+  let inCode = false;
+  const end = () => {
+    const block = lines.join("\n").trim();
+    if (block) blocks.push(block);
+    lines = [];
+  };
+  for (const line of text.split("\n")) {
+    if (FENCE.test(line)) inCode = !inCode;
+    else if (!inCode && !line.trim()) {
+      end();
+      continue;
+    }
+    lines.push(inCode || FENCE.test(line) ? line : line.replace(/<\/?[a-zA-Z][^>]*>/g, ""));
+  }
+  end();
+  return blocks;
+}
+
+// A first block too long on its own: cut at a line, else a word, and close an open code block.
+function cutBlock(block: string, max: number): string {
+  const cut = block.slice(0, max);
+  const at = cut.lastIndexOf("\n") > max / 2 ? cut.lastIndexOf("\n") : Math.max(cut.lastIndexOf(" "), max - 40);
+  const kept = cut.slice(0, at).trimEnd();
+  return FENCE.test(kept) ? `${kept}\n\`\`\`\n\n…` : `${kept}…`;
+}
+
+// Markdown as plain text, for quotes cut mid-sentence where rendering would break [ATT-05].
+// Links keep their text, emphasis and code lose their marks, quoted replies and HTML go.
+export function plainText(markdown: string): string {
+  return markdown
+    .replace(/\r/g, "")
+    .replace(/<!--[\s\S]*?-->/g, "")
+    .replace(/^[ \t]*>.*$/gm, "")
+    .replace(/^[ \t]*(```|~~~).*$/gm, "")
+    .replace(/!\[[^\]]*\]\([^)]*\)/g, "")
+    .replace(/\[([^\]]*)\]\([^)]*\)/g, "$1")
+    .replace(/<(https?:\/\/[^>\s]+)>/g, "$1")
+    .replace(/<\/?[a-zA-Z][^>]*>/g, "")
+    .replace(/`([^`]*)`/g, "$1")
+    .replace(/(\*\*|__)(?=\S)([\s\S]*?\S)\1/g, "$2")
+    .replace(/~~(?=\S)([\s\S]*?\S)~~/g, "$1")
+    .replace(/(^|[^\w*])\*(?=\S)([^*\n]*?\S)\*(?![\w*])/g, "$1$2")
+    .replace(/^[ \t]*#{1,6}[ \t]+/gm, "")
+    .replace(/^[ \t]*(?:[-*+]|\d+[.)])[ \t]+(?:\[[ xX]\][ \t]+)?/gm, "");
+}

package/server/queries.ts

@@ -0,0 +1,152 @@
+import type { UnclaimedSource } from "../shared/attention";
+import type { AttentionConfig } from "../shared/config";
+import type { PullRequestNode } from "./github-types";
+
+// Each search with how many results it asks for and what it reads of each.
+const SEARCHES = {
+  mine: { first: 50, nodes: "...pr" },
+  reviews: { first: 30, nodes: "...pr" },
+  mentions: {
+    first: 30,
+    nodes: `__typename
+      ... on Issue { id number title url createdAt body author { ...author } reactionGroups { viewerHasReacted } repository { nameWithOwner } comments(last: 30) { nodes { ...comment } } }
+      ... on PullRequest {
+        id number title url createdAt body author { ...author } reactionGroups { viewerHasReacted } repository { nameWithOwner } comments(last: 30) { nodes { ...comment } }
+        reviews(last: 20) { nodes { author { login } submittedAt } }
+        reviewThreads(last: 30) { nodes { isResolved comments(first: 20) { nodes { ...comment } } } }
+      }`,
+  },
+  commented: { first: 30, nodes: "... on Issue { number title url repository { nameWithOwner } comments(last: 1) { nodes { author { login } createdAt } } }" },
+  assigned: { first: 50, nodes: "...pickable" },
+  unclaimed: { first: 100, nodes: "...pickable" },
+  merged: {
+    first: 100,
+    nodes: "... on PullRequest { number title url mergedAt repository { nameWithOwner } closingIssuesReferences(first: 3) { nodes { number repository { nameWithOwner } } } }",
+  },
+  reviewed: { first: 100, nodes: "... on PullRequest { number title url mergedAt repository { nameWithOwner } author { ...author } }" },
+  closed: { first: 100, nodes: "... on Issue { number title url closedAt stateReason repository { nameWithOwner } }" },
+};
+export type SearchName = keyof typeof SEARCHES;
+
+// Doing, Waiting and Next up. History has its own, slower schedule.
+export const LIVE_SEARCHES = ["mine", "reviews", "mentions", "commented", "assigned", "unclaimed"] as const;
+export const HISTORY_SEARCHES = ["merged", "reviewed", "closed"] as const;
+
+const FRAGMENTS: Record<string, string> = {
+  author: "fragment author on Actor { __typename login avatarUrl(size: 64) }",
+  comment: `fragment comment on Comment {
+  body createdAt
+  author { ...author }
+  ... on IssueComment { id url reactionGroups { viewerHasReacted } }
+  ... on PullRequestReviewComment { id url reactionGroups { viewerHasReacted } }
+}`,
+  pickable: `fragment pickable on Issue {
+  number title url createdAt
+  repository { nameWithOwner defaultBranchRef { name } }
+  issueType { name }
+  issueFieldValues(first: 20) { nodes { ... on IssueFieldSingleSelectValue { name field { ... on IssueFieldCommon { name } } } } }
+}`,
+  pr: `fragment pr on PullRequest {
+  id number title url isDraft createdAt updatedAt
+  author { ...author }
+  repository { nameWithOwner squashMergeAllowed mergeCommitAllowed autoMergeAllowed defaultBranchRef { name } }
+  baseRefName headRefName headRefOid isCrossRepository mergeable reviewDecision
+  autoMergeRequest { enabledAt }
+  assignees(first: 10) { nodes { login } }
+  closingIssuesReferences(first: 5) { nodes { number title url repository { nameWithOwner } } }
+  commits(last: 1) { nodes { commit { committedDate statusCheckRollup { state } } } }
+  reviewRequests(first: 5) { nodes { requestedReviewer { ... on User { ...author } } } }
+  latestReviews(first: 10) { nodes { author { ...author } state submittedAt } }
+  reviewThreads(last: 30) {
+    nodes {
+      isResolved
+      opener: comments(first: 1) { nodes { author { __typename login } } }
+      comments(last: 1) { nodes { author { login } createdAt } }
+    }
+  }
+  comments(last: 10) { nodes { author { login } createdAt } }
+}`,
+};
+
+// A query for some searches, as aliases named after them, with only the fragments they use; GitHub rejects unused ones.
+// GitHub runs the searches in one request one after another, so the live ones go out as separate requests in parallel [GH-01].
+export function searchQuery(names: readonly SearchName[], withViewer = false): string {
+  const fields = names.map((name) => `  ${name}: search(type: ISSUE, query: $${name}, first: ${SEARCHES[name].first}) {\n    nodes { ${SEARCHES[name].nodes} }\n  }`);
+  const used = new Set<string>();
+  const collect = (text: string) => {
+    for (const [, name] of text.matchAll(/\.\.\.(\w+)/g)) {
+      if (used.has(name)) continue;
+      used.add(name);
+      collect(FRAGMENTS[name]);
+    }
+  };
+  fields.forEach(collect);
+  const variables = names.map((name) => `$${name}: String!`).join(", ");
+  return `query Attention(${variables}) {\n${withViewer ? "  viewer { login id }\n" : ""}${fields.join("\n")}\n}\n${[...used].map((name) => FRAGMENTS[name]).join("\n")}`;
+}
+
+function where(orgs: string[], repos: string[]): string {
+  return [...orgs.map((org) => `org:${org}`), ...repos.map((repo) => `repo:${repo}`), "archived:false"].join(" ");
+}
+
+const isoDate = (date: Date) => date.toISOString().slice(0, 10);
+
+function startOfWeek(now: Date): Date {
+  const monday = new Date(now);
+  monday.setUTCHours(0, 0, 0, 0);
+  monday.setUTCDate(monday.getUTCDate() - ((monday.getUTCDay() + 6) % 7));
+  return monday;
+}
+
+// Where Next up looks for unclaimed issues: the chosen repos, else the configured orgs and repos, else my Paseo
+// projects' repos [NXT-04, NXT-08]. Never all of GitHub: unlike the other searches, this one isn't about me.
+export function unclaimedScope(config: AttentionConfig, projectRepos: string[]): { from: UnclaimedSource; scope: string | null } {
+  if (config.nextUp.repos) return { from: "config", scope: config.nextUp.repos.length ? where([], config.nextUp.repos) : null };
+  if (config.orgs.length || config.repos.length) return { from: "config", scope: where(config.orgs, config.repos) };
+  return projectRepos.length ? { from: "projects", scope: where([], projectRepos) } : { from: "none", scope: null };
+}
+
+// Null for a search with nowhere to look.
+export function searchVariables(config: AttentionConfig, now: Date, projectRepos: string[] = []): Record<SearchName, string | null> {
+  const scope = where(config.orgs, config.repos);
+  const unclaimed = unclaimedScope(config, projectRepos).scope;
+  const since = isoDate(new Date(now.getTime() - config.mentionDays * 86_400_000));
+  // Whole weeks, from a Monday, so the oldest week isn't cut short.
+  const history = isoDate(new Date(startOfWeek(now).getTime() - (config.historyWeeks - 1) * 7 * 86_400_000));
+  return {
+    mine: `is:pr is:open author:@me ${scope}`,
+    // By name only, not via a team [REV-01].
+    reviews: `is:pr is:open user-review-requested:@me ${scope}`,
+    mentions: `is:open mentions:@me updated:>=${since} ${scope}`,
+    assigned: `is:issue is:open assignee:@me ${scope}`,
+    commented: `is:issue is:open commenter:@me updated:>=${since} ${scope}`,
+    // [NXT-01, NXT-04, NXT-08]
+    unclaimed: unclaimed && `is:issue is:open no:assignee ${unclaimed}`,
+    // History [HIS-01, HIS-02]
+    merged: `is:pr is:merged author:@me merged:>=${history} ${scope}`,
+    reviewed: `is:pr is:merged reviewed-by:@me -author:@me merged:>=${history} ${scope}`,
+    closed: `is:issue is:closed assignee:@me closed:>=${history} ${scope}`,
+  };
+}
+
+export function prKey(node: { repository: { nameWithOwner: string }; number: number }): string {
+  return `${node.repository.nameWithOwner}#${node.number}`;
+}
+
+// After my PRs and Next up's issues: how far my PRs are behind their bases, and the option order of org issue fields [GH-01].
+export function detailsQuery(prs: PullRequestNode[], orgs: string[]): { query: string; compares: Record<string, string> } {
+  const compares: Record<string, string> = {};
+  const fields = prs.map((pr, index) => {
+    compares[`c${index}`] = prKey(pr);
+    const [owner, name] = pr.repository.nameWithOwner.split("/");
+    return `c${index}: repository(owner: ${JSON.stringify(owner)}, name: ${JSON.stringify(name)}) {
+      ref(qualifiedName: ${JSON.stringify(`refs/heads/${pr.baseRefName}`)}) { compare(headRef: ${JSON.stringify(pr.headRefName)}) { behindBy } }
+    }`;
+  });
+  orgs.forEach((org, index) =>
+    fields.push(`o${index}: organization(login: ${JSON.stringify(org)}) {
+      issueFields(first: 50) { nodes { ... on IssueFieldSingleSelect { name options { name } } } }
+    }`),
+  );
+  return { query: `query Details {\n${fields.join("\n")}\n}`, compares };
+}