patchrelay 0.35.12 → 0.35.14

package/dist/cli/watch/detail-rows.js

@@ -0,0 +1,590 @@
+import { buildStateHistory } from "./history-builder.js";
+import { buildTimelineRows } from "./timeline-presentation.js";
+import { planStepColor, planStepSymbol } from "./plan-helpers.js";
+import { progressBar } from "./format-utils.js";
+import { describePatchRelayFreshness } from "./freshness.js";
+import { hasDisplayPrBlocker, isRereviewNeeded, prChecksFact } from "./pr-status.js";
+import { renderRichTextLines, renderTextLines } from "./render-rich-text.js";
+const SESSION_DISPLAY = {
+    idle: { label: "idle", color: "blueBright" },
+    running: { label: "running", color: "cyan" },
+    waiting_input: { label: "needs input", color: "yellow" },
+    done: { label: "done", color: "green" },
+    failed: { label: "needs help", color: "red" },
+};
+const STAGE_DISPLAY = {
+    blocked: "blocked",
+    ready: "ready",
+    delegated: "delegated",
+    implementing: "implementing",
+    pr_open: "PR open",
+    changes_requested: "review changes",
+    repairing_ci: "repairing CI",
+    awaiting_queue: "waiting downstream",
+    repairing_queue: "repairing queue",
+    done: "merged",
+    failed: "failed",
+    escalated: "escalated",
+    awaiting_input: "needs input",
+};
+const RUN_LABELS = {
+    implementation: "implementation",
+    ci_repair: "ci repair",
+    review_fix: "review fix",
+    queue_repair: "queue repair",
+};
+const STATE_LABELS = {
+    delegated: "delegated",
+    implementing: "implementing",
+    pr_open: "pr open",
+    changes_requested: "changes requested",
+    repairing_ci: "repairing ci",
+    awaiting_queue: "awaiting queue",
+    repairing_queue: "repairing queue",
+    awaiting_input: "awaiting input",
+    escalated: "escalated",
+    done: "done",
+    failed: "failed",
+};
+export function buildDetailLines(input) {
+    const width = Math.max(20, input.width);
+    const lines = [];
+    const history = buildStateHistory(input.rawRuns, input.rawFeedEvents, input.issue.factoryState, input.activeRunId);
+    lines.push(...buildHeaderLines(input, width));
+    lines.push(blankLine("header-gap"));
+    if (input.detailTab === "timeline") {
+        lines.push(...buildPlanLines(input.plan, width));
+        if (input.plan?.length) {
+            lines.push(blankLine("plan-gap"));
+        }
+        lines.push(...buildTimelineLines(input.timeline, width));
+    }
+    else {
+        lines.push(...buildHistoryIntroLines(width));
+        lines.push(blankLine("history-intro-gap"));
+        lines.push(...buildHistoryLines(history, input.plan, input.activeRunId, width));
+    }
+    return trimTrailingBlankLines(lines);
+}
+function buildHeaderLines(input, width) {
+    const issue = input.issue;
+    const session = sessionDisplay(issue);
+    const stage = stageDisplay(issue);
+    const facts = buildFacts(issue, input.issueContext);
+    const meta = buildMeta(input.tokenUsage, input.diffSummary, input.issueContext);
+    const headerSegments = [
+        { text: issue.issueKey ?? issue.projectId, bold: true },
+        { text: "  " },
+        { text: session.label, color: session.color, bold: true },
+        { text: "  ", dimColor: true },
+        { text: stage, dimColor: true },
+    ];
+    if (facts.length > 0) {
+        headerSegments.push({ text: "  ", dimColor: true });
+        headerSegments.push({ text: facts.join(" · "), dimColor: true });
+    }
+    if (input.activeRunStartedAt) {
+        headerSegments.push({ text: "  ", dimColor: true });
+        headerSegments.push({ text: elapsedLabel(input.activeRunStartedAt), dimColor: true });
+    }
+    if (meta.length > 0) {
+        headerSegments.push({ text: "  ", dimColor: true });
+        headerSegments.push({ text: meta.join("  "), dimColor: true });
+    }
+    headerSegments.push({ text: "  ", dimColor: true });
+    headerSegments.push(...freshnessSegments(input.connected, input.lastServerMessageAt));
+    if (input.follow) {
+        headerSegments.push({ text: "  " });
+        headerSegments.push({ text: "live", color: "yellow", bold: true });
+    }
+    const lines = renderTextLines(segmentsToText(headerSegments), {
+        key: "detail-header",
+        width,
+    });
+    lines[0] = { key: lines[0].key, segments: headerSegments };
+    if (issue.title) {
+        lines.push(...renderTextLines(issue.title, {
+            key: "detail-title",
+            width,
+            style: { bold: true },
+        }));
+    }
+    const blocker = blockerText(issue, input.issueContext);
+    if (blocker) {
+        lines.push(...renderTextLines(blocker, {
+            key: "detail-blocker",
+            width,
+            style: { color: "yellow" },
+        }));
+    }
+    if (issue.statusNote && issue.statusNote !== blocker) {
+        lines.push(...renderRichTextLines(issue.statusNote, {
+            key: "detail-note",
+            width,
+            style: { dimColor: true },
+        }));
+    }
+    if (input.issueContext?.latestFailureSummary) {
+        const failurePrefix = input.issueContext.latestFailureSource === "queue_eviction" ? "Queue failure: " : "Latest failure: ";
+        const head = input.issueContext.latestFailureHeadSha ? ` @ ${input.issueContext.latestFailureHeadSha.slice(0, 8)}` : "";
+        lines.push(...renderTextLines(`${failurePrefix}${input.issueContext.latestFailureSummary}${head}`, {
+            key: "detail-failure",
+            width,
+            style: { color: input.issueContext.latestFailureSource === "queue_eviction" ? "yellow" : "red" },
+        }));
+    }
+    return lines;
+}
+function buildPlanLines(plan, width) {
+    if (!plan || plan.length === 0)
+        return [];
+    const completed = plan.filter((step) => step.status === "completed").length;
+    const lines = renderTextLines(`Plan  ${progressBar(completed, plan.length, 16)}  ${completed}/${plan.length}`, {
+        key: "detail-plan-header",
+        width,
+        style: { dimColor: true },
+    });
+    for (const [index, entry] of plan.entries()) {
+        lines.push({
+            key: `detail-plan-${index}`,
+            segments: [
+                { text: `[${planStepSymbol(entry.status)}]`, color: planStepColor(entry.status) },
+                { text: " " },
+                { text: entry.step },
+            ],
+        });
+    }
+    return lines;
+}
+function buildTimelineLines(entries, width) {
+    const rows = buildTimelineRows(entries);
+    if (rows.length === 0) {
+        return renderTextLines("No timeline events yet.", {
+            key: "timeline-empty",
+            width,
+            style: { dimColor: true },
+        });
+    }
+    const lines = [];
+    for (const row of rows) {
+        switch (row.kind) {
+            case "feed":
+                lines.push(...renderRichTextLines(`${feedGlyph(row.feed.status)} ${row.feed.summary}${row.repeatCount && row.repeatCount > 1 ? ` ×${row.repeatCount}` : ""}`, {
+                    key: row.id,
+                    width,
+                    style: { dimColor: true },
+                }));
+                break;
+            case "ci-checks":
+                lines.push(...renderTextLines(`● checks  ${row.ciChecks.checks.map((check) => `${check.status === "passed" ? "✓" : check.status === "failed" ? "✗" : "●"} ${check.name}`).join("  ")}`, {
+                    key: row.id,
+                    width,
+                    style: { color: row.ciChecks.overall === "failed" ? "red" : row.ciChecks.overall === "passed" ? "green" : "yellow", bold: true },
+                }));
+                break;
+            case "item":
+                lines.push(...renderTimelineItemLines(row.id, row.item, width, 0));
+                break;
+            case "run":
+                lines.push(...buildTimelineRunLines(row.id, row.run, row.items.map((item) => item.item), row.details, width));
+                break;
+        }
+        lines.push(blankLine(`${row.id}-gap`));
+    }
+    return trimTrailingBlankLines(lines);
+}
+function buildTimelineRunLines(key, run, items, details, width) {
+    const statusColor = run.status === "completed" ? "green" : run.status === "failed" ? "red" : run.status === "running" ? "yellow" : "white";
+    const headerText = `● ${RUN_LABELS[run.runType] ?? run.runType}  ${run.status}${run.endedAt ? `  ${formatDuration(run.startedAt, run.endedAt)}` : ""}`;
+    const lines = renderTextLines(headerText, {
+        key: `${key}-header`,
+        width,
+        style: { color: statusColor, bold: true },
+    });
+    const showVerboseItems = run.status === "running";
+    if (showVerboseItems) {
+        for (const item of items) {
+            lines.push(...renderTimelineItemLines(`${key}-${item.id}`, item, width, 2));
+        }
+        return lines;
+    }
+    for (const [index, detail] of details.entries()) {
+        if (detail.tone === "message" || detail.tone === "user") {
+            lines.push(...renderRichTextLines(detail.tone === "user" ? `you: ${detail.text}` : detail.text, {
+                key: `${key}-detail-${index}`,
+                width,
+                firstPrefix: [{ text: "  " }],
+                continuationPrefix: [{ text: "  " }],
+                style: { color: detail.tone === "user" ? "yellow" : undefined },
+            }));
+            continue;
+        }
+        lines.push(...renderTextLines(`${detail.tone === "command" ? "$ " : ""}${detail.text}`, {
+            key: `${key}-detail-${index}`,
+            width,
+            firstPrefix: [{ text: "  " }],
+            continuationPrefix: [{ text: "  " }],
+            style: detail.tone === "command" ? { color: "white" } : { dimColor: true },
+        }));
+    }
+    return lines;
+}
+function renderTimelineItemLines(key, item, width, indent) {
+    const prefix = [{ text: " ".repeat(indent) }];
+    if (item.type === "agentMessage" || item.type === "userMessage" || item.type === "plan" || item.type === "reasoning") {
+        return renderRichTextLines(item.type === "userMessage" ? `you: ${item.text ?? ""}` : item.text ?? "", {
+            key,
+            width,
+            firstPrefix: prefix,
+            continuationPrefix: prefix,
+            style: item.type === "userMessage" ? { color: "yellow" } : undefined,
+        });
+    }
+    const summary = itemSummary(item);
+    const lines = renderTextLines(summary, {
+        key,
+        width,
+        firstPrefix: prefix,
+        continuationPrefix: prefix,
+        style: item.status === "failed" || item.status === "declined"
+            ? { color: "red" }
+            : item.status === "inProgress"
+                ? { color: "yellow" }
+                : item.type === "commandExecution"
+                    ? { color: "white" }
+                    : { dimColor: item.type !== "commandExecution" },
+    });
+    if (item.output && item.status === "inProgress") {
+        lines.push(...renderTextLines(lastNonEmptyLine(item.output), {
+            key: `${key}-output`,
+            width,
+            firstPrefix: [{ text: `${" ".repeat(indent + 2)}` }],
+            continuationPrefix: [{ text: `${" ".repeat(indent + 2)}` }],
+            style: { dimColor: true },
+        }));
+    }
+    return lines;
+}
+function buildHistoryIntroLines(width) {
+    return [
+        ...renderTextLines("PatchRelay activity history.", {
+            key: "history-intro-1",
+            width,
+            style: { dimColor: true },
+        }),
+        ...renderTextLines("Runs, waits, and wake-ups are shown here in PatchRelay order.", {
+            key: "history-intro-2",
+            width,
+            style: { dimColor: true },
+        }),
+    ];
+}
+function buildHistoryLines(history, plan, activeRunId, width) {
+    if (history.length === 0) {
+        return renderTextLines("No state history available.", {
+            key: "history-empty",
+            width,
+            style: { dimColor: true },
+        });
+    }
+    const lines = [];
+    let runCounter = 0;
+    for (const [nodeIndex, node] of history.entries()) {
+        lines.push(...renderTextLines(`${node.isCurrent ? "◉" : "○"} ${STATE_LABELS[node.state] ?? node.state}  ${formatTime(node.enteredAt)}`, {
+            key: `history-node-${nodeIndex}`,
+            width,
+            style: { color: node.isCurrent ? "green" : undefined, bold: node.isCurrent },
+        }));
+        if (node.reason) {
+            lines.push(...renderRichTextLines(node.reason, {
+                key: `history-node-${nodeIndex}-reason`,
+                width,
+                firstPrefix: [{ text: "│ ", dimColor: true }],
+                continuationPrefix: [{ text: "│ ", dimColor: true }],
+                style: { dimColor: true },
+            }));
+        }
+        if (node.runs.length > 5) {
+            lines.push(...renderTextLines(historyRunSummary(node.runs), {
+                key: `history-node-${nodeIndex}-summary`,
+                width,
+                firstPrefix: [{ text: "│ ", dimColor: true }],
+                continuationPrefix: [{ text: "│ ", dimColor: true }],
+                style: { dimColor: true },
+            }));
+        }
+        for (const run of node.runs) {
+            lines.push(...renderHistoryRunLines(run, runCounter, width, "│ "));
+            if (run.id === activeRunId && plan?.length) {
+                for (const [index, entry] of plan.entries()) {
+                    lines.push({
+                        key: `history-run-${run.id}-plan-${index}`,
+                        segments: [
+                            { text: "│   ", dimColor: true },
+                            { text: `[${planStepSymbol(entry.status)}]`, color: planStepColor(entry.status) },
+                            { text: " " },
+                            { text: entry.step },
+                        ],
+                    });
+                }
+            }
+            runCounter += 1;
+        }
+        for (const [tripIndex, trip] of node.sideTrips.entries()) {
+            lines.push(...renderSideTripLines(trip, runCounter, width));
+            runCounter += trip.runs.length;
+            if (tripIndex < node.sideTrips.length - 1) {
+                lines.push({ key: `history-trip-gap-${nodeIndex}-${tripIndex}`, segments: [{ text: "│", dimColor: true }] });
+            }
+        }
+        if (nodeIndex < history.length - 1) {
+            lines.push({ key: `history-node-connector-${nodeIndex}`, segments: [{ text: "│", dimColor: true }] });
+        }
+    }
+    return lines;
+}
+function renderHistoryRunLines(run, index, width, gutter) {
+    const statusColor = run.status === "completed" ? "green" : run.status === "failed" ? "red" : run.status === "running" ? "yellow" : "white";
+    const duration = run.endedAt ? formatDuration(run.startedAt, run.endedAt) : undefined;
+    const stats = [
+        run.messageCount !== undefined ? `${run.messageCount} msgs` : null,
+        run.commandCount ? `${run.commandCount} cmds` : null,
+        run.fileChangeCount ? `${run.fileChangeCount} files` : null,
+    ].filter((value) => Boolean(value));
+    const lines = renderTextLines(`${gutter}${run.status === "completed" ? "✓" : run.status === "failed" ? "✗" : run.status === "running" ? "▸" : "•"} #${index + 1} (${RUN_LABELS[run.runType] ?? run.runType})${duration ? ` ${duration}` : ""}${stats.length ? `  ${stats.join(", ")}` : ""}`, {
+        key: `history-run-${run.id}`,
+        width,
+        style: { color: statusColor },
+    });
+    if (run.lastMessage) {
+        lines.push(...renderRichTextLines(run.lastMessage, {
+            key: `history-run-${run.id}-message`,
+            width,
+            firstPrefix: [{ text: `${gutter}  `, dimColor: true }],
+            continuationPrefix: [{ text: `${gutter}  `, dimColor: true }],
+            style: { dimColor: true },
+        }));
+    }
+    return lines;
+}
+function renderSideTripLines(trip, runOffset, width) {
+    const lines = renderTextLines(`│ ┌ ${STATE_LABELS[trip.state] ?? trip.state}  ${formatTime(trip.enteredAt)}`, {
+        key: `history-trip-${trip.state}-${trip.enteredAt}`,
+        width,
+        style: { color: "magenta", bold: true },
+    });
+    if (trip.reason) {
+        lines.push(...renderRichTextLines(trip.reason, {
+            key: `history-trip-${trip.state}-${trip.enteredAt}-reason`,
+            width,
+            firstPrefix: [{ text: "│ │ ", dimColor: true }],
+            continuationPrefix: [{ text: "│ │ ", dimColor: true }],
+            style: { dimColor: true },
+        }));
+    }
+    for (const [index, run] of trip.runs.entries()) {
+        lines.push(...renderHistoryRunLines(run, runOffset + index, width, "│ │ "));
+    }
+    const returnLabel = trip.returnedAt
+        ? `│ └→ ${STATE_LABELS[trip.returnState] ?? trip.returnState}  ${formatTime(trip.returnedAt)}`
+        : "│ └─ (active)";
+    lines.push(...renderTextLines(returnLabel, {
+        key: `history-trip-${trip.state}-${trip.enteredAt}-return`,
+        width,
+        style: { dimColor: !trip.returnedAt },
+    }));
+    return lines;
+}
+function buildFacts(issue, issueContext) {
+    const facts = [];
+    const rereviewNeeded = isRereviewNeeded(issue);
+    if (issue.prNumber !== undefined)
+        facts.push(`PR #${issue.prNumber}`);
+    if (issue.prReviewState === "approved")
+        facts.push("approved");
+    else if (rereviewNeeded)
+        facts.push("re-review needed");
+    else if (issue.prReviewState === "changes_requested")
+        facts.push("changes requested");
+    if (issue.waitingReason && issue.sessionState === "waiting_input")
+        facts.push(issue.waitingReason);
+    const checks = prChecksFact({
+        ...issue,
+        latestFailureCheckName: issueContext?.latestFailureCheckName ?? issue.latestFailureCheckName,
+    });
+    if (checks) {
+        facts.push(checks.text);
+    }
+    return facts;
+}
+function buildMeta(tokenUsage, diffSummary, issueContext) {
+    const meta = [];
+    if (tokenUsage)
+        meta.push(`${formatTokens(tokenUsage.inputTokens)} in / ${formatTokens(tokenUsage.outputTokens)} out`);
+    if (diffSummary && diffSummary.filesChanged > 0)
+        meta.push(`${diffSummary.filesChanged}f +${diffSummary.linesAdded} -${diffSummary.linesRemoved}`);
+    if (issueContext?.runCount)
+        meta.push(`${issueContext.runCount} runs`);
+    return meta;
+}
+function formatTokens(value) {
+    if (value >= 1_000_000)
+        return `${(value / 1_000_000).toFixed(1)}M`;
+    if (value >= 1_000)
+        return `${(value / 1_000).toFixed(1)}k`;
+    return String(value);
+}
+function formatDuration(startedAt, endedAt) {
+    const ms = new Date(endedAt).getTime() - new Date(startedAt).getTime();
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remainder = seconds % 60;
+    return `${minutes}m${remainder > 0 ? ` ${String(remainder).padStart(2, "0")}s` : ""}`;
+}
+function formatTime(iso) {
+    return new Date(iso).toLocaleTimeString("en-GB", { hour12: false, hour: "2-digit", minute: "2-digit", second: "2-digit" });
+}
+function elapsedLabel(startedAt) {
+    const elapsed = Math.max(0, Math.floor((Date.now() - new Date(startedAt).getTime()) / 1000));
+    const minutes = Math.floor(elapsed / 60);
+    const seconds = elapsed % 60;
+    return `${minutes}m ${String(seconds).padStart(2, "0")}s`;
+}
+function itemSummary(item) {
+    switch (item.type) {
+        case "commandExecution": {
+            const exit = item.exitCode !== undefined && item.exitCode !== 0 ? `  exit ${item.exitCode}` : "";
+            const duration = item.durationMs && item.durationMs >= 1000 ? `  ${Math.floor(item.durationMs / 1000)}s` : "";
+            return `$ ${cleanCommand(item.command ?? "?")}${exit}${duration}`;
+        }
+        case "fileChange":
+            return summarizeFileChanges(item.changes ?? []);
+        case "mcpToolCall":
+        case "dynamicToolCall":
+            return `used ${item.toolName ?? item.type}`;
+        default:
+            return (item.text ?? item.type).replace(/\s+/g, " ").trim();
+    }
+}
+function summarizeFileChanges(changes) {
+    const files = Array.from(new Set(changes
+        .map((change) => {
+        if (!change || typeof change !== "object")
+            return undefined;
+        const path = change.path;
+        return typeof path === "string" && path.trim().length > 0 ? path : undefined;
+    })
+        .filter((path) => Boolean(path))));
+    if (files.length === 0) {
+        return `updated ${changes.length} file${changes.length === 1 ? "" : "s"}`;
+    }
+    const names = files.map((path) => path.split("/").at(-1) ?? path);
+    return `updated ${files.length} file${files.length === 1 ? "" : "s"}: ${names.slice(0, 3).join(", ")}${names.length > 3 ? ` +${names.length - 3}` : ""}`;
+}
+function sessionDisplay(issue) {
+    if (issue.sessionState === "failed" || issue.factoryState === "failed" || issue.factoryState === "escalated") {
+        return { label: "needs help", color: "red" };
+    }
+    const state = issue.sessionState ?? "unknown";
+    return SESSION_DISPLAY[state] ?? { label: state, color: "white" };
+}
+function stageDisplay(issue) {
+    return STAGE_DISPLAY[effectiveState(issue)] ?? issue.factoryState;
+}
+function effectiveState(issue) {
+    if (issue.sessionState === "done")
+        return "done";
+    if (issue.sessionState === "failed")
+        return "failed";
+    if (issue.blockedByCount > 0 && !issue.activeRunType)
+        return "blocked";
+    if (issue.sessionState === "waiting_input")
+        return "awaiting_input";
+    if (issue.readyForExecution && !issue.activeRunType && !hasDisplayPrBlocker(issue))
+        return "ready";
+    return issue.factoryState;
+}
+function blockerText(issue, issueContext) {
+    const rereviewNeeded = isRereviewNeeded(issue);
+    if (issue.sessionState === "waiting_input")
+        return issue.waitingReason ?? "Waiting for input";
+    if (issue.sessionState === "failed" || issue.factoryState === "failed" || issue.factoryState === "escalated") {
+        return issue.statusNote ?? issue.waitingReason ?? "Needs operator intervention";
+    }
+    if (issue.waitingReason && !issue.activeRunType)
+        return issue.waitingReason;
+    if (issue.blockedByCount > 0)
+        return `Waiting on ${issue.blockedByKeys.join(", ")}`;
+    if (effectiveState(issue) === "repairing_queue")
+        return "Merge queue conflict, repairing branch";
+    if (effectiveState(issue) === "repairing_ci") {
+        const check = issueContext?.latestFailureCheckName ?? issue.latestFailureCheckName ?? "CI";
+        return `Repairing ${check}`;
+    }
+    const checks = prChecksFact({
+        ...issue,
+        latestFailureCheckName: issueContext?.latestFailureCheckName ?? issue.latestFailureCheckName,
+    });
+    if (checks?.color === "red") {
+        return checks.text;
+    }
+    if (checks?.color === "yellow" && checks.text.startsWith("checks ")) {
+        return `${checks.text} still running`;
+    }
+    if (rereviewNeeded)
+        return "Awaiting re-review after requested changes";
+    if (issue.prReviewState === "changes_requested")
+        return "Review changes requested";
+    if (issue.prNumber !== undefined && !issue.prReviewState && effectiveState(issue) !== "done")
+        return "Awaiting review";
+    return null;
+}
+function cleanCommand(raw) {
+    const bashMatch = raw.match(/^\/bin\/(?:ba)?sh\s+-\w*c\s+['"](.+?)['"]$/s);
+    if (bashMatch?.[1])
+        return bashMatch[1];
+    const bashMatch2 = raw.match(/^\/bin\/(?:ba)?sh\s+-\w*c\s+"(.+?)"$/s);
+    if (bashMatch2?.[1])
+        return bashMatch2[1];
+    return raw;
+}
+function lastNonEmptyLine(output) {
+    return output.split("\n").filter((line) => line.trim().length > 0).at(-1) ?? "";
+}
+function historyRunSummary(runs) {
+    const completed = runs.filter((run) => run.status === "completed").length;
+    const failed = runs.filter((run) => run.status === "failed").length;
+    const running = runs.filter((run) => run.status === "running").length;
+    const parts = [
+        completed > 0 ? `${completed} completed` : null,
+        failed > 0 ? `${failed} failed` : null,
+        running > 0 ? `${running} active` : null,
+    ].filter((value) => Boolean(value));
+    return `${runs.length} runs: ${parts.join(", ")}`;
+}
+function feedGlyph(status) {
+    if (status === "failed")
+        return "✗";
+    if (status === "completed" || status === "pr_merged")
+        return "✓";
+    return "●";
+}
+function freshnessSegments(connected, lastServerMessageAt) {
+    const freshness = describePatchRelayFreshness(connected, lastServerMessageAt);
+    return [{ text: freshness.label, color: freshness.color, bold: true }];
+}
+function blankLine(key) {
+    return { key, segments: [] };
+}
+function trimTrailingBlankLines(lines) {
+    const result = [...lines];
+    while (result.length > 0 && result[result.length - 1]?.segments.length === 0) {
+        result.pop();
+    }
+    return result;
+}
+function segmentsToText(segments) {
+    return segments.map((segment) => segment.text).join("");
+}

package/dist/cli/watch/pr-status.js

@@ -0,0 +1,74 @@
+function isPassingCheckStatus(status) {
+    return status === "passed" || status === "success";
+}
+function isFailingCheckStatus(status) {
+    return status === "failed" || status === "failure";
+}
+function isPendingCheckStatus(status) {
+    return status === "pending" || status === "in_progress";
+}
+export function hasPendingPrChecks(issue) {
+    const summary = issue.prChecksSummary;
+    if (summary?.total) {
+        return summary.pending > 0 || summary.completed < summary.total;
+    }
+    return isPendingCheckStatus(issue.prCheckStatus);
+}
+export function hasFailedPrChecks(issue) {
+    const summary = issue.prChecksSummary;
+    if (summary?.total) {
+        return summary.failed > 0 || summary.overall === "failure";
+    }
+    return isFailingCheckStatus(issue.prCheckStatus);
+}
+export function arePrChecksCompleteAndGreen(issue) {
+    const summary = issue.prChecksSummary;
+    if (summary?.total) {
+        return summary.pending === 0 && summary.failed === 0;
+    }
+    return isPassingCheckStatus(issue.prCheckStatus);
+}
+export function isRereviewNeeded(issue) {
+    return issue.prReviewState === "changes_requested"
+        && arePrChecksCompleteAndGreen(issue)
+        && !issue.activeRunType;
+}
+export function prChecksFact(issue) {
+    const summary = issue.prChecksSummary;
+    if (hasFailedPrChecks(issue)) {
+        const failedNames = summary?.failedNames ?? [];
+        const checkInfo = issue.latestFailureCheckName
+            ?? (failedNames.length > 0 ? failedNames.slice(0, 2).join(", ") : "checks");
+        return { text: `${checkInfo} failed`, color: "red" };
+    }
+    if (summary?.total) {
+        if (summary.pending > 0 || summary.completed < summary.total) {
+            return { text: `checks ${summary.completed}/${summary.total}`, color: "yellow" };
+        }
+        if (summary.failed === 0) {
+            return { text: "checks passed", color: "green" };
+        }
+    }
+    if (isPassingCheckStatus(issue.prCheckStatus)) {
+        return { text: "checks passed", color: "green" };
+    }
+    if (isPendingCheckStatus(issue.prCheckStatus)) {
+        return { text: "checks running", color: "yellow" };
+    }
+    return undefined;
+}
+export function hasDisplayPrBlocker(issue) {
+    if (issue.prNumber === undefined || issue.activeRunType) {
+        return false;
+    }
+    if (hasPendingPrChecks(issue) || hasFailedPrChecks(issue)) {
+        return true;
+    }
+    if (issue.prReviewState === "changes_requested" && !isRereviewNeeded(issue)) {
+        return true;
+    }
+    if (!issue.prReviewState && issue.factoryState === "pr_open") {
+        return true;
+    }
+    return false;
+}