cloving 1.0.1 → 1.1.0

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

@@ -1,3 +1,7 @@
+import { isTicketStatus } from "../ticket-status.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 { decisionOf, phasesOf } from "./watch-phases.js";
 import { displayRun } from "./watch-paths.js";
@@ -59,7 +63,7 @@ function failed(part) {
     return [{ kind: "error", text: shown }];
 }
 function ended(line) {
-    const cost = count(line["total_cost_usd"]);
+    const cost = priceOf(line["total_cost_usd"]);
     return [
         {
             kind: "result",
@@ -79,13 +83,6 @@ export function activityOf(line) {
         return parts(value).flatMap(failed);
     return value["type"] === "result" ? ended(value) : [];
 }
-function costOf(lines) {
-    const costs = lines
-        .map((line) => record(parsed(line)))
-        .filter((value) => value["type"] === "result")
-        .map((value) => count(value["total_cost_usd"]));
-    return costs.at(-1) ?? null;
-}
 function concise(items) {
     return items.map((item, index) => {
         const before = items[index - 1];
@@ -103,8 +100,9 @@ function shortened(run) {
         turns: run.turns.map((turn) => ({
             ...turn,
             activity: concise(turn.activity.map((item) => {
-                const cost = item.costUsd;
-                const spent = cost === undefined ? "" : ` (cost ${cost.toFixed(2)} USD)`;
+                const spent = item.kind === "result"
+                    ? ` (cost ${priceText(item.costUsd, turn.estimatedCostUsd)})`
+                    : "";
                 return { kind: item.kind, text: `${cut(item.text)}${spent}` };
             })).slice(-activityLimit),
         })),
@@ -118,14 +116,26 @@ export function turnOf(records) {
     const report = record(parsed(text(result["result"])));
     return {
         key: records.key,
+        operationId: text(started["operationId"]),
+        usage: usageOf(report["usage"]),
         runId: text(operation[2]),
         target: text(started["target"]),
         branch: text(started["branch"]),
         worktree: text(started["worktree"]),
         startedAt: text(started["startedAt"]),
         outcome: records.result === null ? "in work" : outcome,
-        costUsd: costOf(records.lines),
-        activity: records.lines.flatMap(activityOf).slice(-activityLimit - 1),
+        costUsd: priceOf(report["costUsd"]),
+        estimatedCostUsd: priceOf(report["estimatedCostUsd"]),
+        activity: records.lines
+            .flatMap(activityOf)
+            .map((item) => item.kind === "result"
+            ? {
+                kind: item.kind,
+                text: item.text,
+                ...priceFields(report["costUsd"]),
+            }
+            : item)
+            .slice(-activityLimit - 1),
         endedAt: stamp(result["endedAt"]),
         activeAt: records.activeAt ?? null,
         commits: texts(report["commits"]),
@@ -215,14 +225,21 @@ function runOf(inputs, value) {
     const workflowId = text(status["workflowId"]);
     const budget = record(status["budget"]);
     const ticketId = text(status["ticketId"]);
+    const ticketStatus = record(status["outcome"])["ticketStatus"];
     return {
         runId,
         workflowId,
         ticketId: ticketId === "" ? null : ticketId,
         title: stamp(status["title"]),
         outcome: stamp(record(status["outcome"])["kind"]),
+        ...(isTicketStatus(ticketStatus) ? { ticketStatus } : {}),
+        ...(record(status["outcome"])["issueUpdate"] === "failed"
+            ? { issueUpdate: "failed" }
+            : {}),
         latestAt: stamp(status["latestAt"]),
-        claudeCostUsd: count(status["claudeCostUsd"]) ?? 0,
+        claudeCostUsd: priceOf(status["claudeCostUsd"]),
+        estimatedCostUsd: priceOf(status["estimatedCostUsd"]),
+        usage: usageOf(status["usage"]),
         currentStep: currentStepOf(list(record(value)["events"]), workflowId),
         round: roundOf(list(record(value)["events"])),
         state: text(status["state"]),
@@ -234,7 +251,7 @@ function runOf(inputs, value) {
             .filter((decision) => record(decision)["runId"] === runId)
             .map((decision) => decisionCommands(decision, inputs.client)),
         events: list(record(value)["events"]).map(eventOf),
-        turns: inputs.turns.filter((turn) => turn.runId === runId),
+        turns: statusTurns(inputs.turns, status),
         phases: phasesOf(list(record(value)["events"]), workflowId),
         decision: decisionOf(list(record(value)["events"])),
         feedback: list(status["feedback"]).map(feedbackOf),

package/dist/src/cli/watch-page.d.ts

@@ -1 +1 @@
-export declare function pageDocument(): string;
+export declare function pageDocument(actionToken?: string | null): string;

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

@@ -1,9 +1,27 @@
-import { Board, Card, CardReview, WorkflowList, cardReview, cardStep, completionMark, } from "./watch-board-view.js";
+import { cardReply } from "./watch-card-reply.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 { 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, Header, Page, Phases, PullRequest, Review, Run, } from "./watch-view.js";
+import { clove, Banner, BannerDetail, BoardPage, Header, Page, Phases, PullRequest, Review, Run, } from "./watch-view.js";
 const functions = [
+    cardReply,
+    cardSubmitKey,
+    cardKey,
+    AddCard,
+    CardInput,
+    priceOf,
+    tokenCount,
+    usageOf,
+    priceText,
+    usageText,
+    totalsSuffix,
     watchHash,
     watchLocation,
     boardWorkflow,
@@ -13,6 +31,8 @@ const functions = [
     completionMark,
     CardReview,
     Card,
+    Column,
+    columnCollapsed,
     WorkflowList,
     Board,
     counted,
@@ -35,6 +55,9 @@ const functions = [
     Command,
     Decision,
     Events,
+    startPrompts,
+    StartCard,
+    StartRun,
     BannerDetail,
     Banner,
     Phases,
@@ -42,6 +65,7 @@ const functions = [
     Review,
     Run,
     Header,
+    BoardPage,
     Page,
 ];
 const light = `
@@ -83,28 +107,57 @@ const style = `
 :root[data-theme="dark"] {${dark}}
 * { box-sizing: border-box; }
 body { margin: 0 auto; max-width: 1800px; padding: 0 20px 96px; }
+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; }
 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); }
 .brand svg { width: 30px; height: 30px; color: var(--accent); }
-a:focus-visible, button:focus-visible, summary:focus-visible { outline: 3px solid var(--accent); outline-offset: 2px; box-shadow: 0 0 0 6px var(--code-bg); }
+a:focus-visible, button:focus-visible, summary:focus-visible, input:focus-visible, textarea:focus-visible { outline: 3px solid var(--accent); outline-offset: 2px; box-shadow: 0 0 0 6px var(--code-bg); }
 h2, h3 { font-family: var(--heading-font); font-weight: 700; }
-.workspace { display: grid; grid-template-columns: 200px minmax(0, 1fr); gap: 24px; margin-top: 20px; }
-.workflows { display: flex; flex-direction: column; gap: 8px; }
-.workflows a { display: grid; gap: 2px; border-bottom: 3px solid transparent; padding: 10px; color: inherit; text-decoration: none; overflow-wrap: anywhere; }
+.start-cards { display: grid; grid-template-columns: repeat(auto-fit, minmax(min(100%, 420px), 1fr)); gap: 16px; margin-top: 12px; }
+.start-card { min-width: 0; padding: 14px; border-radius: 14px; background: var(--surface); box-shadow: inset 0 0 0 1px var(--line); }
+.start-card h3 { margin: 0; }
+.start-card p { margin: 6px 0 12px; }
+.start-card .command { grid-template-columns: minmax(0, 1fr); margin: 0; }
+.start-card button { justify-self: end; }
+.workspace { display: flex; width: 100%; margin-top: 12px; flex: 1; min-height: 0; }
+.workflows { display: flex; flex-direction: row; flex-shrink: 0; gap: 8px; min-width: 0; margin-top: 12px; padding: 6px; overflow-x: auto; overflow-y: hidden; }
+.workflows a { display: grid; flex-shrink: 0; white-space: nowrap; gap: 2px; border-bottom: 3px solid transparent; padding: 10px; color: inherit; text-decoration: none; }
 .workflows a[aria-current="page"] { border-bottom-color: var(--accent); background: var(--surface); border-radius: 8px 8px 0 0; }
 .workflows span, .card small { color: var(--muted); font-size: 12px; }
-.board { min-width: 0; }
-.board h2 { margin: 0 0 14px; font-size: 24px; }
-.columns { display: grid; grid-auto-flow: column; grid-auto-columns: minmax(230px, 1fr); gap: 12px; overflow-x: auto; padding: 6px 6px 24px; }
-.column { min-width: 0; padding: 10px; border-radius: 14px; box-shadow: inset 0 0 0 1px var(--line); background: var(--surface-2); }
-.column-name { margin: 0 0 10px; padding: 8px 4px; color: var(--muted); font: 500 12px/1.5 var(--code-font); }
+.board { width: 100%; min-width: 0; min-height: 0; display: flex; flex-direction: column; }
+.board h2 { margin: 0 0 8px; font-size: 24px; flex-shrink: 0; }
+.columns { display: flex; align-items: flex-start; gap: ${String(boardSizing.gap)}px; flex: 1; min-height: 0; overflow-x: scroll; overflow-y: hidden; padding: 6px 6px 12px; scrollbar-color: var(--muted) var(--surface-2); }
+@supports selector(::-webkit-scrollbar) { .columns { scrollbar-color: auto; } }
+.columns::-webkit-scrollbar { height: 12px; }
+.columns::-webkit-scrollbar-track { background: var(--surface-2); }
+.columns::-webkit-scrollbar-thumb { background: var(--muted); border-radius: 6px; }
+.column { flex: 1 0 ${String(boardSizing.minimumColumnWidth)}px; min-width: ${String(boardSizing.minimumColumnWidth)}px; max-height: 100%; display: flex; flex-direction: column; overflow: hidden; padding: 10px; border-radius: 14px; box-shadow: inset 0 0 0 1px var(--line); background: var(--surface-2); }
+.column-name { display: flex; align-items: center; gap: 6px; flex-shrink: 0; margin: 0; padding: 4px 0 10px; color: var(--muted); font: 500 12px/1.5 var(--code-font); }
+.column-name > span:first-child { flex: 1; }
+.column-cards { min-height: 0; overflow-y: auto; overscroll-behavior-y: contain; }
+.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); }
+.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; }
+.add-card-form label { display: block; color: var(--ink); margin-bottom: 8px; }
+.add-card-form input, .add-card-form textarea { display: block; width: 100%; min-width: 0; box-sizing: border-box; padding: 8px; border: 1px solid var(--line); border-radius: 6px; font: inherit; color: var(--ink); background: var(--surface); }
+.add-card-form textarea { resize: vertical; }
+.add-card-form button:disabled { opacity: 0.6; cursor: default; }
+.add-card-form p { font-size: 12px; margin: 8px 0; }
 .card { display: grid; gap: 6px; margin-bottom: 10px; padding: 12px; border-radius: 14px; box-shadow: inset 0 0 0 1px var(--line), var(--shadow); color: var(--ink); overflow-wrap: anywhere; background: var(--surface); }
 .card:hover { outline: 1px solid var(--accent-strong); }
-.card-run { display: grid; gap: 8px; color: inherit; text-decoration: none; }
-.card-run strong { font-family: var(--heading-font); font-weight: 700; }
+.card-run { display: grid; gap: 4px; min-width: 0; color: inherit; text-decoration: none; }
+.card-run strong { font-family: var(--heading-font); font-weight: 700; display: -webkit-box; -webkit-box-orient: vertical; -webkit-line-clamp: 2; overflow: hidden; }
 .completion-mark { font-size: 12px; }
 .card-step, .card-review, .card-cost, .card small { font: 400 12px/1.6 var(--code-font); font-variant-numeric: tabular-nums; }
+.card-step, .card-review { white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
 .card-step { color: var(--muted); }
 .card-step.active { color: var(--accent-strong); }
 .card-review { color: var(--muted); }
@@ -180,84 +233,17 @@ button:hover { background: var(--code-head); }
 .events { margin-top: 18px; padding-bottom: 10px; }
 .events > summary { color: var(--code-fg); }
 .down { font-weight: 600; }
-@media (max-width: 700px) { body { padding-inline: 12px; } .workspace { grid-template-columns: minmax(0, 1fr); gap: 12px; } .workflows { flex-direction: row; overflow-x: auto; padding: 6px; } .workflows a { flex-shrink: 0; } }
+@media (max-width: 700px) { body { padding-inline: 12px; } }
 `;
-const loader = `
-const state = { model: null, stale: false, copied: "", label: "", run: "", loading: false, again: false };
-function moved(next, followed) {
-  const arrived = next === "waiting_gate" && next !== state.run;
-  state.run = next;
-  if (arrived) scrollTo(0, 0);
-  else if (followed && next === "running") scrollTo(0, document.body.scrollHeight);
-}
-function copy(command) {
-  const shown = (label) => {
-    state.copied = command;
-    state.label = label;
-    draw();
-  };
-  navigator.clipboard.writeText(command).then(
-    () => { shown("Copied"); },
-    () => { shown("Copy failed"); },
-  );
-}
-function draw() {
-  const { model, stale } = state;
-  const selected = location.hash.slice(1);
-  const followed = innerHeight + scrollY >= document.body.scrollHeight - 80;
-  const copying = { command: state.copied, label: state.label, onCopy: copy };
-  const now = new Date().toISOString();
-  const page = component(Page, { model, selected, now, stale, copying });
-  render(page, document.getElementById("app"));
-  if (model === null) return;
-  document.title = watchTitle(model, selected);
-  const { runId } = watchLocation(selected);
-  moved(model.runs.find((run) => run.runId === runId)?.state ?? "", followed);
-}
-async function withSelectedRun(model) {
-  const { runId } = watchLocation(location.hash);
-  if (runId === null || model.runs.some((run) => run.runId === runId)) return model;
-  const detail = await fetch("data.json?runId=" + encodeURIComponent(runId), { cache: "no-store" });
-  if (detail.status === 404) return model;
-  if (!detail.ok) throw new Error("watch-run-not-available");
-  const { run } = await detail.json();
-  if (run?.runId !== runId) throw new Error("watch-run-mismatch");
-  return { ...model, runs: [...model.runs, run] };
-}
-async function load() {
-  state.again = state.loading;
-  if (state.loading) return;
-  state.loading = true;
-  try {
-    const reply = await fetch("data.json", { cache: "no-store" });
-    if (!reply.ok) throw new Error("watch-not-available");
-    state.model = await withSelectedRun(await reply.json());
-    state.stale = false;
-  } catch {
-    state.stale = true;
-  }
-  state.loading = false;
-  draw();
-  if (state.again) load();
-}
-function listen() {
-  const source = new EventSource("events");
-  source.onmessage = () => { load(); };
-  source.onerror = () => { state.stale = true; draw(); };
-}
-addEventListener("hashchange", () => { state.run = ""; draw(); load(); });
-draw();
-listen();
-setInterval(draw, 1000);
-setInterval(load, 15000);
-`;
-export function pageDocument() {
+export function pageDocument(actionToken = null) {
     const icon = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${clove.viewBox}">${clove.paths.map((d) => `<path fill="#0BBF64" d="${d}"/>`).join("")}</svg>`;
     const script = [
         'import { h as element, h as component, render } from "./preact.mjs";',
         `const clove = ${JSON.stringify(clove)};`,
+        `const actionToken = ${JSON.stringify(actionToken)};`,
         ...functions.map((item) => item.toString()),
-        loader,
+        watchCardClient,
+        watchClient,
     ].join("\n");
     return [
         "<!doctype html>",

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

@@ -0,0 +1,3 @@
+import type { PrObserver } from "./watch-pr-observer.ts";
+import type { WatchModel } from "./watch-render.ts";
+export declare function observedBoard(model: WatchModel, observer: PrObserver): WatchModel;

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

@@ -0,0 +1,26 @@
+function observedCard(context, card) {
+    if (card.completionMark?.text !== "Needs attention")
+        return card;
+    const run = context.model.runs.find((run) => run.runId === card.runId);
+    if (run?.workflowId !== "develop-issue" ||
+        run.state !== "completed" ||
+        run.outcome !== "blocked" ||
+        run.pullRequest === null)
+        return card;
+    return {
+        ...card,
+        pullRequestObservation: context.observer.observe(run.pullRequest),
+    };
+}
+export function observedBoard(model, observer) {
+    return {
+        ...model,
+        workflows: model.workflows.map((workflow) => ({
+            ...workflow,
+            columns: workflow.columns.map((column) => ({
+                ...column,
+                cards: column.cards.map((card) => observedCard({ model, observer }, card)),
+            })),
+        })),
+    };
+}

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

@@ -0,0 +1,15 @@
+import { type PrIdentity, type PrObservation } from "./watch-pr-identity.ts";
+export interface WatchCommandOutput {
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly status: number | null;
+    readonly errorCode: string | null;
+}
+export interface WatchCommandRequest {
+    readonly command: readonly string[];
+    readonly directory: string;
+    readonly signal: AbortSignal;
+}
+export type WatchCommandRunner = (request: WatchCommandRequest) => Promise<WatchCommandOutput>;
+export declare function prArguments(identity: PrIdentity): readonly string[];
+export declare function prCommandResult(identity: PrIdentity, output: WatchCommandOutput): PrObservation;

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

@@ -0,0 +1,37 @@
+import { prResponse, } from "./watch-pr-identity.js";
+export function prArguments(identity) {
+    return [
+        "api",
+        "--method",
+        "GET",
+        "--hostname",
+        identity.host,
+        `repos/${identity.owner}/${identity.repository}/pulls/${String(identity.number)}`,
+        "--include",
+    ];
+}
+function commandFailure(output) {
+    const status = Number(/\(HTTP (\d{3})\)/.exec(output.stderr)?.[1] ??
+        /^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))
+        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) };
+    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" };
+    try {
+        const response = JSON.parse(envelope[1]);
+        return prResponse(identity, response);
+    }
+    catch {
+        return { status: "unavailable", failure: "response" };
+    }
+}

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

@@ -0,0 +1,20 @@
+export interface PrIdentity {
+    readonly host: string;
+    readonly owner: string;
+    readonly repository: string;
+    readonly number: number;
+}
+export type PrFailure = "configuration" | "identity" | "command" | "access" | "rate-limit" | "response" | "timeout";
+export type PrObservation = {
+    readonly status: "merged" | "unmerged";
+} | {
+    readonly status: "unavailable";
+    readonly failure: PrFailure;
+};
+export declare function prResponse(identity: PrIdentity, value: unknown): PrObservation;
+export type PrRepository = Omit<PrIdentity, "number">;
+export declare function prRepository(origin: string): PrRepository | null;
+export declare function prIdentity(repository: PrRepository, pullRequest: {
+    readonly number: number;
+    readonly url: string;
+}): PrIdentity | null;

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

@@ -0,0 +1,62 @@
+import { record } from "../protocol.js";
+function responseNames(fields) {
+    const repository = record(record(fields["base"])?.["repo"]) ?? {};
+    return [
+        fields["html_url"],
+        repository["html_url"],
+        repository["full_name"],
+        repository["name"],
+        record(repository["owner"])?.["login"],
+    ];
+}
+export function prResponse(identity, value) {
+    const fields = record(value) ?? {};
+    const expected = `https://${identity.host}/${identity.owner}/${identity.repository}`;
+    const strings = responseNames(fields);
+    if (typeof fields["number"] !== "number" ||
+        strings.some((part) => typeof part !== "string"))
+        return { status: "unavailable", failure: "response" };
+    const wanted = [
+        `${expected}/pull/${String(identity.number)}`,
+        expected,
+        `${identity.owner}/${identity.repository}`,
+        identity.repository,
+        identity.owner,
+    ];
+    if (fields["number"] !== identity.number ||
+        strings.some((part, index) => String(part).toLowerCase() !== String(wanted[index]).toLowerCase()))
+        return { status: "unavailable", failure: "identity" };
+    const merged = fields["merged"];
+    if (typeof merged !== "boolean")
+        return { status: "unavailable", failure: "response" };
+    return { status: merged ? "merged" : "unmerged" };
+}
+export function prRepository(origin) {
+    const address = origin
+        .replace(/^git@([^:/]+):/, "ssh://git@$1/")
+        .replace(/\r?\n$/, "");
+    const matched = /^(?:https:\/\/|ssh:\/\/git@)([a-zA-Z0-9.-]+)\/([a-zA-Z0-9-]+)\/([a-zA-Z0-9_.-]+)$/.exec(address);
+    const [, host, owner, name] = matched ?? [];
+    if (host === undefined || owner === undefined || name === undefined)
+        return null;
+    if (host
+        .split(".")
+        .some((label) => !/^[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?$/.test(label)))
+        return null;
+    const repository = name.replace(/\.git$/, "");
+    if (![host, owner].every((part) => /^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/.test(part)) ||
+        ["", ".", ".."].includes(repository))
+        return null;
+    return {
+        host: host.toLowerCase(),
+        owner: owner.toLowerCase(),
+        repository: repository.toLowerCase(),
+    };
+}
+export function prIdentity(repository, pullRequest) {
+    const { number, url } = pullRequest;
+    if (!Number.isSafeInteger(number) || number <= 0)
+        return null;
+    const expected = `https://${repository.host}/${repository.owner}/${repository.repository}/pull/${String(number)}`;
+    return url.toLowerCase() === expected ? { ...repository, number } : null;
+}

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

@@ -0,0 +1,19 @@
+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 observe: (pullRequest: WatchPullRequest) => PrObservation | null;
+    readonly close: () => void;
+}
+export interface PrClock {
+    readonly now: () => number;
+    readonly after: (expired: () => void, milliseconds: number) => () => void;
+}
+export interface PrObserverSettings {
+    readonly clock?: PrClock;
+    readonly repository: PrRepository | null;
+    readonly directory: string;
+    readonly command: readonly string[] | null;
+    readonly execute: WatchCommandRunner;
+}
+export declare function prObserver(settings: PrObserverSettings): PrObserver;

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

@@ -0,0 +1,108 @@
+import { prArguments, prCommandResult, } from "./watch-pr-command.js";
+import { prIdentity, } from "./watch-pr-identity.js";
+const systemClock = {
+    now: Date.now,
+    after: (expired, milliseconds) => {
+        const timer = setTimeout(expired, milliseconds);
+        return () => {
+            clearTimeout(timer);
+        };
+    },
+};
+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;
+        controller.abort();
+    }, 5000);
+    controller.signal.addEventListener("abort", cancel, { once: true });
+    try {
+        const output = await Promise.resolve().then(() => state.settings.execute({
+            command: [
+                ...(state.settings.command ?? []),
+                ...prArguments(entry.identity),
+            ],
+            directory: state.settings.directory,
+            signal: controller.signal,
+        }));
+        return deadline.expired ? timeout : prCommandResult(entry.identity, output);
+    }
+    catch {
+        return deadline.expired
+            ? timeout
+            : { status: "unavailable", failure: "command" };
+    }
+    finally {
+        cancel();
+        controller.signal.removeEventListener("abort", cancel);
+    }
+}
+function pump(state) {
+    if (state.closed || state.active !== null)
+        return;
+    const entry = state.queue.shift();
+    if (entry === undefined)
+        return;
+    const controller = new AbortController();
+    state.active = controller;
+    entry.started = state.clock.now();
+    const completed = (result) => {
+        entry.result = result;
+        entry.pending = false;
+        state.active = null;
+        pump(state);
+    };
+    readPr(state, { entry, controller }).then(completed, () => {
+        completed({ status: "unavailable", failure: "command" });
+    });
+}
+function needsRead(entry, now) {
+    if (entry === undefined)
+        return true;
+    if (entry.pending || entry.result?.status === "merged")
+        return false;
+    return now - entry.started >= 60000;
+}
+export function prObserver(settings) {
+    const state = {
+        settings,
+        clock: settings.clock ?? systemClock,
+        cache: new Map(),
+        queue: [],
+        active: null,
+        closed: false,
+    };
+    const configured = settings.repository !== null && Boolean(settings.command?.[0]?.trim());
+    const observe = (pullRequest) => {
+        if (!configured)
+            return { status: "unavailable", failure: "configuration" };
+        const identity = prIdentity(settings.repository, pullRequest);
+        if (identity === null)
+            return { status: "unavailable", failure: "identity" };
+        const key = JSON.stringify(identity);
+        const known = state.cache.get(key);
+        if (state.closed || !needsRead(known, state.clock.now()))
+            return known?.result ?? null;
+        const entry = {
+            identity,
+            result: known?.result ?? null,
+            started: Infinity,
+            pending: true,
+        };
+        state.cache.set(key, entry);
+        state.queue.push(entry);
+        pump(state);
+        return entry.result;
+    };
+    return {
+        observe,
+        close: () => {
+            state.closed = true;
+            state.queue.length = 0;
+            state.active?.abort();
+        },
+    };
+}

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

@@ -0,0 +1,8 @@
+import type { WatchCommandRunner } from "./watch-pr-command.ts";
+import { type PrObserver } from "./watch-pr-observer.ts";
+export interface WatchPrSettings {
+    readonly repository: string | undefined;
+    readonly githubCommand: string | undefined;
+    readonly execute: WatchCommandRunner;
+}
+export declare function watchPrObserver(settings: WatchPrSettings): Promise<PrObserver>;