cloving 1.1.0 → 1.2.0

package/dist/src/cli/watch-model.js

@@ -1,9 +1,14 @@
+import { operationalDecision } from "../decision-visibility.js";
+import { workflowRefusals, } from "../workflow-refusals.js";
 import { isTicketStatus } from "../ticket-status.js";
+import { isPromotionId } from "../workflow-contracts.js";
 import { priceFields, statusTurns } from "./watch-usage.js";
 import { priceOf, usageOf } from "../worker-usage.js";
 import { priceText } from "./usage-render.js";
-import { boardsOf, currentStepOf, roundOf, startWorkflowOf, } from "./watch-board.js";
+import { boardsOf, currentStepOf, roundOf, stagesFor, startWorkflowOf, } from "./watch-board.js";
 import { decisionOf, phasesOf } from "./watch-phases.js";
+import { pullOf } from "./watch-pull-request.js";
+import { establishedIssue } from "./watch-pr-identity.js";
 import { displayRun } from "./watch-paths.js";
 const textLimit = 600;
 const activityLimit = 400;
@@ -156,54 +161,6 @@ export function decisionCommands(decision, client) {
         deny: `${client} deny ${decisionId} --text "<feedback>" ${binding}`,
     };
 }
-function githubOf(records) {
-    const started = record(records.started);
-    const operation = list(parsed(text(started["operationId"])));
-    const result = record(records.result);
-    const completed = result["outcome"] === "completed";
-    return {
-        runId: text(operation[2]),
-        round: Number(operation[1]),
-        method: text(started["method"]),
-        report: completed ? record(parsed(text(result["result"]))) : {},
-    };
-}
-function pullRequestOf(results) {
-    const opened = results
-        .filter((item) => item.method === "open-pr")
-        .map((item) => item.report)
-        .findLast((report) => text(report["url"]).startsWith("https://"));
-    if (opened === undefined)
-        return null;
-    return { number: Number(opened["number"]), url: text(opened["url"]) };
-}
-function reviewsOf(results) {
-    return results
-        .filter((item) => item.method === "wait-review")
-        .flatMap(({ round, report }) => {
-        const score = count(report["score"]);
-        if (score === null)
-            return [];
-        return [{ round, commit: text(report["commit"]), score }];
-    });
-}
-function mergeCommitOf(results) {
-    const merged = results
-        .filter((item) => item.method === "merge")
-        .map((item) => stamp(item.report["merged"]));
-    return merged.find((commit) => commit !== null) ?? null;
-}
-function pullOf(inputs, runId) {
-    const results = inputs.githubRecords
-        .map(githubOf)
-        .filter((item) => item.runId === runId)
-        .toSorted((first, second) => first.round - second.round);
-    return {
-        pullRequest: pullRequestOf(results),
-        reviews: reviewsOf(results),
-        mergeCommit: mergeCommitOf(results),
-    };
-}
 function feedbackOf(value) {
     const fields = record(value);
     return {
@@ -219,28 +176,43 @@ function eventOf(value) {
         type: text(fields["type"]),
     };
 }
+function outcomeOf(value) {
+    const fields = record(value);
+    const { promotionId, ticketStatus, issueUpdate } = fields;
+    return {
+        outcome: stamp(fields["kind"]),
+        ...(isPromotionId(promotionId) ? { promotionId } : {}),
+        ...(isTicketStatus(ticketStatus) ? { ticketStatus } : {}),
+        ...(issueUpdate === "failed" ? { issueUpdate } : {}),
+    };
+}
 function runOf(inputs, value) {
     const status = record(record(value)["status"]);
     const runId = text(status["runId"]);
     const workflowId = text(status["workflowId"]);
     const budget = record(status["budget"]);
     const ticketId = text(status["ticketId"]);
-    const ticketStatus = record(status["outcome"])["ticketStatus"];
+    const issue = workflowId === "develop-issue"
+        ? establishedIssue(inputs.repository ?? null, status["issueIdentity"])
+        : null;
     return {
         runId,
         workflowId,
+        parentRunId: stamp(status["parentRunId"]),
+        chainId: stamp(status["chainId"]) ?? runId,
+        childRunIds: texts(status["childRunIds"]),
         ticketId: ticketId === "" ? null : ticketId,
+        ...(issue === null ? {} : { issueIdentity: issue }),
         title: stamp(status["title"]),
-        outcome: stamp(record(status["outcome"])["kind"]),
-        ...(isTicketStatus(ticketStatus) ? { ticketStatus } : {}),
-        ...(record(status["outcome"])["issueUpdate"] === "failed"
-            ? { issueUpdate: "failed" }
-            : {}),
+        ...outcomeOf(status["outcome"]),
         latestAt: stamp(status["latestAt"]),
         claudeCostUsd: priceOf(status["claudeCostUsd"]),
         estimatedCostUsd: priceOf(status["estimatedCostUsd"]),
         usage: usageOf(status["usage"]),
-        currentStep: currentStepOf(list(record(value)["events"]), workflowId),
+        currentStep: currentStepOf(list(record(value)["events"]), {
+            workflowId,
+            stages: stagesFor(inputs.workflowStages, workflowId),
+        }),
         round: roundOf(list(record(value)["events"])),
         state: text(status["state"]),
         code: text(record(status["reason"])["code"]),
@@ -249,13 +221,16 @@ function runOf(inputs, value) {
         limit: count(budget["limit"]),
         decisions: inputs.decisions
             .filter((decision) => record(decision)["runId"] === runId)
-            .map((decision) => decisionCommands(decision, inputs.client)),
+            .map((decision) => decisionCommands(operationalDecision(record(decision), workflowId), inputs.client)),
         events: list(record(value)["events"]).map(eventOf),
         turns: statusTurns(inputs.turns, status),
         phases: phasesOf(list(record(value)["events"]), workflowId),
         decision: decisionOf(list(record(value)["events"])),
         feedback: list(status["feedback"]).map(feedbackOf),
-        ...pullOf(inputs, runId),
+        ...pullOf({
+            records: inputs.githubRecords,
+            repository: workflowId === "develop-issue" ? (inputs.repository ?? null) : null,
+        }, runId),
     };
 }
 function began(run) {
@@ -270,6 +245,8 @@ export function watchModel(inputs) {
     const workflows = boardsOf({ ...inputs, completionCandidates: candidates }, runs);
     return {
         workflows,
+        ...(inputs.queue === undefined ? {} : { queue: inputs.queue }),
+        workflowRefusals: workflowRefusals(inputs.workflowRefusals),
         startWorkflowId: startWorkflowOf(workflows),
         updatedAt: inputs.updatedAt,
         service: inputs.service,

package/dist/src/cli/watch-page.js

@@ -1,16 +1,19 @@
 import { cardReply } from "./watch-card-reply.js";
+import { record } from "../protocol.js";
 import { watchCardClient } from "./watch-card-client.js";
 import { AddCard, CardInput, cardKey, cardSubmitKey, } from "./watch-card-view.js";
 import { watchClient } from "./watch-client.js";
 import { priceOf, tokenCount, usageOf } from "../worker-usage.js";
 import { priceText, usageText, totalsSuffix } from "./usage-render.js";
 import { startPrompts, StartCard, StartRun } from "./watch-start-view.js";
-import { Board, boardSizing, Card, Column, columnCollapsed, CardReview, WorkflowList, cardReview, cardStep, completionMark, } from "./watch-board-view.js";
+import { Board, boardSizing, Card, HandoffLinks, Column, columnCollapsed, CardReview, WorkflowList, cardReview, cardStep, completionMark, observationText, staleObservation, } from "./watch-board-view.js";
 import { boardWorkflow, watchHash, watchLocation, watchTitle, } from "./watch-navigation.js";
 import { clockTime, completedDetail, counted, elapsed, groupActivity, pageTitle, phaseTime, runName, runTone, selectedRun, toneOf, turnTime, waitingDetail, } from "./watch-render.js";
 import { Command, Decision, Events, Group, Item, Turn, Work, } from "./watch-turn.js";
-import { clove, Banner, BannerDetail, BoardPage, Header, Page, Phases, PullRequest, Review, Run, } from "./watch-view.js";
+import { clove, Banner, BannerDetail, BoardPage, Header, Page, Phases, PullRequest, Review, RefusedWorkflows, Queue, Run, } from "./watch-view.js";
 const functions = [
+    record,
+    Queue,
     cardReply,
     cardSubmitKey,
     cardKey,
@@ -29,8 +32,11 @@ const functions = [
     cardReview,
     cardStep,
     completionMark,
+    observationText,
+    staleObservation,
     CardReview,
     Card,
+    HandoffLinks,
     Column,
     columnCollapsed,
     WorkflowList,
@@ -65,6 +71,7 @@ const functions = [
     Review,
     Run,
     Header,
+    RefusedWorkflows,
     BoardPage,
     Page,
 ];
@@ -93,6 +100,15 @@ const dark = `
   --bad: #FF7B72; --bad-tint: rgba(255,123,114,0.14);
 `;
 const style = `
+@font-face { font-family: "Fira Code"; font-style: normal; font-weight: 400; font-display: swap; src: url("/watch-fonts-v1/fira-code-latin-400-normal.woff2") format("woff2"); }
+@font-face { font-family: "Fira Code"; font-style: normal; font-weight: 500; font-display: swap; src: url("/watch-fonts-v1/fira-code-latin-500-normal.woff2") format("woff2"); }
+@font-face { font-family: "Heebo"; font-style: normal; font-weight: 500; font-display: swap; src: url("/watch-fonts-v1/heebo-latin-500-normal.woff2") format("woff2"); }
+@font-face { font-family: "Heebo"; font-style: normal; font-weight: 700; font-display: swap; src: url("/watch-fonts-v1/heebo-latin-700-normal.woff2") format("woff2"); }
+@font-face { font-family: "Heebo"; font-style: normal; font-weight: 800; font-display: swap; src: url("/watch-fonts-v1/heebo-latin-800-normal.woff2") format("woff2"); }
+@font-face { font-family: "Space Grotesk"; font-style: normal; font-weight: 400; font-display: swap; src: url("/watch-fonts-v1/space-grotesk-latin-400-normal.woff2") format("woff2"); }
+@font-face { font-family: "Space Grotesk"; font-style: normal; font-weight: 500; font-display: swap; src: url("/watch-fonts-v1/space-grotesk-latin-500-normal.woff2") format("woff2"); }
+@font-face { font-family: "Space Grotesk"; font-style: normal; font-weight: 600; font-display: swap; src: url("/watch-fonts-v1/space-grotesk-latin-600-normal.woff2") format("woff2"); }
+@font-face { font-family: "Space Grotesk"; font-style: normal; font-weight: 700; font-display: swap; src: url("/watch-fonts-v1/space-grotesk-latin-700-normal.woff2") format("woff2"); }
 :root {${light}
   --heading-font: "Heebo", system-ui, sans-serif;
   --body-font: "Space Grotesk", system-ui, sans-serif;
@@ -111,6 +127,8 @@ body:has(.board-page) { padding-bottom: 0; overflow: hidden; }
 .board-page { height: 100dvh; display: flex; flex-direction: column; overflow: hidden; }
 .board-page > header, .board-page > .down { flex-shrink: 0; }
 .start-run { flex-shrink: 0; max-height: 45dvh; overflow-y: auto; }
+.workflow-refusals { flex-shrink: 0; max-height: 25dvh; overflow-y: auto; overflow-wrap: anywhere; }
+.workflow-refusals h2 { margin: 8px 0; }
 a { color: var(--accent-strong); }
 header { display: flex; gap: 16px; align-items: center; flex-wrap: wrap; padding: 22px 0 10px; color: var(--muted); font-size: 12px; }
 .brand { display: inline-flex; align-items: center; gap: 9px; color: var(--ink); font: 800 26px/1.2 var(--heading-font); }
@@ -142,7 +160,7 @@ h2, h3 { font-family: var(--heading-font); font-weight: 700; }
 .column.collapsed { flex: 0 0 ${String(boardSizing.collapsedColumnWidth)}px; min-width: ${String(boardSizing.collapsedColumnWidth)}px; padding: 6px; }
 .collapsed .column-name { writing-mode: vertical-rl; padding: 0; }
 .column-name button, .start-toggle { color: var(--ink); box-shadow: inset 0 0 0 1px var(--line); margin: 0; }
-.column-name button:hover, .start-toggle:hover { background: var(--surface); }
+.column-name button:hover, .start-toggle:hover, .add-card:hover, .add-card-form button:hover { background: var(--surface); }
 .add-card, .add-card-form button { color: var(--ink); box-shadow: inset 0 0 0 1px var(--line); margin: 4px 8px 4px 0; }
 .add-card { width: 100%; text-align: left; }
 .add-card-form { padding: 8px 0; overflow-wrap: anywhere; }
@@ -249,7 +267,6 @@ export function pageDocument(actionToken = null) {
         "<!doctype html>",
         '<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>Cloving</title>',
         `<link rel="icon" href="data:image/svg+xml,${encodeURIComponent(icon)}">`,
-        '<link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Fira+Code:wght@400;500&amp;family=Heebo:wght@500;700;800&amp;family=Space+Grotesk:wght@400..700&amp;display=swap" media="print" onload="this.media=\'all\'">',
         `<style>${style}</style></head><body>`,
         '<div id="app"></div>',
         `<script type="module">${script}</script></body></html>`,

package/dist/src/cli/watch-phases.js

@@ -8,9 +8,9 @@ const effect = { open: "effect.requested", close: "effect.reported" };
 const issueWorkflow = "develop-issue";
 export const issueSteps = [
     { name: "Work tree", operation: "github-prepare" },
-    { name: "Claude turn", operation: "claude-turn" },
+    { name: "Agent turn", operation: "claude-turn" },
     { name: "Pull request", operation: "github-open-pr" },
-    { name: "Greptile review", operation: "github-wait-review" },
+    { name: "Code review", operation: "github-wait-review" },
     { name: "Merge", operation: "github-merge" },
 ];
 const verdicts = {
@@ -56,7 +56,7 @@ function ticketSpans(events) {
     return [
         ...admission(events),
         {
-            name: "Claude turn",
+            name: "Agent turn",
             startedAt: firstAt(events, effect.open),
             endedAt: closedAt(events, effect),
             ending: "done",

package/dist/src/cli/watch-pr-command.d.ts

@@ -1,4 +1,4 @@
-import { type PrIdentity, type PrObservation } from "./watch-pr-identity.ts";
+import { type PrIdentity, type PrReadResult } from "./watch-pr-identity.ts";
 export interface WatchCommandOutput {
     readonly stdout: string;
     readonly stderr: string;
@@ -12,4 +12,7 @@ export interface WatchCommandRequest {
 }
 export type WatchCommandRunner = (request: WatchCommandRequest) => Promise<WatchCommandOutput>;
 export declare function prArguments(identity: PrIdentity): readonly string[];
-export declare function prCommandResult(identity: PrIdentity, output: WatchCommandOutput): PrObservation;
+export declare function prCommandResult(identity: PrIdentity, reply: {
+    readonly output: WatchCommandOutput;
+    readonly now: number;
+}): PrReadResult;

package/dist/src/cli/watch-pr-command.js

@@ -15,15 +15,52 @@ function commandFailure(output) {
         /^HTTP\/[^ ]+ (\d{3})/m.exec(output.stdout)?.[1]);
     if (status === 429 ||
         /rate limit/i.test(output.stderr) ||
-        /x-ratelimit-remaining: 0\s*$/im.test(output.stdout))
+        headerValues(output.stdout, "x-ratelimit-remaining").includes("0"))
         return "rate-limit";
     if (output.status === 4 || [401, 403, 404].includes(status))
         return "access";
     return "command";
 }
-export function prCommandResult(identity, output) {
-    if (output.status !== 0 || output.errorCode !== null)
-        return { status: "unavailable", failure: commandFailure(output) };
+function headerValues(stdout, name) {
+    if (!/^HTTP\/[^ ]+ \d{3}/.test(stdout))
+        return [];
+    const headers = stdout.split(/\r?\n\r?\n/, 1)[0] ?? "";
+    return headers.split(/\r?\n/).flatMap((line) => {
+        const separator = line.indexOf(":");
+        return line.slice(0, separator).toLowerCase() === name
+            ? [line.slice(separator + 1).trim()]
+            : [];
+    });
+}
+function millisecondsOf(value) {
+    if (!/^\d+$/.test(value))
+        return [];
+    const milliseconds = Number(value) * 1000;
+    return Number.isSafeInteger(milliseconds) ? [milliseconds] : [];
+}
+function retryDeadline(output, now) {
+    const delays = headerValues(output.stdout, "retry-after")
+        .flatMap(millisecondsOf)
+        .map((delay) => now + delay)
+        .filter(Number.isSafeInteger);
+    const resets = headerValues(output.stdout, "x-ratelimit-remaining").includes("0")
+        ? headerValues(output.stdout, "x-ratelimit-reset").flatMap(millisecondsOf)
+        : [];
+    const deadlines = [...delays, ...resets];
+    return deadlines.length === 0 ? now + 60000 : Math.max(now, ...deadlines);
+}
+export function prCommandResult(identity, reply) {
+    const { output, now } = reply;
+    if (output.status !== 0 || output.errorCode !== null) {
+        const failure = commandFailure(output);
+        return {
+            status: "unavailable",
+            failure,
+            ...(failure === "rate-limit"
+                ? { retryAt: retryDeadline(output, now) }
+                : {}),
+        };
+    }
     const envelope = /^HTTP\/[^ ]+ 200[^\n]*\r?\n[\s\S]*?\r?\n\r?\n([\s\S]*)$/.exec(output.stdout);
     if (envelope?.[1] === undefined)
         return { status: "unavailable", failure: "response" };

package/dist/src/cli/watch-pr-identity.d.ts

@@ -5,14 +5,26 @@ export interface PrIdentity {
     readonly number: number;
 }
 export type PrFailure = "configuration" | "identity" | "command" | "access" | "rate-limit" | "response" | "timeout";
-export type PrObservation = {
+export type PrReadResult = {
     readonly status: "merged" | "unmerged";
 } | {
     readonly status: "unavailable";
     readonly failure: PrFailure;
+    readonly retryAt?: number;
 };
-export declare function prResponse(identity: PrIdentity, value: unknown): PrObservation;
+export type PrObservation = (PrReadResult | {
+    readonly status: "pending";
+}) & {
+    readonly retryAt?: number;
+    readonly lastSuccess?: {
+        readonly status: "merged" | "unmerged";
+        readonly readAt: number;
+    };
+};
+export declare function prResponse(identity: PrIdentity, value: unknown): PrReadResult;
 export type PrRepository = Omit<PrIdentity, "number">;
+export declare function establishedIssue(repository: PrRepository | null, value: unknown): PrIdentity | null;
+export declare function sameIssue(first: PrIdentity | null | undefined, second: PrIdentity | null | undefined): boolean;
 export declare function prRepository(origin: string): PrRepository | null;
 export declare function prIdentity(repository: PrRepository, pullRequest: {
     readonly number: number;

package/dist/src/cli/watch-pr-identity.js

@@ -31,6 +31,31 @@ export function prResponse(identity, value) {
         return { status: "unavailable", failure: "response" };
     return { status: merged ? "merged" : "unmerged" };
 }
+export function establishedIssue(repository, value) {
+    const fields = record(value) ?? {};
+    const number = fields["number"];
+    if (repository === null ||
+        typeof number !== "number" ||
+        !Number.isSafeInteger(number) ||
+        number <= 0)
+        return null;
+    const owner = fields["owner"];
+    const name = fields["repository"];
+    if (typeof owner !== "string" ||
+        typeof name !== "string" ||
+        owner.toLowerCase() !== repository.owner ||
+        name.toLowerCase() !== repository.repository)
+        return null;
+    return { ...repository, number };
+}
+export function sameIssue(first, second) {
+    return (first != null &&
+        second != null &&
+        first.host === second.host &&
+        first.owner === second.owner &&
+        first.repository === second.repository &&
+        first.number === second.number);
+}
 export function prRepository(origin) {
     const address = origin
         .replace(/^git@([^:/]+):/, "ssh://git@$1/")

package/dist/src/cli/watch-pr-observer.d.ts

@@ -2,6 +2,7 @@ import type { WatchPullRequest } from "./watch-render.ts";
 import { type WatchCommandRunner } from "./watch-pr-command.ts";
 import { type PrObservation, type PrRepository } from "./watch-pr-identity.ts";
 export interface PrObserver {
+    readonly repository?: PrRepository | null;
     readonly observe: (pullRequest: WatchPullRequest) => PrObservation | null;
     readonly close: () => void;
 }

package/dist/src/cli/watch-pr-observer.js

@@ -9,13 +9,23 @@ const systemClock = {
         };
     },
 };
+function observationOf(entry, reply) {
+    const { result, now } = reply;
+    if (result.status !== "unavailable")
+        return { ...result, lastSuccess: { status: result.status, readAt: now } };
+    const lastSuccess = entry.result?.lastSuccess;
+    return { ...result, ...(lastSuccess === undefined ? {} : { lastSuccess }) };
+}
 async function readPr(state, attempt) {
     const { entry, controller } = attempt;
     const deadline = { expired: false };
     const timeout = { status: "unavailable", failure: "timeout" };
     const cancel = state.clock.after(() => {
         deadline.expired = true;
-        entry.result = timeout;
+        entry.result = observationOf(entry, {
+            result: timeout,
+            now: state.clock.now(),
+        });
         controller.abort();
     }, 5000);
     controller.signal.addEventListener("abort", cancel, { once: true });
@@ -28,7 +38,9 @@ async function readPr(state, attempt) {
             directory: state.settings.directory,
             signal: controller.signal,
         }));
-        return deadline.expired ? timeout : prCommandResult(entry.identity, output);
+        return deadline.expired
+            ? timeout
+            : prCommandResult(entry.identity, { output, now: state.clock.now() });
     }
     catch {
         return deadline.expired
@@ -43,14 +55,32 @@ async function readPr(state, attempt) {
 function pump(state) {
     if (state.closed || state.active !== null)
         return;
-    const entry = state.queue.shift();
+    state.wake?.();
+    state.wake = null;
+    if (state.queue.length === 0)
+        return;
+    const now = state.clock.now();
+    const position = state.queue.findIndex((entry) => (state.retryDeadlines.get(entry.identity.host) ?? 0) <= now);
+    if (position === -1) {
+        const next = Math.min(...state.queue.map((entry) => state.retryDeadlines.get(entry.identity.host) ?? now));
+        state.wake = state.clock.after(() => {
+            state.wake = null;
+            pump(state);
+        }, Math.min(next - now, 2147483647));
+        return;
+    }
+    const [entry] = state.queue.splice(position, 1);
     if (entry === undefined)
         return;
     const controller = new AbortController();
     state.active = controller;
     entry.started = state.clock.now();
     const completed = (result) => {
-        entry.result = result;
+        if (state.closed)
+            return;
+        entry.result = observationOf(entry, { result, now: state.clock.now() });
+        if (result.status === "unavailable" && result.failure === "rate-limit")
+            state.retryDeadlines.set(entry.identity.host, Math.max(state.retryDeadlines.get(entry.identity.host) ?? 0, result.retryAt ?? state.clock.now() + 60000));
         entry.pending = false;
         state.active = null;
         pump(state);
@@ -59,6 +89,11 @@ function pump(state) {
         completed({ status: "unavailable", failure: "command" });
     });
 }
+function currentObservation(state, entry) {
+    const result = entry.result ?? { status: "pending" };
+    const retryAt = state.retryDeadlines.get(entry.identity.host) ?? 0;
+    return retryAt > state.clock.now() ? { ...result, retryAt } : result;
+}
 function needsRead(entry, now) {
     if (entry === undefined)
         return true;
@@ -72,6 +107,8 @@ export function prObserver(settings) {
         clock: settings.clock ?? systemClock,
         cache: new Map(),
         queue: [],
+        retryDeadlines: new Map(),
+        wake: null,
         active: null,
         closed: false,
     };
@@ -85,7 +122,9 @@ export function prObserver(settings) {
         const key = JSON.stringify(identity);
         const known = state.cache.get(key);
         if (state.closed || !needsRead(known, state.clock.now()))
-            return known?.result ?? null;
+            return known === undefined
+                ? { status: "pending" }
+                : currentObservation(state, known);
         const entry = {
             identity,
             result: known?.result ?? null,
@@ -95,13 +134,16 @@ export function prObserver(settings) {
         state.cache.set(key, entry);
         state.queue.push(entry);
         pump(state);
-        return entry.result;
+        return currentObservation(state, entry);
     };
     return {
+        repository: settings.repository,
         observe,
         close: () => {
             state.closed = true;
             state.queue.length = 0;
+            state.wake?.();
+            state.wake = null;
             state.active?.abort();
         },
     };

package/dist/src/cli/watch-pull-request.d.ts

@@ -0,0 +1,10 @@
+import type { WatchRun } from "./watch-render.ts";
+import { type PrRepository } from "./watch-pr-identity.ts";
+export interface GithubRecords {
+    readonly started: unknown;
+    readonly result: unknown;
+}
+export declare function pullOf(inputs: {
+    readonly records: readonly GithubRecords[];
+    readonly repository: PrRepository | null;
+}, runId: string): Pick<WatchRun, "pullRequest" | "reviews" | "mergeCommit" | "mergeProof">;

package/dist/src/cli/watch-pull-request.js

@@ -0,0 +1,130 @@
+import { operationIdentity } from "../operation-identity.js";
+import { prIdentity, } from "./watch-pr-identity.js";
+function record(value) {
+    return typeof value === "object" && value !== null ? { ...value } : {};
+}
+function text(value) {
+    return typeof value === "string" ? value : "";
+}
+function stamp(value) {
+    return typeof value === "string" ? value : null;
+}
+function parsed(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+}
+function list(value) {
+    return Array.isArray(value) ? value.map((item) => item) : [];
+}
+function count(value) {
+    return typeof value === "number" ? value : null;
+}
+function attributed(started, operation) {
+    const stage = list(operation[5]);
+    const checked = operationIdentity({
+        round: operation[1],
+        run: operation[2],
+        phase: operation[3],
+        operation: operation[4],
+        ...(operation[5] === null
+            ? {}
+            : { stage: { id: stage[0], visit: stage[1], branch: stage[2] } }),
+        ...(operation[6] === null ? {} : { key: operation[6] }),
+    });
+    return (checked.kind === "valid" &&
+        checked.value === JSON.stringify(operation) &&
+        operation[3] === "pull-request" &&
+        operation[4] === `github-${text(started["method"])}` &&
+        (started["runId"] === undefined || started["runId"] === operation[2]));
+}
+function githubOf(records) {
+    const started = record(records.started);
+    const operation = list(parsed(text(started["operationId"])));
+    const result = record(records.result);
+    const completed = result["outcome"] === "completed";
+    return {
+        runId: text(operation[2]),
+        round: Number(operation[1]),
+        method: text(started["method"]),
+        completed,
+        attributed: attributed(started, operation) && !Object.hasOwn(result, "reason"),
+        report: completed ? record(parsed(text(result["result"]))) : {},
+    };
+}
+function pullRequestOf(results) {
+    const opened = results
+        .filter((item) => item.method === "open-pr")
+        .map((item) => item.report)
+        .findLast((report) => text(report["url"]).startsWith("https://"));
+    if (opened === undefined)
+        return null;
+    return { number: Number(opened["number"]), url: text(opened["url"]) };
+}
+function reviewsOf(results) {
+    return results
+        .filter((item) => item.method === "wait-review")
+        .flatMap(({ round, report }) => {
+        const score = count(report["score"]);
+        if (score === null)
+            return [];
+        return [{ round, commit: text(report["commit"]), score }];
+    });
+}
+function mergeCommitOf(results) {
+    const merged = results
+        .filter((item) => item.method === "merge")
+        .map((item) => stamp(item.report["merged"]));
+    return merged.find((commit) => commit !== null) ?? null;
+}
+function mergeProofOf(results, context) {
+    if (context.repository === null || context.pullRequest === null)
+        return null;
+    const repository = context.repository;
+    const identity = prIdentity(repository, context.pullRequest);
+    if (identity === null)
+        return null;
+    const opened = results.filter((item) => item.method === "open-pr" && item.completed && item.attributed);
+    if (opened.length === 0 ||
+        opened.some(({ report }) => report["number"] !== identity.number ||
+            typeof report["url"] !== "string" ||
+            prIdentity(repository, {
+                number: identity.number,
+                url: report["url"],
+            }) === null))
+        return null;
+    const merged = results.filter((item) => item.method === "merge" &&
+        item.completed &&
+        item.attributed &&
+        (typeof item.report["reason"] !== "string" ||
+            Object.hasOwn(item.report, "merged")));
+    if (merged.length === 0 ||
+        merged.some(({ report }) => report["number"] !== identity.number ||
+            typeof report["merged"] !== "string" ||
+            report["merged"].trim() === "" ||
+            Object.hasOwn(report, "reason")))
+        return null;
+    return new Set(merged.map(({ report }) => report["merged"])).size === 1
+        ? identity
+        : null;
+}
+export function pullOf(inputs, runId) {
+    const results = inputs.records
+        .map(githubOf)
+        .filter((item) => item.runId === runId)
+        .toSorted((first, second) => first.round - second.round);
+    const pullRequest = pullRequestOf(results);
+    const mergeProof = mergeProofOf(results, {
+        repository: inputs.repository,
+        pullRequest,
+    });
+    return {
+        pullRequest,
+        reviews: reviewsOf(results),
+        mergeCommit: mergeCommitOf(results),
+        ...(mergeProof === null ? {} : { mergeProof }),
+    };
+}