cloving 1.2.0 → 1.4.0

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 {};

package/dist/src/report-flow.js

@@ -0,0 +1,193 @@
+import { reportReadyData } from "./report-ready.js";
+import { reportMetric, } from "./report-statistics.js";
+function overlaps(run, window) {
+    return run.start < window.end && (run.end ?? window.end) > window.start;
+}
+function busyShare(input, window) {
+    const queue = input.queue;
+    const runs = input.runs;
+    if (queue === null || runs === null)
+        return null;
+    const active = runs.filter((run) => overlaps(run, window));
+    if (active.some((run) => run.workflowId === null))
+        return null;
+    const own = active.filter((run) => run.workflowId === queue.workflowId);
+    const milliseconds = own.reduce((sum, run) => sum +
+        Math.max(0, Math.min(run.end ?? window.end, window.end) -
+            Math.max(run.start, window.start)), 0);
+    return {
+        at: window.start,
+        value: milliseconds / (queue.lanes * (window.end - window.start)),
+        evidence: {
+            workflowId: queue.workflowId,
+            lanes: queue.lanes,
+            runIds: own.map((run) => run.runId),
+        },
+    };
+}
+function peakRuns(runs, window) {
+    const points = runs
+        .filter((run) => overlaps(run, window) && (run.end === null || run.end > run.start))
+        .flatMap((run) => [
+        { at: Math.max(run.start, window.start), change: 1 },
+        { at: Math.min(run.end ?? window.end, window.end), change: -1 },
+    ])
+        .toSorted((a, b) => a.at - b.at || a.change - b.change);
+    let active = 0;
+    let peak = 0;
+    let peakAt = window.start;
+    for (const point of points) {
+        active += point.change;
+        if (active <= peak)
+            continue;
+        peak = active;
+        peakAt = point.at;
+    }
+    const runIds = runs
+        .filter((run) => run.start <= peakAt && (run.end ?? window.end) > peakAt)
+        .map((run) => run.runId);
+    return { at: window.start, value: peak, evidence: { runIds } };
+}
+function streaks(completions, window) {
+    const ended = completions
+        .filter((event) => event.at < window.end)
+        .toSorted((a, b) => a.at - b.at || a.sequence - b.sequence);
+    let current = [];
+    let inWindow = [];
+    let longest = [];
+    for (const event of ended) {
+        current = event.outcome === "completed" ? [] : [...current, event.runId];
+        if (event.at < window.start)
+            continue;
+        inWindow = event.outcome === "completed" ? [] : [...inWindow, event.runId];
+        if (inWindow.length > longest.length)
+            longest = inWindow;
+    }
+    return { current, longest };
+}
+function windowData(input, window) {
+    const busy = input.flow === undefined ? null : busyShare(input.flow, window);
+    const peak = input.flow?.runs == null ? null : peakRuns(input.flow.runs, window);
+    const streak = input.completions === null ? null : streaks(input.completions, window);
+    const waits = reportReadyData({ tickets: input.ready.tickets, flow: input.flow }, window);
+    return {
+        "flow.busyLaneShare": busy === null ? null : [busy],
+        "flow.peakActiveRuns": peak === null ? null : [peak],
+        "flow.unsuccessfulStreak.current": streak === null
+            ? null
+            : [
+                {
+                    at: window.start,
+                    value: streak.current.length,
+                    evidence: { runIds: streak.current },
+                },
+            ],
+        "flow.unsuccessfulStreak.longest": streak === null
+            ? null
+            : [
+                {
+                    at: window.start,
+                    value: streak.longest.length,
+                    evidence: { runIds: streak.longest },
+                },
+            ],
+        "flow.idleLaneHoursWithReadyTicket": waits.idle,
+        "flow.readyWaitHours.dependency": waits.dependency,
+        "flow.readyWaitHours.noLane": waits.noLane,
+    };
+}
+function sampleWindows(window) {
+    return [
+        window,
+        ...Array.from({ length: 7 }, (_, index) => ({
+            ...window,
+            start: window.start - (index + 1) * 86_400_000,
+            end: window.start - index * 86_400_000,
+        })),
+    ];
+}
+function metricWindow(name, input) {
+    const { window, ready } = input;
+    if (!name.includes("ReadyTicket") && !name.includes("readyWaitHours"))
+        return window;
+    const origin = ready.observedSince;
+    if (name.endsWith("dependency"))
+        return { ...window, observedSince: origin };
+    const observedSince = origin === null || window.observedSince === null
+        ? null
+        : Math.max(origin, window.observedSince);
+    return { ...window, observedSince };
+}
+function sampledMetrics(input, window) {
+    const windows = sampleWindows(window);
+    const samples = windows.map((sample) => windowData(input, sample));
+    const metrics = {};
+    for (const name of Object.keys(samples[0] ?? {})) {
+        const current = samples[0]?.[name];
+        const data = current == null
+            ? null
+            : samples.flatMap((sample, index) => sample[name] ?? [
+                {
+                    at: windows[index]?.start ?? window.start,
+                    value: null,
+                    evidence: {},
+                },
+            ]);
+        metrics[name] = reportMetric({
+            data,
+            window: metricWindow(name, { window, ready: input.ready }),
+            aggregation: name.includes("Hours") ? "count" : "median",
+        });
+    }
+    return metrics;
+}
+function workflowIds(input) {
+    const flow = input ?? { runs: [], queue: null, skips: [], workflows: [] };
+    const queue = flow.queue === null ? [] : [flow.queue.workflowId];
+    return new Set([
+        ...(flow.workflows ?? []),
+        ...(flow.skips ?? []).map((skip) => skip.workflowId),
+        ...(flow.runs ?? []).flatMap((run) => run.workflowId === null ? [] : [run.workflowId]),
+        ...queue,
+    ]);
+}
+function skipMetrics(input, window) {
+    const workflows = workflowIds(input);
+    const metrics = {
+        "flow.scheduleSkips": reportMetric({
+            data: input?.skips == null
+                ? null
+                : input.skips.map((skip) => ({
+                    at: skip.at,
+                    value: 1,
+                    evidence: {
+                        workflowId: skip.workflowId,
+                        sequence: skip.sequence,
+                    },
+                })),
+            window,
+            aggregation: "count",
+        }),
+    };
+    for (const workflowId of workflows)
+        metrics[`flow.scheduleSkips.${workflowId}`] = reportMetric({
+            data: input?.skips == null
+                ? null
+                : input.skips
+                    .filter((skip) => skip.workflowId === workflowId)
+                    .map((skip) => ({
+                    at: skip.at,
+                    value: 1,
+                    evidence: { workflowId, sequence: skip.sequence },
+                })),
+            window,
+            aggregation: "count",
+        });
+    return metrics;
+}
+export function reportFlowMetrics(input, window) {
+    return {
+        ...sampledMetrics(input, window),
+        ...skipMetrics(input.flow, window),
+    };
+}

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

@@ -0,0 +1,67 @@
+import type { Fields } from "./protocol.ts";
+import { type ReportDatum, type ReportWindow } from "./report-statistics.ts";
+export interface ReportOperatorInput {
+    readonly effects: readonly Fields[] | null;
+    readonly pulls: readonly ReportDatum[] | null;
+    readonly labels: readonly ReportDatum[] | null;
+}
+export declare function reportOperatorMetrics(input: ReportOperatorInput, window: ReportWindow): {
+    merges: {
+        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;
+            };
+        };
+    };
+    labelChanges: {
+        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-operator.js

@@ -0,0 +1,25 @@
+import { reportOperatorEffects } from "./report-effects.js";
+import { reportMetric, } from "./report-statistics.js";
+export function reportOperatorMetrics(input, window) {
+    const merges = reportOperatorEffects(input.effects, "merge");
+    const labels = reportOperatorEffects(input.effects, "label");
+    return {
+        merges: reportMetric({
+            data: merges === null || input.pulls === null
+                ? null
+                : input.pulls.filter((pull) => !merges.some((effect) => effect.at < window.end &&
+                    effect.number === pull.evidence["pullRequest"])),
+            window,
+            aggregation: "count",
+        }),
+        labelChanges: reportMetric({
+            data: labels === null || input.labels === null
+                ? null
+                : input.labels.filter((event) => !labels.some((effect) => effect.at < window.end &&
+                    effect.number === event.evidence["issue"] &&
+                    Math.abs(effect.at - event.at) <= 120_000)),
+            window,
+            aggregation: "count",
+        }),
+    };
+}