cloving 1.0.1 → 1.2.0

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

@@ -0,0 +1,150 @@
+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);
+        };
+    },
+};
+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 = observationOf(entry, {
+            result: timeout,
+            now: state.clock.now(),
+        });
+        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, now: state.clock.now() });
+    }
+    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;
+    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) => {
+        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);
+    };
+    readPr(state, { entry, controller }).then(completed, () => {
+        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;
+    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: [],
+        retryDeadlines: new Map(),
+        wake: null,
+        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 === undefined
+                ? { status: "pending" }
+                : currentObservation(state, known);
+        const entry = {
+            identity,
+            result: known?.result ?? null,
+            started: Infinity,
+            pending: true,
+        };
+        state.cache.set(key, entry);
+        state.queue.push(entry);
+        pump(state);
+        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-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>;

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

@@ -0,0 +1,47 @@
+import { prRepository } from "./watch-pr-identity.js";
+import { prObserver } from "./watch-pr-observer.js";
+function githubCommand(given) {
+    if (given === undefined)
+        return ["gh"];
+    try {
+        const parsed = JSON.parse(given);
+        if (!Array.isArray(parsed) ||
+            !parsed.every((part) => typeof part === "string"))
+            return null;
+        return parsed.map(String);
+    }
+    catch {
+        return null;
+    }
+}
+export async function watchPrObserver(settings) {
+    const directory = settings.repository;
+    const command = githubCommand(settings.githubCommand);
+    const output = directory === undefined
+        ? null
+        : await settings
+            .execute({
+            command: [
+                "git",
+                "config",
+                "--local",
+                "--get-all",
+                "remote.origin.url",
+            ],
+            directory,
+            signal: AbortSignal.timeout(5000),
+        })
+            .catch(() => null);
+    if (output?.errorCode === "ENOENT" || output?.errorCode === "EACCES")
+        return {
+            observe: () => ({ status: "unavailable", failure: "command" }),
+            close: () => undefined,
+        };
+    const repository = output?.status === 0 ? prRepository(output.stdout) : null;
+    return prObserver({
+        repository,
+        directory: directory ?? "",
+        command,
+        execute: settings.execute,
+    });
+}

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 }),
+    };
+}

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

@@ -1,4 +1,7 @@
+import { type PrRepository } from "./watch-pr-identity.ts";
+import { type WorkflowStages } from "../workflow-declaration.ts";
 import { type Fields } from "../protocol.ts";
+import { type WorkflowRefusal } from "../workflow-refusals.ts";
 interface ReadStatus extends Fields {
     readonly runId: string;
     readonly latestSequence: number;
@@ -13,8 +16,11 @@ interface ReadRun {
     readonly events: readonly ReadEvent[];
 }
 export interface WatchRead {
+    readonly queue?: Fields;
     readonly service: string;
     readonly workflows: readonly string[];
+    readonly workflowRefusals: readonly WorkflowRefusal[];
+    readonly workflowStages?: WorkflowStages;
     readonly summaries: readonly ReadStatus[];
     readonly runs: readonly ReadRun[];
     readonly completionCandidates: readonly ReadRun[];
@@ -24,5 +30,5 @@ export interface WatchReader {
     readonly read: (now: string) => Promise<WatchRead>;
     readonly run: (runId: string) => Promise<WatchRead>;
 }
-export declare function watchReader(runtimeDirectory: string): WatchReader;
+export declare function watchReader(runtimeDirectory: string, repository?: PrRepository | null): WatchReader;
 export {};

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

@@ -1,9 +1,13 @@
+import { establishedIssue } from "./watch-pr-identity.js";
+import { isWorkflowStages, } from "../workflow-declaration.js";
 import { record } from "../protocol.js";
 import { send } from "./client.js";
 import { activeRun, recentRun } from "./watch-board.js";
+import { workflowRefusals, } from "../workflow-refusals.js";
 const unavailable = {
     service: "down",
     workflows: [],
+    workflowRefusals: [],
     summaries: [],
     runs: [],
     completionCandidates: [],
@@ -79,13 +83,15 @@ async function creationOf(reader, runId) {
     }
     return null;
 }
-function matchingCompletion(status, ticketIds) {
-    const ticketId = status["ticketId"];
+function matchingCompletion(status, context) {
+    const issue = establishedIssue(context.repository, status["issueIdentity"]);
     return (status.state === "completed" &&
         status["workflowId"] === "develop-issue" &&
         record(status["outcome"])?.["kind"] === "handoff_requested" &&
-        typeof ticketId === "string" &&
-        ticketIds.has(ticketId));
+        record(status["outcome"])?.["ticketStatus"] !== "partial" &&
+        record(status["outcome"])?.["issueUpdate"] !== "failed" &&
+        issue !== null &&
+        context.issues.has(JSON.stringify(issue)));
 }
 async function completionOf(reader, search) {
     const { runId, latestSequence } = search.summary;
@@ -104,12 +110,16 @@ async function completionOf(reader, search) {
                 state: status.state,
                 workflowId: status["workflowId"],
                 ticketId: status["ticketId"],
+                issueIdentity: status["issueIdentity"],
                 outcome: status["outcome"],
             },
         };
         reader.completions.set(runId, known);
     }
-    if (!matchingCompletion(known.status, search.ticketIds))
+    if (!matchingCompletion(known.status, {
+        issues: search.issues,
+        repository: reader.repository,
+    }))
         return null;
     const creation = known.creation === undefined
         ? await creationOf(reader, runId)
@@ -117,11 +127,20 @@ async function completionOf(reader, search) {
     reader.completions.set(runId, { ...known, creation });
     return { status: known.status, events: creation === null ? [] : [creation] };
 }
+function refreshedLinks(run, status) {
+    const links = Object.fromEntries(["parentRunId", "chainId", "childRunIds"]
+        .filter((name) => Object.hasOwn(status, name))
+        .map((name) => [name, status[name]]));
+    return {
+        ...run,
+        status: { ...run.status, ...links },
+    };
+}
 async function detailed(reader, summary) {
     const { runId, latestSequence: sequence } = summary;
     const known = reader.details.get(runId);
     if (known !== undefined && known.sequence === sequence)
-        return known.value;
+        return refreshedLinks(known.value, summary);
     const shown = await asked(reader, {
         operation: "status",
         parameters: { runId },
@@ -158,10 +177,10 @@ async function decisionsOf(reader) {
     });
     return list(questions["decisions"]);
 }
-function stoppedTicketIds(runs, now) {
+function stoppedIssues(runs, context) {
     const stopped = runs
         .map((run) => run.status)
-        .filter((status) => recentRun(status.latestAt, now) &&
+        .filter((status) => recentRun(status.latestAt, context.now) &&
         status["workflowId"] === "develop-issue" &&
         (["failed", "cancelled"].includes(status.state) ||
             (status.state === "completed" &&
@@ -169,14 +188,15 @@ function stoppedTicketIds(runs, now) {
         .toSorted((first, second) => Date.parse(second.latestAt ?? "") - Date.parse(first.latestAt ?? ""))
         .slice(0, 20);
     return new Set(stopped.flatMap((status) => {
-        const ticketId = status["ticketId"];
-        return status.state === "completed" &&
-            typeof ticketId === "string" &&
-            ticketId !== ""
-            ? [ticketId]
+        const issue = establishedIssue(context.repository, status["issueIdentity"]);
+        return status.state === "completed" && issue !== null
+            ? [JSON.stringify(issue)]
             : [];
     }));
 }
+function stageMetadata(value) {
+    return Object.fromEntries(Object.entries(record(value) ?? {}).flatMap(([workflowId, stages]) => isWorkflowStages(stages) ? [[workflowId, stages]] : []));
+}
 async function service(reader, now) {
     const status = await asked(reader, {
         operation: "status",
@@ -190,20 +210,25 @@ async function service(reader, now) {
     const current = summaries.filter((summary) => activeRun(summary.state) || recentRun(summary.latestAt, now));
     for (const summary of current)
         runs.push(await detailed(reader, summary));
-    const ticketIds = stoppedTicketIds(runs, now);
-    const older = ticketIds.size === 0
+    const issues = stoppedIssues(runs, { now, repository: reader.repository });
+    const older = issues.size === 0
         ? []
         : summaries.filter((summary) => !recentRun(summary.latestAt, now) &&
             summary["workflowId"] === "develop-issue" &&
             summary.state === "completed");
     for (const summary of older) {
-        const candidate = await completionOf(reader, { summary, ticketIds });
+        const candidate = await completionOf(reader, { summary, issues });
         if (candidate !== null)
             completionCandidates.push(candidate);
     }
     return {
         service: "up",
+        ...(record(status["queue"]) === undefined
+            ? {}
+            : { queue: record(status["queue"]) ?? {} }),
         workflows: list(status["workflows"]).filter((value) => typeof value === "string"),
+        workflowStages: stageMetadata(status["workflowStages"]),
+        workflowRefusals: workflowRefusals(status["workflowRefusals"]),
         summaries,
         runs,
         completionCandidates,
@@ -222,7 +247,7 @@ async function singleRun(reader, runId) {
     const status = statusOf(reply.result["run"]);
     const known = reader.details.get(runId);
     const value = known !== undefined && known.sequence === status.latestSequence
-        ? known.value
+        ? refreshedLinks(known.value, status)
         : await remember(reader, status);
     return {
         ...unavailable,
@@ -231,9 +256,10 @@ async function singleRun(reader, runId) {
         decisions: await decisionsOf(reader),
     };
 }
-export function watchReader(runtimeDirectory) {
+export function watchReader(runtimeDirectory, repository = null) {
     const reader = {
         runtimeDirectory,
+        repository,
         details: new Map(),
         completions: new Map(),
     };

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

@@ -1,9 +1,17 @@
+import type { CardForm } from "./watch-run-input.ts";
+import type { WorkerUsage } from "../worker-usage.ts";
+import type { PrIdentity, PrObservation } from "./watch-pr-identity.ts";
+import type { WorkflowRefusal } from "../workflow-refusals.ts";
+import type { Fields } from "../protocol.ts";
 export interface WatchItem {
     readonly kind: string;
     readonly text: string;
     readonly costUsd?: number;
 }
 export interface WatchTurn {
+    readonly estimatedCostUsd: number | null;
+    readonly operationId: string;
+    readonly usage: WorkerUsage;
     readonly key: string;
     readonly runId: string;
     readonly target: string;
@@ -56,9 +64,14 @@ export interface WatchStep {
     readonly startedAt: string | null;
 }
 export interface WatchCard {
+    readonly parentRunId?: string | null;
+    readonly chainId?: string;
+    readonly childRunIds?: readonly string[];
+    readonly estimatedCostUsd: number | null;
     readonly runId: string;
     readonly title: string | null;
-    readonly claudeCostUsd: number;
+    readonly claudeCostUsd: number | null;
+    readonly usage: WorkerUsage;
     readonly currentStep: WatchStep | null;
     readonly endedAt: string | null;
     readonly decisionWaiting: boolean;
@@ -66,6 +79,7 @@ export interface WatchCard {
     readonly greptileScore: number | null;
     readonly pullRequestNumber: number | null;
     readonly completionMark: WatchCompletionMark | null;
+    readonly pullRequestObservation: PrObservation | null;
 }
 export interface WatchCompletionMark {
     readonly text: string;
@@ -83,11 +97,21 @@ export interface WatchWorkflow {
     readonly columns: readonly WatchColumn[];
 }
 export interface WatchRun {
+    readonly parentRunId?: string | null;
+    readonly chainId?: string;
+    readonly childRunIds?: readonly string[];
+    readonly mergeProof?: PrIdentity | null;
+    readonly issueIdentity?: PrIdentity | null;
+    readonly issueUpdate?: "failed";
+    readonly ticketStatus?: "complete" | "partial";
+    readonly promotionId?: string;
+    readonly estimatedCostUsd: number | null;
     readonly ticketId: string | null;
     readonly title: string | null;
     readonly outcome: string | null;
     readonly latestAt: string | null;
-    readonly claudeCostUsd: number;
+    readonly claudeCostUsd: number | null;
+    readonly usage: WorkerUsage;
     readonly currentStep: WatchStep;
     readonly round: number;
     readonly runId: string;
@@ -108,6 +132,9 @@ export interface WatchRun {
     readonly mergeCommit: string | null;
 }
 export interface WatchModel {
+    readonly queue?: Fields;
+    readonly workflowRefusals?: readonly WorkflowRefusal[];
+    readonly cardForms?: readonly CardForm[];
     readonly workflows: readonly WatchWorkflow[];
     readonly startWorkflowId: string | null;
     readonly updatedAt: string;

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

@@ -1,3 +1,4 @@
+import { priceText } from "./usage-render.js";
 export function counted(count, noun) {
     return `${String(count)} ${noun}${count === 1 ? "" : "s"}`;
 }
@@ -49,7 +50,7 @@ export function runTone(run) {
     return toneOf(run.state);
 }
 export function runName(run) {
-    return run.turns[0]?.target ?? run.runId.slice(0, 12);
+    return run.turns[0]?.target || run.runId.slice(0, 12);
 }
 export function waitingDetail(run, now) {
     const opened = run.phases.find((phase) => phase.state === "active");
@@ -60,7 +61,7 @@ export function waitingDetail(run, now) {
 export function completedDetail(run) {
     const [first] = run.events;
     const last = run.events.at(-1);
-    const cost = run.turns.reduce((sum, turn) => sum + (turn.costUsd ?? 0), 0);
+    const cost = priceText(run.claudeCostUsd, run.estimatedCostUsd);
     const time = first === undefined || last === undefined
         ? ""
         : ` in ${elapsed(first.recordedAt, last.recordedAt)}`;
@@ -68,7 +69,14 @@ export function completedDetail(run) {
         approved: "You approved the work. ",
         denied: "You denied the work. ",
     };
-    return `${verdicts[run.decision] ?? ""}The run completed${time} · cost ${cost.toFixed(2)} USD.`;
+    const ticket = run.ticketStatus === undefined
+        ? ""
+        : ` Ticket status: ${run.ticketStatus}.`;
+    const update = run.issueUpdate === "failed"
+        ? " Issue status update failed; check the GitHub operation."
+        : "";
+    const promotion = run.promotionId === undefined ? "" : ` Promotion: ${run.promotionId}.`;
+    return `${verdicts[run.decision] ?? ""}The run completed${time} · cost ${cost}.${promotion}${ticket}${update}`;
 }
 export function phaseTime(phase, now) {
     if (phase.startedAt === null)

package/dist/src/cli/watch-run-input.d.ts

@@ -0,0 +1,14 @@
+import { type ServiceRequest } from "../protocol.ts";
+export interface CardField {
+    readonly name: string;
+    readonly label: string;
+    readonly multiline: boolean;
+    readonly optional: boolean;
+}
+export interface CardForm {
+    readonly workflowId: string;
+    readonly source: "ticket" | "prompt" | "input";
+    readonly fields: readonly CardField[];
+}
+export declare function builtinCardForms(): readonly CardForm[];
+export declare function cardRunRequest(forms: readonly CardForm[], value: unknown): ServiceRequest | null;