cloving 1.3.0 → 1.4.0

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

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

@@ -0,0 +1,221 @@
+import type { Fields } from "./protocol.ts";
+import { type ReportDatum, type ReportWindow } from "./report-statistics.ts";
+export interface QualityJob {
+    readonly id: number;
+    readonly runId: number;
+    readonly commit: string;
+    readonly name: string;
+    readonly attempt: number;
+    readonly at: number;
+    readonly conclusion: string | null;
+}
+export declare function reportFailureData(input: {
+    readonly jobs: readonly QualityJob[];
+    readonly names: Readonly<Record<number, readonly string[]>>;
+}): {
+    flaky: ReportDatum[];
+    real: ReportDatum[];
+};
+export interface ReportQualityData {
+    readonly effects?: readonly Fields[] | null;
+    readonly daemonObservedSince?: number | null;
+    readonly reopened?: readonly ReportDatum[] | null;
+    readonly reverts?: readonly ReportDatum[] | null;
+    readonly jobLogs?: {
+        readonly read: number;
+        readonly notRead: number;
+        readonly limit: number;
+        readonly maximumBytes: number;
+    } | null;
+    readonly mainFirstPass?: readonly ReportDatum[] | null;
+    readonly failures?: {
+        readonly flaky: readonly ReportDatum[];
+        readonly real: readonly ReportDatum[];
+    } | null;
+}
+export declare function reportQualityMetrics(input: ReportQualityData, window: ReportWindow): {
+    reviewScore: {
+        [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;
+                };
+            };
+        };
+    };
+    reopenedTickets: {
+        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;
+            };
+        };
+    };
+    revertedPullRequests: {
+        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;
+            };
+        };
+    };
+    jobLogs: {
+        readonly read: number;
+        readonly notRead: number;
+        readonly limit: number;
+        readonly maximumBytes: number;
+    } | {
+        status: string;
+    };
+    mainFirstPassShare: {
+        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;
+            };
+        };
+    };
+    flakyFailures: {
+        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;
+            };
+        };
+    };
+    realFailures: {
+        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-quality.js

@@ -0,0 +1,94 @@
+import { reportReviewScores } from "./report-effects.js";
+import { reportMetric, } from "./report-statistics.js";
+function later(left, right) {
+    if (left.runId === right.runId)
+        return left.attempt > right.attempt;
+    return left.at > right.at;
+}
+export function reportFailureData(input) {
+    const groups = new Map();
+    for (const job of input.jobs) {
+        const key = JSON.stringify([job.commit, job.name]);
+        const group = groups.get(key) ?? [];
+        group.push(job);
+        groups.set(key, group);
+    }
+    const flaky = [];
+    const real = [];
+    for (const jobs of groups.values()) {
+        const failed = jobs.filter((job) => job.conclusion === "failure");
+        const passed = jobs.filter((job) => job.conclusion === "success");
+        const flakyJobs = failed.filter((job) => passed.some((success) => later(success, job)));
+        const realJobs = failed.filter((job) => !passed.some((success) => later(success, job)));
+        const successes = passed.filter((job) => flakyJobs.some((failure) => later(job, failure)));
+        flaky.push(...failureDatum({
+            failed: flakyJobs,
+            passed: successes,
+            names: input.names,
+        }));
+        real.push(...failureDatum({ failed: realJobs, passed: [], names: input.names }));
+    }
+    return { flaky, real };
+}
+export function reportQualityMetrics(input, window) {
+    const reviewScore = reviewMetrics(input, window);
+    return {
+        reviewScore,
+        reopenedTickets: reportMetric({
+            data: input.reopened ?? null,
+            window,
+            aggregation: "count",
+        }),
+        revertedPullRequests: reportMetric({
+            data: input.reverts ?? null,
+            window,
+            aggregation: "count",
+        }),
+        jobLogs: input.jobLogs ?? { status: "unavailable" },
+        mainFirstPassShare: reportMetric({
+            data: input.mainFirstPass ?? null,
+            window,
+            aggregation: "mean",
+        }),
+        flakyFailures: reportMetric({
+            data: input.failures?.flaky ?? null,
+            window,
+            aggregation: "distinct",
+        }),
+        realFailures: reportMetric({
+            data: input.failures?.real ?? null,
+            window,
+            aggregation: "distinct",
+        }),
+    };
+}
+function reviewMetrics(input, window) {
+    const rounds = reportReviewScores(input.effects ?? null);
+    const reviewScore = Object.fromEntries(Object.entries(rounds ?? { round1: null }).map(([key, data]) => [
+        key,
+        reportMetric({
+            data,
+            window: { ...window, observedSince: input.daemonObservedSince ?? null },
+            aggregation: "median",
+        }),
+    ]));
+    return reviewScore;
+}
+function failureDatum(input) {
+    return input.failed.map((failed) => {
+        const passed = input.passed.filter((job) => later(job, failed));
+        const jobs = [failed, ...passed];
+        return {
+            at: failed.at,
+            value: 1,
+            key: JSON.stringify([failed.commit, failed.name]),
+            evidence: {
+                commit: failed.commit,
+                jobName: failed.name,
+                testNames: input.names[failed.id] ?? ["unknown"],
+                jobIds: jobs.map((job) => job.id),
+                runIds: [...new Set(jobs.map((job) => job.runId))],
+            },
+        };
+    });
+}

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

@@ -0,0 +1,23 @@
+import type { ReportFlow, ReportReadyTicket } from "./report-flow-types.ts";
+import type { ReportDatum, ReportWindow } from "./report-statistics.ts";
+interface ReadyInput {
+    readonly tickets: readonly ReportReadyTicket[] | null;
+    readonly flow: ReportFlow | undefined;
+}
+export declare function reportReadyData(input: ReadyInput, window: ReportWindow): {
+    dependency: null;
+    noLane: null;
+    idle: null;
+} | {
+    dependency: ReportDatum[];
+    noLane: ReportDatum[] | null;
+    idle: {
+        at: number;
+        value: number;
+        evidence: {
+            issues: number[];
+            runIds: string[];
+        };
+    }[] | null;
+};
+export {};