cloving 1.3.0 → 1.4.0

package/dist/src/cli/report-github.js

@@ -1,102 +1,93 @@
+import { readOperatorLabels } from "./report-operator.js";
+import { readClosureHistory } from "./report-closures.js";
+import { readCiJobs } from "./report-ci-jobs.js";
+import { reportFailureData } from "../report-quality.js";
+import { readCiUsage } from "./report-ci-usage.js";
+import { ciRuns, mainRuns, firstPassData } from "./report-ci.js";
+import { repositoryReader, issueTimeline, rows, identity, timestamp, reportSource as source, } from "./report-github-reader.js";
+import { readyTicketsOf } from "./report-ready.js";
+function unavailableGithub() {
+    const unavailable = {
+        status: "unavailable",
+        reason: "configuration-or-identity",
+    };
+    return {
+        labels: null,
+        ciUsage: null,
+        reopened: null,
+        reverts: null,
+        jobLogs: null,
+        failures: null,
+        mainFirstPass: null,
+        observedSince: null,
+        issues: null,
+        pulls: null,
+        leadTimes: null,
+        ready: null,
+        sources: {
+            labels: unavailable,
+            jobs: unavailable,
+            ci: unavailable,
+            ciUsage: unavailable,
+            ciUsageJobs: unavailable,
+            ciUsageWorkflows: unavailable,
+            ready: unavailable,
+            issues: unavailable,
+            pulls: unavailable,
+            history: unavailable,
+            timelines: unavailable,
+        },
+    };
+}
 export async function readReportGithub(input) {
     const reader = await repositoryReader(input).catch(() => null);
     if (reader === null)
-        return {
-            observedSince: null,
-            issues: null,
-            pulls: null,
-            sources: {
-                issues: { status: "unavailable", reason: "configuration-or-identity" },
-                pulls: { status: "unavailable", reason: "configuration-or-identity" },
-                history: { status: "unavailable", reason: "configuration-or-identity" },
-            },
-        };
-    const [issues, pulls, history] = await Promise.allSettled([
-        issuesOf(reader, input.since),
+        return unavailableGithub();
+    const runsRead = mainRuns(reader, {
+        since: input.since,
+        activity: "created",
+    });
+    const issueRead = readClosureHistory(reader, input.since);
+    const [issues, pulls, history, timelines, ready, ci, jobs, ciUsage, labels] = await Promise.allSettled([
+        issueRead,
         pullsOf(reader, input.since),
         repositoryCreatedAt(reader),
+        issueRead.then((values) => leadTimesOf(reader, { issues: values.completed, since: input.since })),
+        readyTicketsOf(reader),
+        runsRead.then((runs) => firstPassData(reader, runs)),
+        mainRuns(reader, { since: input.since, activity: "updated" }).then((runs) => readCiJobs(reader, runs)),
+        ciRuns(reader, { since: input.since, activity: "updated" }).then((runs) => readCiUsage(reader, runs)),
+        readOperatorLabels(reader, input.since),
     ]);
     return {
+        labels: settledValue(labels),
+        reopened: issues.status === "fulfilled" ? issues.value.reopened : null,
+        reverts: pulls.status === "fulfilled" ? pulls.value.reverts : null,
+        ...ciSourceData({ jobs, ci, ciUsage }),
         observedSince: history.status === "fulfilled" ? history.value : null,
-        issues: issues.status === "fulfilled" ? issues.value : null,
-        pulls: pulls.status === "fulfilled" ? pulls.value : null,
+        issues: issues.status === "fulfilled" ? issues.value.completed : null,
+        pulls: pulls.status === "fulfilled" ? pulls.value.pulls : null,
+        ready: ready.status === "fulfilled" ? ready.value : null,
+        leadTimes: timelines.status === "fulfilled" ? timelines.value : null,
         sources: {
+            labels: source(labels),
+            jobs: source(jobs),
+            ci: source(ci),
+            ciUsage: source(ciUsage),
+            ...(ciUsage.status === "fulfilled"
+                ? ciUsage.value.sources
+                : { ciUsageJobs: source(ciUsage), ciUsageWorkflows: source(ciUsage) }),
+            ready: source(ready),
             issues: source(issues),
             pulls: source(pulls),
             history: source(history),
+            timelines: source(timelines),
         },
     };
 }
 import { record } from "../protocol.js";
-import { githubRetry } from "./github-retry.js";
-import { prRepository } from "./watch-pr-identity.js";
-function commandOf(value) {
-    const command = JSON.parse(value ?? '["gh"]');
-    if (!Array.isArray(command) ||
-        command.length === 0 ||
-        !command.every((part) => typeof part === "string" && part !== "" && !part.includes("\0")))
-        throw new Error("configuration");
-    return command.map(String);
-}
-function rows(value) {
-    if (!Array.isArray(value))
-        throw new Error("response");
-    return value.map((item) => {
-        const row = record(item);
-        if (row === undefined)
-            throw new Error("response");
-        return row;
-    });
-}
-function identity(row, context) {
-    const { repository, kind } = context;
-    const number = row["number"];
-    const url = row["html_url"];
-    if (typeof number !== "number" ||
-        !Number.isSafeInteger(number) ||
-        number <= 0 ||
-        typeof url !== "string" ||
-        url.toLowerCase() !==
-            `https://${repository.host}/${repository.owner}/${repository.repository}/${kind}/${String(number)}`)
-        throw new Error("identity");
-    return number;
-}
-function timestamp(value) {
-    if (typeof value !== "string" || !Number.isFinite(Date.parse(value)))
-        throw new Error("response");
-    return Date.parse(value);
-}
-async function issuesOf(reader, since) {
-    const result = [];
-    const seen = new Set();
-    for (let page = 1;; page += 1) {
-        const values = rows(await reader.read(`issues?state=closed&since=${encodeURIComponent(since)}&per_page=100&page=${String(page)}`, [
-            "--jq",
-            'map({number, html_url, closed_at, state, state_reason} + (if has("pull_request") then {pull_request: {}} else {} end))',
-        ]));
-        for (const row of values) {
-            if (Object.hasOwn(row, "pull_request"))
-                continue;
-            const number = identity(row, {
-                repository: reader.repository,
-                kind: "issues",
-            });
-            if (seen.has(number))
-                throw new Error("response");
-            seen.add(number);
-            if (!completedIssue(row))
-                continue;
-            result.push({
-                at: timestamp(row["closed_at"]),
-                value: 1,
-                evidence: { issue: number },
-            });
-        }
-        if (values.length < 100)
-            return result;
-    }
-}
 async function pullsOf(reader, since) {
+    const reverts = [];
     const result = [];
     const seen = new Set();
     for (let page = 1;; page += 1) {
@@ -112,77 +103,24 @@ async function pullsOf(reader, since) {
             timestamp(row["updated_at"]);
             if (row["merged_at"] === null)
                 continue;
-            result.push({
+            const datum = {
                 at: timestamp(row["merged_at"]),
                 value: 1,
                 evidence: { pullRequest: number },
-            });
+            };
+            result.push(datum);
+            reverts.push(...revertOf(row, datum));
         }
         if (values.length < 100 ||
             values.some((row) => Date.parse(String(row["updated_at"])) < Date.parse(since)))
-            return result;
+            return {
+                pulls: result,
+                reverts: reverts.includes(null)
+                    ? null
+                    : reverts.filter((item) => item !== null),
+            };
     }
 }
-async function repositoryReader(input) {
-    const settings = input.settings;
-    if (settings?.repository === undefined)
-        throw new Error("configuration");
-    const command = commandOf(settings.githubCommand);
-    const signal = AbortSignal.timeout(120_000);
-    const origin = await settings.execute({
-        command: ["git", "config", "--local", "--get-all", "remote.origin.url"],
-        directory: settings.repository,
-        signal,
-    });
-    const repository = origin.status === 0 && origin.errorCode === null
-        ? prRepository(origin.stdout)
-        : null;
-    if (repository === null)
-        throw new Error("identity");
-    const directory = settings.repository;
-    return {
-        repository,
-        read: async (endpoint, flags = []) => {
-            const output = await githubRetry({
-                signal,
-                pollMilliseconds: input.retryMilliseconds ?? 30_000,
-                action: async () => {
-                    const output = await settings.execute({
-                        directory,
-                        signal,
-                        command: [
-                            ...command,
-                            "api",
-                            "--method",
-                            "GET",
-                            "--hostname",
-                            repository.host,
-                            `repos/${repository.owner}/${repository.repository}${endpoint === "" ? "" : `/${endpoint}`}`,
-                            ...flags,
-                        ],
-                    });
-                    if (output.status !== 0 || output.errorCode !== null)
-                        throw Object.assign(new Error("github-call-failed"), {
-                            status: Number(/\(HTTP (\d{3})\)/.exec(output.stderr)?.[1]),
-                            detail: output.stderr,
-                        });
-                    return output.stdout;
-                },
-            });
-            const parsed = JSON.parse(output);
-            return parsed;
-        },
-    };
-}
-function source(result) {
-    if (result.status === "fulfilled")
-        return { status: "available" };
-    const reason = result.reason instanceof Error &&
-        result.reason.message === "github-network-failed"
-        ? "github-network-failed"
-        : "read-failed";
-    return { status: "unavailable", reason };
-}
 async function repositoryCreatedAt(reader) {
     const repository = record(await reader.read(""));
     const name = repository?.["full_name"];
@@ -192,9 +130,52 @@ async function repositoryCreatedAt(reader) {
         throw new Error("identity");
     return timestamp(repository?.["created_at"]);
 }
-function completedIssue(row) {
-    if (row["state"] !== "closed" ||
-        !["completed", "not_planned", "duplicate"].includes(String(row["state_reason"])))
-        throw new Error("response");
-    return row["state_reason"] === "completed";
+async function lastReadyAt(reader, issue) {
+    let ready = null;
+    for (const row of await issueTimeline(reader, Number(issue.evidence["issue"]))) {
+        if (!readyLabel(row))
+            continue;
+        const at = timestamp(row["created_at"]);
+        if (at <= issue.at && (ready === null || at > ready))
+            ready = at;
+    }
+    return ready;
+}
+async function leadTimesOf(reader, input) {
+    const result = [];
+    for (const issue of input.issues.filter((item) => item.at >= Date.parse(input.since))) {
+        const ready = await lastReadyAt(reader, issue);
+        result.push({
+            at: issue.at,
+            value: ready === null ? null : (issue.at - ready) / 3_600_000,
+            evidence: {
+                ...issue.evidence,
+                readyAt: ready === null ? null : new Date(ready).toISOString(),
+                closedAt: new Date(issue.at).toISOString(),
+            },
+        });
+    }
+    return result;
+}
+function readyLabel(row) {
+    return (row["event"] === "labeled" &&
+        record(row["label"])?.["name"] === "cloving: ready");
+}
+function ciSourceData(input) {
+    const { jobs, ci, ciUsage } = input;
+    return {
+        ciUsage: ciUsage.status === "fulfilled" ? ciUsage.value.data : null,
+        jobLogs: jobs.status === "fulfilled" ? jobs.value.jobLogs : null,
+        failures: jobs.status === "fulfilled" ? reportFailureData(jobs.value) : null,
+        mainFirstPass: ci.status === "fulfilled" ? ci.value : null,
+    };
+}
+function revertOf(row, datum) {
+    const title = row["title"];
+    if (typeof title !== "string")
+        return [null];
+    return title.startsWith('Revert "') ? [datum] : [];
+}
+function settledValue(result) {
+    return result.status === "fulfilled" ? result.value : null;
 }

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

@@ -0,0 +1,3 @@
+import type { ReportDatum } from "../report-statistics.ts";
+import { type Reader } from "./report-github-reader.ts";
+export declare function readOperatorLabels(reader: Reader, since: string): Promise<ReportDatum[]>;

package/dist/src/cli/report-operator.js

@@ -0,0 +1,40 @@
+import { record } from "../protocol.js";
+import { positiveInteger } from "./report-ci.js";
+import { rows, timestamp } from "./report-github-reader.js";
+export async function readOperatorLabels(reader, since) {
+    const result = [];
+    const seen = new Set();
+    for (let page = 1;; page += 1) {
+        const events = rows(await reader.read(`issues/events?per_page=100&page=${String(page)}`));
+        for (const event of events) {
+            const id = positiveInteger(event["id"]);
+            if (seen.has(id))
+                throw new Error("response");
+            seen.add(id);
+            result.push(...labelDatum(event, since));
+        }
+        if (events.length < 100)
+            return result;
+    }
+}
+function labelDatum(event, since) {
+    const id = positiveInteger(event["id"]);
+    if (!["labeled", "unlabeled"].includes(String(event["event"])))
+        return [];
+    const label = record(event["label"])?.["name"];
+    if (typeof label !== "string")
+        throw new Error("response");
+    if (!label.startsWith("cloving:"))
+        return [];
+    const at = timestamp(event["created_at"]);
+    if (at < Date.parse(since))
+        return [];
+    const issue = positiveInteger(record(event["issue"])?.["number"]);
+    return [
+        {
+            at,
+            value: 1,
+            evidence: { issue, eventId: id, event: event["event"], label },
+        },
+    ];
+}

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

@@ -0,0 +1,3 @@
+import type { ReportReadyTicket } from "../report-flow-types.ts";
+import { type Reader } from "./report-github-reader.ts";
+export declare function readyTicketsOf(reader: Pick<Reader, "repository" | "read">): Promise<ReportReadyTicket[]>;

package/dist/src/cli/report-ready.js

@@ -0,0 +1,96 @@
+import { record } from "../protocol.js";
+import { hardDependencies } from "../ticket-dependencies.js";
+import { rows, identity, timestamp, issueTimeline, } from "./report-github-reader.js";
+function intervals(events) {
+    const labels = events
+        .filter((event) => ["labeled", "unlabeled"].includes(String(event["event"])) &&
+        record(event["label"])?.["name"] === "cloving: ready")
+        .map((event) => ({
+        type: event["event"],
+        at: timestamp(event["created_at"]),
+    }))
+        .toSorted((a, b) => a.at - b.at);
+    const result = [];
+    let start = null;
+    for (const label of labels) {
+        if (label.type === "labeled")
+            start ??= label.at;
+        else if (start !== null) {
+            result.push({ start, end: label.at });
+            start = null;
+        }
+    }
+    if (start !== null)
+        result.push({ start, end: null });
+    return result;
+}
+async function detail(reader, number) {
+    const row = record(await reader.read(`issues/${String(number)}`));
+    if (row === undefined ||
+        identity(row, { repository: reader.repository, kind: "issues" }) !==
+            number ||
+        Object.hasOwn(row, "pull_request"))
+        throw new Error("identity");
+    return row;
+}
+async function dependencies(reader, row) {
+    const body = row["body"];
+    if (body !== null && typeof body !== "string")
+        throw new Error("response");
+    const result = [];
+    for (const id of hardDependencies(body ?? "")) {
+        const number = Number(id);
+        if (!Number.isSafeInteger(number))
+            throw new Error("identity");
+        const dependency = await detail(reader, number);
+        const state = dependency["state"];
+        if (state !== "closed" && state !== "open")
+            throw new Error("response");
+        result.push({
+            issue: number,
+            closedAt: state === "open" ? null : timestamp(dependency["closed_at"]),
+        });
+    }
+    return result;
+}
+export async function readyTicketsOf(reader) {
+    const result = [];
+    const seen = new Set();
+    for (let page = 1;; page += 1) {
+        const values = rows(await reader.read(`issues?state=all&per_page=100&page=${String(page)}`, [
+            "--jq",
+            'map({number, html_url} + (if has("pull_request") then {pull_request: {}} else {} end))',
+        ]));
+        const numbers = [];
+        for (const row of values) {
+            if (Object.hasOwn(row, "pull_request"))
+                continue;
+            const number = identity(row, {
+                repository: reader.repository,
+                kind: "issues",
+            });
+            if (seen.has(number))
+                throw new Error("response");
+            seen.add(number);
+            numbers.push(number);
+        }
+        for (let offset = 0; offset < numbers.length; offset += 5) {
+            const tickets = await Promise.all(numbers
+                .slice(offset, offset + 5)
+                .map((number) => readyTicket(reader, number)));
+            result.push(...tickets.filter((ticket) => ticket !== null));
+        }
+        if (values.length < 100)
+            return result;
+    }
+}
+async function readyTicket(reader, number) {
+    const ready = intervals(await issueTimeline(reader, number));
+    if (ready.length === 0)
+        return null;
+    return {
+        issue: number,
+        intervals: ready,
+        dependencies: await dependencies(reader, await detail(reader, number)),
+    };
+}

package/dist/src/cli/report-text.d.ts

@@ -0,0 +1,9 @@
+import type { loopReport } from "../report.ts";
+type TextReport = Omit<ReturnType<typeof loopReport>, "window" | "runCosts"> & {
+    readonly window: Readonly<Record<string, string | number>>;
+    readonly runCosts: readonly (Omit<ReturnType<typeof loopReport>["runCosts"][number], "completedAt"> & {
+        readonly completedAt: string;
+    })[];
+};
+export declare function textReport(report: TextReport): string;
+export {};

package/dist/src/cli/report-text.js

@@ -0,0 +1,33 @@
+function isMetric(value) {
+    return typeof value["status"] === "string";
+}
+function sectionMetrics(section, prefix) {
+    return Object.fromEntries(Object.entries(section).flatMap(([name, value]) => isMetric(value)
+        ? [[`${prefix}.${name}`, value]]
+        : Object.entries(value).map(([key, metric]) => [`${prefix}.${name}.${key}`, metric])));
+}
+export function textReport(report) {
+    const lines = [`Loop report ${JSON.stringify(report.window)}`];
+    const { jobLogs, ...quality } = report.quality;
+    const metrics = {
+        ...report.metrics,
+        ...sectionMetrics(quality, "quality"),
+        ...sectionMetrics(report.ci, "ci"),
+        ...sectionMetrics(report.operator, "operator"),
+    };
+    for (const [name, metric] of Object.entries(metrics)) {
+        lines.push(`${name}: ${metric.status === "unavailable" ? "unavailable" : String(metric.value)}`);
+        const baseline = metric.baseline;
+        lines.push(`  history: ${baseline.history}; median: ${String(baseline.median)}; band: ${JSON.stringify(baseline.band)}${metric.mark === "outside" ? "; outside" : ""}`);
+        lines.push(`  comparison value: ${String(metric.comparisonValue)}`);
+        lines.push(`  evidence: ${JSON.stringify(metric.evidence)}`);
+        lines.push(`  baseline evidence: ${JSON.stringify(baseline.evidence)}`);
+    }
+    lines.push(`Quality job logs: ${JSON.stringify(jobLogs)}`);
+    lines.push(`Run costs (USD): ${JSON.stringify(report.runCosts)}`);
+    lines.push(`Completed ticket costs (USD): ${JSON.stringify(report.completedTicketCosts)}`);
+    lines.push(`Semantics: ${JSON.stringify(report.semantics)}`);
+    lines.push(`Sources: ${JSON.stringify(report.sources)}`);
+    lines.push(`Coverage: ${JSON.stringify(report.coverage)}`);
+    return lines.join("\n") + "\n";
+}

package/dist/src/cli/report.d.ts

@@ -2,6 +2,7 @@ import { type Fields } from "../protocol.ts";
 import { type ReportCompletion } from "../report.ts";
 import type { WatchPrSettings } from "./watch-pr-settings.ts";
 interface ReportEnvironment {
+    readonly now?: number;
     readonly runtimeDirectory: string;
     readonly workingDirectory: string;
     readonly watchPr?: WatchPrSettings;