cloving 1.3.0 → 1.4.0

package/dist/src/project-settings.js

@@ -1,11 +1,13 @@
-import { configuration } from "./configuration-schema.js";
+import { configuration, } from "./configuration-schema.js";
 export const settingVariables = {
     "checks.beforeMerge": "CLOVING_CHECK_COMMAND",
     "checks.required": "CLOVING_REQUIRED_CHECKS",
+    "checks.redGreen": "CLOVING_RED_GREEN",
     "tickets.command": "CLOVING_TICKET_COMMAND",
     "tickets.nextCommand": "CLOVING_NEXT_COMMAND",
     "queue.everySeconds": "CLOVING_QUEUE_SECONDS",
     "queue.lanes": "CLOVING_QUEUE_LANES",
+    "queue.dailySpendLimitUsd": "CLOVING_QUEUE_DAILY_SPEND_USD",
     "harness.name": "CLOVING_WORKER",
     fallbackModels: "CLOVING_FALLBACK_MODELS",
     tokenPrices: "CLOVING_TOKEN_PRICES",

package/dist/src/queue-spend.d.ts

@@ -0,0 +1,4 @@
+export declare function queueSpending(costs: readonly number[], limitUsd: number): {
+    readonly spentUsd: number;
+    readonly holding: boolean;
+};

package/dist/src/queue-spend.js

@@ -0,0 +1,21 @@
+function decimal(value) {
+    const [mantissa = "0", exponent = "0"] = String(value).split("e");
+    const fraction = mantissa.split(".")[1]?.length ?? 0;
+    return {
+        units: BigInt(mantissa.replace(".", "")),
+        exponent: Number(exponent) - fraction,
+    };
+}
+function scaled(value, exponent) {
+    return value.units * 10n ** BigInt(value.exponent - exponent);
+}
+export function queueSpending(costs, limitUsd) {
+    const prices = costs.map(decimal);
+    const limit = decimal(limitUsd);
+    const exponent = prices.reduce((smallest, price) => Math.min(smallest, price.exponent), limit.exponent);
+    const total = prices.reduce((sum, price) => sum + scaled(price, exponent), 0n);
+    return {
+        spentUsd: Number(`${String(total)}e${String(exponent)}`),
+        holding: total * 100n >= scaled(limit, exponent) * 85n,
+    };
+}

package/dist/src/relay/relay-service.d.ts

@@ -1,5 +1,7 @@
+import type { Reply } from "../protocol.ts";
 import { type InboxTiming } from "./answer-inbox.ts";
 import { type WatchTiming } from "./decision-watch.ts";
+import { type OperationState } from "./phone-operations.ts";
 import { type HeartbeatTiming } from "./relay-heartbeat.ts";
 export interface RelayPaths {
     readonly runtimeDirectory: string;
@@ -16,6 +18,7 @@ export interface RelayOptions extends RelayPaths {
 export interface Relay {
     readonly close: () => Promise<void>;
 }
+export declare function phoneState(relay: OperationState): Promise<Reply>;
 export declare function computerName(name: string): string;
 export declare function startRelay(options: RelayOptions): Promise<Relay>;
 export interface RelayProgram {

package/dist/src/relay/relay-service.js

@@ -41,15 +41,17 @@ function pairingView(open) {
             },
     };
 }
-async function phoneState(relay) {
-    const link = await readLink(relay.context.phoneDirectory);
+export async function phoneState(relay) {
+    const stored = await readLink(relay.context.phoneDirectory);
+    const lost = relay.registration.lost;
+    const link = lost ? undefined : stored;
     return result({
         registered: link !== undefined,
         daemonId: link?.daemonId ?? null,
         origin: link?.origin ?? null,
         pairing: pairingView(relay.sessions.current()),
         refusal: relay.sessions.refusal(),
-        reason: relay.registration.lost ? "registration-lost" : null,
+        reason: lost ? "registration-lost" : null,
         devices: (await relay.store.devices()).map((device) => ({
             deviceId: device.deviceId,
             name: device.name,

package/dist/src/report-ci.d.ts

@@ -0,0 +1,164 @@
+import { type ReportDatum, type ReportWindow } from "./report-statistics.ts";
+export declare const runnerKinds: readonly ["localMacos", "localLinux", "hostedMacos", "hostedLinux"];
+export type RunnerKind = (typeof runnerKinds)[number];
+export type RunnerData = Readonly<Record<RunnerKind, readonly ReportDatum[]>>;
+export interface ReportCiData {
+    readonly jobMinutes: RunnerData | null;
+    readonly jobLimitShare: RunnerData | null;
+    readonly runnerWaitMinutes: RunnerData | null;
+    readonly timeouts: readonly ReportDatum[] | null;
+    readonly reruns: readonly ReportDatum[] | null;
+}
+export declare function reportCiMetrics(input: ReportCiData | undefined, window: ReportWindow): {
+    jobMinutes: {
+        [k: string]: {
+            evidence: Readonly<Record<string, unknown>>[];
+            mark?: string;
+            status: string;
+            value: number | null;
+            comparisonValue: number | null;
+            baseline: {
+                evidence: Readonly<Record<string, unknown>>[];
+                history: string;
+                days: number;
+                median: null;
+                band: null;
+            } | {
+                evidence: Readonly<Record<string, unknown>>[];
+                history: string;
+                days: number;
+                median: number;
+                band: null;
+            } | {
+                evidence: Readonly<Record<string, unknown>>[];
+                history: string;
+                days: number;
+                median: number;
+                band: {
+                    low: number;
+                    high: number;
+                };
+            };
+        };
+    };
+    jobLimitShare: {
+        [k: string]: {
+            evidence: Readonly<Record<string, unknown>>[];
+            mark?: string;
+            status: string;
+            value: number | null;
+            comparisonValue: number | null;
+            baseline: {
+                evidence: Readonly<Record<string, unknown>>[];
+                history: string;
+                days: number;
+                median: null;
+                band: null;
+            } | {
+                evidence: Readonly<Record<string, unknown>>[];
+                history: string;
+                days: number;
+                median: number;
+                band: null;
+            } | {
+                evidence: Readonly<Record<string, unknown>>[];
+                history: string;
+                days: number;
+                median: number;
+                band: {
+                    low: number;
+                    high: number;
+                };
+            };
+        };
+    };
+    runnerWaitMinutes: {
+        [k: string]: {
+            evidence: Readonly<Record<string, unknown>>[];
+            mark?: string;
+            status: string;
+            value: number | null;
+            comparisonValue: number | null;
+            baseline: {
+                evidence: Readonly<Record<string, unknown>>[];
+                history: string;
+                days: number;
+                median: null;
+                band: null;
+            } | {
+                evidence: Readonly<Record<string, unknown>>[];
+                history: string;
+                days: number;
+                median: number;
+                band: null;
+            } | {
+                evidence: Readonly<Record<string, unknown>>[];
+                history: string;
+                days: number;
+                median: number;
+                band: {
+                    low: number;
+                    high: number;
+                };
+            };
+        };
+    };
+    timeouts: {
+        evidence: Readonly<Record<string, unknown>>[];
+        mark?: string;
+        status: string;
+        value: number | null;
+        comparisonValue: number | null;
+        baseline: {
+            evidence: Readonly<Record<string, unknown>>[];
+            history: string;
+            days: number;
+            median: null;
+            band: null;
+        } | {
+            evidence: Readonly<Record<string, unknown>>[];
+            history: string;
+            days: number;
+            median: number;
+            band: null;
+        } | {
+            evidence: Readonly<Record<string, unknown>>[];
+            history: string;
+            days: number;
+            median: number;
+            band: {
+                low: number;
+                high: number;
+            };
+        };
+    };
+    reruns: {
+        evidence: Readonly<Record<string, unknown>>[];
+        mark?: string;
+        status: string;
+        value: number | null;
+        comparisonValue: number | null;
+        baseline: {
+            evidence: Readonly<Record<string, unknown>>[];
+            history: string;
+            days: number;
+            median: null;
+            band: null;
+        } | {
+            evidence: Readonly<Record<string, unknown>>[];
+            history: string;
+            days: number;
+            median: number;
+            band: null;
+        } | {
+            evidence: Readonly<Record<string, unknown>>[];
+            history: string;
+            days: number;
+            median: number;
+            band: {
+                low: number;
+                high: number;
+            };
+        };
+    };
+};

package/dist/src/report-ci.js

@@ -0,0 +1,32 @@
+import { reportMetric, } from "./report-statistics.js";
+export const runnerKinds = [
+    "localMacos",
+    "localLinux",
+    "hostedMacos",
+    "hostedLinux",
+];
+export function reportCiMetrics(input, window) {
+    const runners = (data) => Object.fromEntries(runnerKinds.map((kind) => [
+        kind,
+        reportMetric({
+            data: data?.[kind] ?? null,
+            window,
+            aggregation: "median",
+        }),
+    ]));
+    return {
+        jobMinutes: runners(input?.jobMinutes),
+        jobLimitShare: runners(input?.jobLimitShare),
+        runnerWaitMinutes: runners(input?.runnerWaitMinutes),
+        timeouts: reportMetric({
+            data: input?.timeouts ?? null,
+            window,
+            aggregation: "count",
+        }),
+        reruns: reportMetric({
+            data: input?.reruns ?? null,
+            window,
+            aggregation: "count",
+        }),
+    };
+}

package/dist/src/report-effects.d.ts

@@ -0,0 +1,15 @@
+import { type Fields } from "./protocol.ts";
+import type { ReportDatum } from "./report-statistics.ts";
+export declare function reportFixRounds(events: readonly Fields[] | null): ReportDatum[] | null;
+export declare function reportPhaseTimes(events: readonly Fields[] | null, method: string): ReportDatum[] | null;
+export declare function reportEffectData(events: readonly Fields[] | null): {
+    fixRounds: ReportDatum[] | null;
+    workerTurn: ReportDatum[] | null;
+    codeReview: ReportDatum[] | null;
+    merge: ReportDatum[] | null;
+};
+export declare function reportReviewScores(events: readonly Fields[] | null): Record<string, ReportDatum[]> | null;
+export declare function reportOperatorEffects(events: readonly Fields[] | null, method: "merge" | "label"): {
+    number: number;
+    at: number;
+}[] | null;

package/dist/src/report-effects.js

@@ -0,0 +1,212 @@
+import { record } from "./protocol.js";
+function payloadOf(event) {
+    return record(event["payload"]) ?? {};
+}
+function resultOf(value) {
+    const parsed = typeof value === "string" ? JSON.parse(value) : value;
+    const result = record(parsed);
+    if (result === undefined)
+        throw new Error("invalid-report-effect-result");
+    return result;
+}
+function requestsOf(events) {
+    const requests = new Map();
+    for (const event of events) {
+        if (event["type"] !== "effect.requested")
+            continue;
+        const key = effectKey(event);
+        if (!requests.has(key))
+            requests.set(key, event);
+    }
+    return requests;
+}
+function effectKey(event) {
+    return JSON.stringify([event["runId"], payloadOf(event)["operationId"]]);
+}
+function pairsOf(events, requests) {
+    return events.flatMap((report) => {
+        if (report["type"] !== "effect.reported")
+            return [];
+        const request = requests.get(effectKey(report));
+        if (request === undefined)
+            throw new Error("missing-report-effect-request");
+        return [{ request, report }];
+    });
+}
+function historyOf(events) {
+    if (events === null)
+        return null;
+    try {
+        const requests = requestsOf(events);
+        const runs = new Map();
+        for (const request of requests.values()) {
+            const runId = request["runId"];
+            if (typeof runId !== "string")
+                throw new Error("invalid-report-run-id");
+            const own = runs.get(runId) ?? [];
+            own.push(request);
+            runs.set(runId, own);
+        }
+        return { pairs: pairsOf(events, requests), runs };
+    }
+    catch {
+        return null;
+    }
+}
+function fixRoundDatum(pair, requests) {
+    const { request, report } = pair;
+    const payload = payloadOf(report);
+    if (payloadOf(request)["method"] !== "merge" ||
+        payload["outcome"] !== "completed")
+        return [];
+    const result = resultOf(payload["result"]);
+    if (!mergedResult(result["merged"]))
+        return [];
+    const own = requests;
+    const opened = own.find((item) => payloadOf(item)["method"] === "open-pr");
+    const rounds = opened === undefined
+        ? null
+        : own.filter((item) => payloadOf(item)["method"] === "run-turn" &&
+            Number(item["sequence"]) > Number(opened["sequence"]) &&
+            Number(item["sequence"]) < Number(report["sequence"])).length;
+    return [
+        {
+            at: Number(report["at"]),
+            value: rounds,
+            evidence: {
+                runId: report["runId"],
+                pullRequest: result["number"] ?? resultOf(payloadOf(request)["payload"])["number"],
+                operationId: payload["operationId"],
+                fixRounds: rounds,
+            },
+        },
+    ];
+}
+function fixRounds(history) {
+    if (history === null)
+        return null;
+    try {
+        return history.pairs.flatMap((pair) => {
+            const runId = pair.report["runId"];
+            if (typeof runId !== "string")
+                throw new Error("invalid-report-run-id");
+            return fixRoundDatum(pair, history.runs.get(runId) ?? []);
+        });
+    }
+    catch {
+        return null;
+    }
+}
+function phaseTimes(history, method) {
+    if (history === null)
+        return null;
+    return history.pairs.flatMap(({ request, report }) => {
+        if (payloadOf(request)["method"] !== method)
+            return [];
+        const at = Number(report["at"]);
+        const minutes = (at - Number(request["at"])) / 60_000;
+        return [
+            {
+                at,
+                value: Number.isFinite(minutes) && minutes >= 0 ? minutes : null,
+                evidence: {
+                    runId: report["runId"],
+                    operationId: payloadOf(report)["operationId"],
+                },
+            },
+        ];
+    });
+}
+export function reportFixRounds(events) {
+    return fixRounds(historyOf(events));
+}
+export function reportPhaseTimes(events, method) {
+    return phaseTimes(historyOf(events), method);
+}
+export function reportEffectData(events) {
+    const history = historyOf(events);
+    return {
+        fixRounds: fixRounds(history),
+        workerTurn: phaseTimes(history, "run-turn"),
+        codeReview: phaseTimes(history, "wait-review"),
+        merge: phaseTimes(history, "merge"),
+    };
+}
+function mergedResult(value) {
+    return (value === true ||
+        (typeof value === "string" && /^[a-f0-9]{40}$/i.test(value)));
+}
+export function reportReviewScores(events) {
+    const history = historyOf(events);
+    if (history === null)
+        return null;
+    const rounds = { round1: [] };
+    for (const { request, report } of history.pairs) {
+        if (payloadOf(request)["method"] !== "wait-review")
+            continue;
+        const own = history.runs.get(String(request["runId"])) ?? [];
+        const round = own.filter((event) => payloadOf(event)["method"] === "wait-review" &&
+            Number(event["sequence"]) <= Number(request["sequence"])).length;
+        const key = `round${String(round)}`;
+        const data = rounds[key] ?? [];
+        const score = reviewScoreOf(report);
+        data.push({
+            at: Number(report["at"]),
+            value: score,
+            evidence: {
+                runId: report["runId"],
+                operationId: payloadOf(report)["operationId"],
+                sequence: report["sequence"],
+                round,
+                score,
+            },
+        });
+        rounds[key] = data;
+    }
+    return rounds;
+}
+function reviewScoreOf(report) {
+    let score = null;
+    try {
+        const result = resultOf(payloadOf(report)["result"]);
+        const value = result["score"];
+        if (payloadOf(report)["outcome"] === "completed" &&
+            typeof value === "number" &&
+            Number.isFinite(value) &&
+            value >= 0 &&
+            value <= 5)
+            score = value;
+    }
+    catch {
+        score = null;
+    }
+    return score;
+}
+export function reportOperatorEffects(events, method) {
+    const history = historyOf(events);
+    if (history === null)
+        return null;
+    try {
+        return history.pairs.flatMap(({ request, report }) => {
+            const requested = payloadOf(request);
+            const reported = payloadOf(report);
+            if (requested["method"] !== method)
+                return [];
+            if (method === "merge" &&
+                (reported["outcome"] !== "completed" ||
+                    !mergedResult(resultOf(reported["result"])["merged"])))
+                return [];
+            const number = resultOf(requested["payload"])["number"];
+            const at = Number(report["at"]);
+            if (typeof number !== "number" ||
+                !Number.isSafeInteger(number) ||
+                number < 1 ||
+                !Number.isFinite(at))
+                throw new Error("invalid-report-effect");
+            return [{ number, at }];
+        });
+    }
+    catch {
+        return null;
+    }
+}

package/dist/src/report-flow-types.d.ts

@@ -0,0 +1,38 @@
+export declare const reportOutcomes: readonly ["completed", "partial", "blocked", "failed", "cancelled"];
+export type ReportOutcome = (typeof reportOutcomes)[number];
+export interface ReportCompletion {
+    readonly runId: string;
+    readonly sequence: number;
+    readonly at: number;
+    readonly outcome: ReportOutcome;
+}
+export interface ReportFlowRun {
+    readonly runId: string;
+    readonly workflowId: string | null;
+    readonly start: number;
+    readonly end: number | null;
+}
+export interface ReportFlow {
+    readonly queue: {
+        readonly workflowId: string;
+        readonly lanes: number;
+    } | null;
+    readonly runs: readonly ReportFlowRun[] | null;
+    readonly workflows?: readonly string[];
+    readonly skips?: readonly {
+        readonly workflowId: string;
+        readonly at: number;
+        readonly sequence: number;
+    }[] | null;
+}
+export interface ReportReadyTicket {
+    readonly issue: number;
+    readonly intervals: readonly {
+        readonly start: number;
+        readonly end: number | null;
+    }[];
+    readonly dependencies: readonly {
+        readonly issue: number;
+        readonly closedAt: number | null;
+    }[];
+}

package/dist/src/report-flow-types.js

@@ -0,0 +1,7 @@
+export const reportOutcomes = [
+    "completed",
+    "partial",
+    "blocked",
+    "failed",
+    "cancelled",
+];

package/dist/src/report-flow.d.ts

@@ -0,0 +1,43 @@
+import type { ReportCompletion, ReportFlow, ReportReadyTicket } from "./report-flow-types.ts";
+import { type ReportWindow } from "./report-statistics.ts";
+interface FlowInput {
+    readonly flow: ReportFlow | undefined;
+    readonly completions: readonly ReportCompletion[] | null;
+    readonly ready: ReadyInput;
+}
+interface ReadyInput {
+    readonly tickets: readonly ReportReadyTicket[] | null;
+    readonly observedSince: number | null;
+}
+export declare function reportFlowMetrics(input: FlowInput, window: ReportWindow): {
+    [x: string]: {
+        evidence: Readonly<Record<string, unknown>>[];
+        mark?: string;
+        status: string;
+        value: number | null;
+        comparisonValue: number | null;
+        baseline: {
+            evidence: Readonly<Record<string, unknown>>[];
+            history: string;
+            days: number;
+            median: null;
+            band: null;
+        } | {
+            evidence: Readonly<Record<string, unknown>>[];
+            history: string;
+            days: number;
+            median: number;
+            band: null;
+        } | {
+            evidence: Readonly<Record<string, unknown>>[];
+            history: string;
+            days: number;
+            median: number;
+            band: {
+                low: number;
+                high: number;
+            };
+        };
+    };
+};
+export {};