cloving 1.2.0 → 1.4.0

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

@@ -0,0 +1,97 @@
+import { record } from "../protocol.js";
+import { identity, rows, timestamp, } from "./report-github-reader.js";
+async function issueNumbers(reader, since) {
+    const result = [];
+    const seen = new Set();
+    for (let page = 1;; page += 1) {
+        const values = rows(await reader.read(`issues?state=all&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);
+            result.push(number);
+        }
+        if (values.length < 100)
+            return result;
+    }
+}
+async function closureEvents(reader, issue) {
+    const result = [];
+    const seen = new Set();
+    for (let page = 1;; page += 1) {
+        const values = rows(await reader.read(`issues/${String(issue)}/events?per_page=100&page=${String(page)}`));
+        const signature = JSON.stringify(values);
+        if (seen.has(signature))
+            throw new Error("response");
+        seen.add(signature);
+        for (const event of values.filter((item) => ["closed", "reopened"].includes(String(item["event"]))))
+            result.push(await withCloseReason(reader, event));
+        if (values.length < 100)
+            return result;
+    }
+}
+function historyData(events, issue) {
+    const completed = [];
+    const reopened = [];
+    let completedAt = null;
+    for (const event of events.toSorted((left, right) => timestamp(left["created_at"]) - timestamp(right["created_at"]))) {
+        const at = timestamp(event["created_at"]);
+        const evidence = {
+            issue,
+            ...(event["id"] === undefined ? {} : { eventId: event["id"] }),
+        };
+        if (event["event"] === "reopened" &&
+            completedAt !== null &&
+            completedAt <= at)
+            reopened.push({ at, value: 1, evidence: { ...evidence, completedAt } });
+        if (event["event"] === "reopened")
+            continue;
+        if (!["completed", "not_planned", "duplicate"].includes(String(event["state_reason"])))
+            throw new Error("response");
+        if (event["state_reason"] !== "completed")
+            continue;
+        completedAt = at;
+        completed.push({ at, value: 1, evidence });
+    }
+    return { completed, reopened };
+}
+export async function readClosureHistory(reader, since) {
+    const completed = [];
+    const reopened = [];
+    for (const issue of await issueNumbers(reader, since)) {
+        const history = historyData(await closureEvents(reader, issue), issue);
+        completed.push(...history.completed);
+        reopened.push(...history.reopened);
+    }
+    return { completed, reopened };
+}
+async function withCloseReason(reader, event) {
+    if (event["event"] !== "closed" || typeof event["state_reason"] === "string")
+        return event;
+    const nodeId = event["node_id"];
+    if (typeof nodeId !== "string")
+        throw new Error("response");
+    return {
+        ...event,
+        state_reason: nodeReason(await reader.readNode(nodeId), nodeId),
+    };
+}
+function nodeReason(value, nodeId) {
+    const response = record(value);
+    const node = record(record(response?.["data"])?.["node"]);
+    if (response?.["errors"] !== undefined ||
+        node === undefined ||
+        node["id"] !== nodeId ||
+        typeof node["stateReason"] !== "string")
+        throw new Error("response");
+    return node["stateReason"].toLowerCase();
+}

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

@@ -0,0 +1,7 @@
+import { type Fields } from "../protocol.ts";
+import type { ReportFlow, ReportCompletion } from "../report-flow-types.ts";
+export declare function readReportFlow(runtime: string, input: {
+    readonly events: readonly Fields[] | null;
+    readonly start: number;
+    readonly completions: readonly ReportCompletion[] | null;
+}): Promise<ReportFlow>;

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

@@ -0,0 +1,122 @@
+import { record } from "../protocol.js";
+import { send } from "./client.js";
+function queueOf(value) {
+    const queue = record(value);
+    const workflowId = queue?.["workflowId"];
+    const lanes = queue?.["lanes"];
+    return typeof workflowId === "string" &&
+        workflowId !== "" &&
+        typeof lanes === "number" &&
+        Number.isSafeInteger(lanes) &&
+        lanes > 0
+        ? { workflowId, lanes }
+        : null;
+}
+async function overview(runtime) {
+    const reply = await send(runtime, {
+        operation: "status",
+        parameters: { limit: 1 },
+    });
+    if (reply.kind === "error")
+        throw new Error("report-overview-unavailable");
+    const workflows = reply.result["workflows"];
+    return {
+        queue: queueOf(reply.result["queue"]),
+        workflows: Array.isArray(workflows)
+            ? workflows.filter((id) => typeof id === "string")
+            : [],
+    };
+}
+async function workflowIds(runtime, runIds) {
+    const identities = new Map();
+    for (let offset = 0; offset < runIds.length; offset += 500) {
+        const batch = runIds.slice(offset, offset + 500);
+        try {
+            const reply = await send(runtime, {
+                operation: "status",
+                parameters: { metadata: "workflows", runIds: batch },
+            });
+            if (reply.kind === "error")
+                continue;
+            appendWorkflowIds(identities, {
+                runIds: batch,
+                values: reply.result["runs"],
+            });
+        }
+        catch {
+            continue;
+        }
+    }
+    return identities;
+}
+function appendWorkflowIds(identities, batch) {
+    const { values, runIds } = batch;
+    if (!Array.isArray(values) || values.length !== runIds.length)
+        return;
+    const rows = values.map((value) => record(value));
+    if (rows.some((row, index) => row?.["runId"] !== runIds[index]))
+        return;
+    for (const row of rows) {
+        const id = row?.["workflowId"];
+        identities.set(String(row?.["runId"]), typeof id === "string" && id !== "" ? id : null);
+    }
+}
+function skipsOf(events) {
+    if (events === null)
+        return null;
+    const skips = [];
+    for (const event of events.filter((event) => event["type"] === "schedule.skipped")) {
+        const id = record(event["payload"])?.["workflowId"];
+        const at = Date.parse(String(event["recordedAt"]));
+        const sequence = event["sequence"];
+        if (typeof id !== "string" ||
+            id === "" ||
+            !Number.isFinite(at) ||
+            typeof sequence !== "number" ||
+            !Number.isSafeInteger(sequence) ||
+            sequence < 1)
+            return null;
+        skips.push({ workflowId: id, at, sequence });
+    }
+    return skips;
+}
+function runsOf(input) {
+    const runs = [];
+    const ended = new Map((input.completions ?? []).map((event) => [event.runId, event.at]));
+    const seen = new Set();
+    for (const event of input.events.filter((event) => event["type"] === "run.started")) {
+        const runId = event["runId"];
+        const at = Date.parse(String(event["recordedAt"]));
+        if (typeof runId !== "string" ||
+            !Number.isFinite(at) ||
+            seen.has(runId) ||
+            (ended.get(runId) ?? at) < at)
+            return null;
+        seen.add(runId);
+        runs.push({
+            runId,
+            workflowId: null,
+            start: at,
+            end: ended.get(runId) ?? null,
+        });
+    }
+    return runs.filter((run) => (run.end ?? Infinity) > input.start);
+}
+export async function readReportFlow(runtime, input) {
+    const settings = await overview(runtime).catch(() => ({
+        queue: null,
+        workflows: [],
+    }));
+    const runs = input.events === null ? null : runsOf({ ...input, events: input.events });
+    const identities = await workflowIds(runtime, (runs ?? []).map((run) => run.runId));
+    return {
+        ...settings,
+        skips: skipsOf(input.events),
+        runs: runs === null
+            ? null
+            : runs.map((run) => ({
+                ...run,
+                workflowId: identities.get(run.runId) ?? null,
+            })),
+    };
+}

package/dist/src/cli/report-github-reader.d.ts

@@ -0,0 +1,29 @@
+import { type Fields } from "../protocol.ts";
+import type { WatchPrSettings } from "./watch-pr-settings.ts";
+import { type PrRepository } from "./watch-pr-identity.ts";
+export interface GithubReportInput {
+    readonly since: string;
+    readonly settings?: WatchPrSettings;
+    readonly retryMilliseconds?: number;
+}
+export declare function reportSource(result: PromiseSettledResult<unknown>): {
+    status: string;
+    reason?: never;
+} | {
+    status: string;
+    reason: string;
+};
+export declare function rows(value: unknown): readonly Fields[];
+export declare function identity(row: Fields, context: {
+    readonly repository: PrRepository;
+    readonly kind: "issues" | "pull";
+}): number;
+export declare function timestamp(value: unknown): number;
+export interface Reader {
+    readonly repository: PrRepository;
+    readonly readNode: (nodeId: string) => Promise<unknown>;
+    readonly readLog: (endpoint: string) => Promise<string>;
+    readonly read: (endpoint: string, flags?: readonly string[]) => Promise<unknown>;
+}
+export declare function repositoryReader(input: GithubReportInput): Promise<Reader>;
+export declare function issueTimeline(reader: Pick<Reader, "read">, issue: number): Promise<Fields[]>;

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

@@ -0,0 +1,157 @@
+import { record } from "../protocol.js";
+import { githubRetry } from "./github-retry.js";
+import { prRepository } from "./watch-pr-identity.js";
+export function reportSource(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 };
+}
+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);
+}
+export 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;
+    });
+}
+export 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;
+}
+export function timestamp(value) {
+    if (typeof value !== "string" || !Number.isFinite(Date.parse(value)))
+        throw new Error("response");
+    return Date.parse(value);
+}
+export 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 timelines = new Map();
+    return {
+        repository,
+        readNode: (nodeId) => readEndpoint(input, {
+            repository,
+            command,
+            endpoint: "",
+            flags: [
+                "-f",
+                `query=query{node(id:${JSON.stringify(nodeId)}){id ... on ClosedEvent{stateReason}}}`,
+            ],
+            format: "graphql",
+        }),
+        readLog: async (endpoint) => String(await readEndpoint(input, {
+            repository,
+            command,
+            endpoint,
+            flags: [],
+            format: "text",
+        })),
+        read: (endpoint, flags = []) => {
+            const key = JSON.stringify([endpoint, flags]);
+            const cached = timelines.get(key);
+            if (cached !== undefined)
+                return cached;
+            const reading = readEndpoint(input, {
+                repository,
+                command,
+                endpoint,
+                flags,
+            });
+            timelines.set(key, reading);
+            return reading;
+        },
+    };
+}
+async function readEndpoint(input, request) {
+    const settings = input.settings;
+    if (settings?.repository === undefined)
+        throw new Error("configuration");
+    const { repository, command, endpoint, flags } = request;
+    const directory = settings.repository;
+    const signal = AbortSignal.timeout(120_000);
+    const output = await githubRetry({
+        signal,
+        pollMilliseconds: input.retryMilliseconds ?? 30_000,
+        action: async () => {
+            const output = await settings.execute({
+                outputBytes: request.format === "text" ? 2 * 1024 * 1024 : 1024 * 1024,
+                directory,
+                signal,
+                command: [
+                    ...command,
+                    "api",
+                    "--method",
+                    request.format === "graphql" ? "POST" : "GET",
+                    "--hostname",
+                    repository.host,
+                    request.format === "graphql"
+                        ? "graphql"
+                        : `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;
+        },
+    });
+    if (request.format === "text")
+        return Buffer.from(output)
+            .subarray(0, 2 * 1024 * 1024)
+            .toString("utf8");
+    const parsed = JSON.parse(output);
+    return parsed;
+}
+export async function issueTimeline(reader, issue) {
+    const result = [];
+    const seen = new Set();
+    for (let page = 1;; page += 1) {
+        const values = rows(await reader.read(`issues/${String(issue)}/timeline?per_page=100&page=${String(page)}`));
+        const signature = JSON.stringify(values);
+        if (seen.has(signature))
+            throw new Error("response");
+        seen.add(signature);
+        result.push(...values);
+        if (values.length < 100)
+            return result;
+    }
+}

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

@@ -0,0 +1,25 @@
+import { readCiJobs } from "./report-ci-jobs.ts";
+import { reportFailureData } from "../report-quality.ts";
+import type { ReportCiData } from "../report-ci.ts";
+import type { ReportDatum } from "../report-statistics.ts";
+import { type GithubReportInput } from "./report-github-reader.ts";
+import type { ReportReadyTicket } from "../report-flow-types.ts";
+export interface ReportGithub {
+    readonly labels: readonly ReportDatum[] | null;
+    readonly ciUsage: ReportCiData | null;
+    readonly reopened: readonly ReportDatum[] | null;
+    readonly reverts: readonly ReportDatum[] | null;
+    readonly jobLogs: Awaited<ReturnType<typeof readCiJobs>>["jobLogs"] | null;
+    readonly failures: ReturnType<typeof reportFailureData> | null;
+    readonly mainFirstPass: readonly ReportDatum[] | null;
+    readonly observedSince: number | null;
+    readonly issues: readonly ReportDatum[] | null;
+    readonly pulls: readonly ReportDatum[] | null;
+    readonly leadTimes: readonly ReportDatum[] | null;
+    readonly ready: readonly ReportReadyTicket[] | null;
+    readonly sources: Readonly<Record<"issues" | "pulls" | "history" | "timelines" | "ready" | "ci" | "ciUsage" | "ciUsageJobs" | "ciUsageWorkflows" | "jobs" | "labels", {
+        readonly status: string;
+        readonly reason?: string;
+    }>>;
+}
+export declare function readReportGithub(input: GithubReportInput): Promise<ReportGithub>;

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

@@ -0,0 +1,181 @@
+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 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.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";
+async function pullsOf(reader, since) {
+    const reverts = [];
+    const result = [];
+    const seen = new Set();
+    for (let page = 1;; page += 1) {
+        const values = rows(await reader.read(`pulls?state=closed&sort=updated&direction=desc&per_page=100&page=${String(page)}`));
+        for (const row of values) {
+            const number = identity(row, {
+                repository: reader.repository,
+                kind: "pull",
+            });
+            if (seen.has(number))
+                throw new Error("response");
+            seen.add(number);
+            timestamp(row["updated_at"]);
+            if (row["merged_at"] === null)
+                continue;
+            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 {
+                pulls: result,
+                reverts: reverts.includes(null)
+                    ? null
+                    : reverts.filter((item) => item !== null),
+            };
+    }
+}
+async function repositoryCreatedAt(reader) {
+    const repository = record(await reader.read(""));
+    const name = repository?.["full_name"];
+    if (typeof name !== "string" ||
+        name.toLowerCase() !==
+            `${reader.repository.owner}/${reader.repository.repository}`)
+        throw new Error("identity");
+    return timestamp(repository?.["created_at"]);
+}
+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[]>;