cloving 1.3.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

@@ -1,18 +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 { WatchPrSettings } from "./watch-pr-settings.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 sources: Readonly<Record<"issues" | "pulls" | "history", {
+    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;
     }>>;
 }
-interface GithubReportInput {
-    readonly since: string;
-    readonly settings?: WatchPrSettings;
-    readonly retryMilliseconds?: number;
-}
 export declare function readReportGithub(input: GithubReportInput): Promise<ReportGithub>;
-export {};