cloving 1.3.0 → 1.5.0

package/dist/src/cli/report-ci-usage.js

@@ -0,0 +1,185 @@
+import { record } from "../protocol.js";
+import {} from "../report-ci.js";
+import { ciJobs } from "./report-ci-jobs.js";
+import { reportSource, timestamp, } from "./report-github-reader.js";
+function groups() {
+    return { localMacos: [], localLinux: [], hostedMacos: [], hostedLinux: [] };
+}
+function workflowEndpoint(run) {
+    const path = run["path"];
+    const commit = run["head_sha"];
+    if (typeof path !== "string" ||
+        !path.startsWith(".github/workflows/") ||
+        typeof commit !== "string" ||
+        !/^[a-f0-9]{40,64}$/i.test(commit))
+        throw new Error("response");
+    const file = path.replace(/@.*$/, "");
+    return `contents/${file}?ref=${commit}`;
+}
+async function workflowJobs(reader, run) {
+    const response = record(await reader.read(workflowEndpoint(run)));
+    if (response?.["encoding"] !== "base64" ||
+        typeof response["content"] !== "string")
+        throw new Error("response");
+    const text = Buffer.from(response["content"], "base64").toString("utf8");
+    try {
+        return record(record(JSON.parse(text))?.["jobs"]) ?? {};
+    }
+    catch {
+        return {};
+    }
+}
+function definitionOf(jobs, name) {
+    const key = name.split(" (")[0] ?? name;
+    return (record(jobs[key]) ??
+        Object.values(jobs)
+            .map(record)
+            .find((job) => job?.["name"] === name) ??
+        {});
+}
+function runnerSystem(value) {
+    if (typeof value === "string")
+        return runnerSystem([value]);
+    if (!Array.isArray(value) ||
+        !value.every((item) => typeof item === "string"))
+        return null;
+    const description = value.join(" ").toLowerCase();
+    const macos = /\bmacos\b|\bosx\b/.test(description);
+    const linux = /\blinux\b|\bubuntu\b/.test(description);
+    if (macos === linux)
+        return null;
+    return macos ? "Macos" : "Linux";
+}
+function runnerKind(row, definition) {
+    const labels = row["labels"];
+    if (!Array.isArray(labels) ||
+        !labels.every((label) => typeof label === "string"))
+        throw new Error("response");
+    const local = labels.includes("self-hosted");
+    const system = runnerSystem(labels) ??
+        (local ? null : runnerSystem(definition["runs-on"]));
+    if (system === null)
+        throw new Error("runner-kind");
+    return `${local ? "local" : "hosted"}${system}`;
+}
+function jobValues(job, definition) {
+    const row = job.details;
+    const start = timestamp(row["started_at"]);
+    const end = row["completed_at"] === null ? null : timestamp(row["completed_at"]);
+    const created = timestamp(row["created_at"]);
+    if (created > start || (end !== null && start > end))
+        throw new Error("response");
+    const minutes = end === null ? null : (end - start) / 60_000;
+    const timeout = definition["timeout-minutes"];
+    const limit = typeof timeout === "number" && Number.isFinite(timeout) && timeout > 0
+        ? timeout
+        : null;
+    return {
+        kind: runnerKind(row, definition),
+        minutes,
+        wait: (start - created) / 60_000,
+        limit,
+    };
+}
+function appendJob(target, input) {
+    const { job, definitions } = input;
+    const definition = definitionOf(definitions.get(job.runId) ?? {}, job.name);
+    const values = jobValues(job, definition);
+    const evidence = {
+        jobId: job.id,
+        runId: job.runId,
+        attempt: job.attempt,
+        jobName: job.name,
+        minutes: values.minutes,
+        limitMinutes: values.limit,
+    };
+    const datum = { at: job.at, evidence };
+    if (values.minutes !== null)
+        target.jobMinutes[values.kind].push({ ...datum, value: values.minutes });
+    target.runnerWaitMinutes[values.kind].push({ ...datum, value: values.wait });
+    if (values.limit !== null && values.minutes !== null)
+        target.jobLimitShare[values.kind].push({
+            ...datum,
+            value: values.minutes / values.limit,
+        });
+    if (job.conclusion === "timed_out" ||
+        (values.limit !== null &&
+            values.minutes !== null &&
+            values.minutes >= values.limit))
+        target.timeouts.push({ ...datum, value: 1 });
+}
+function jobData(jobs, definitions) {
+    const jobMinutes = groups();
+    const jobLimitShare = groups();
+    const runnerWaitMinutes = groups();
+    const timeouts = [];
+    for (const job of jobs) {
+        if (job.details["started_at"] === null || job.conclusion === "skipped")
+            continue;
+        appendJob({ jobMinutes, jobLimitShare, runnerWaitMinutes, timeouts }, { job, definitions });
+    }
+    const limitsKnown = [...definitions.values()].every((value) => value !== null);
+    return {
+        jobMinutes,
+        runnerWaitMinutes,
+        jobLimitShare: limitsKnown ? jobLimitShare : null,
+        timeouts: limitsKnown ? timeouts : null,
+    };
+}
+async function workflowDefinitions(reader, runs) {
+    const results = [];
+    for (const run of runs)
+        results.push(...(await Promise.allSettled([workflowJobs(reader, run)])));
+    return {
+        definitions: new Map(runs.map((run, index) => {
+            const result = results[index];
+            return [
+                Number(run["id"]),
+                result?.status === "fulfilled" ? result.value : null,
+            ];
+        })),
+        source: reportSource(results.find((result) => result.status === "rejected") ?? {
+            status: "fulfilled",
+            value: null,
+        }),
+    };
+}
+export async function readCiUsage(reader, runs) {
+    const reruns = runs
+        .filter((run) => Number(run["run_attempt"]) > 1)
+        .map((run) => ({
+        at: timestamp(run["run_started_at"] ?? run["updated_at"]),
+        value: 1,
+        evidence: { runId: run["id"], attempt: run["run_attempt"] },
+    }));
+    const empty = {
+        jobMinutes: null,
+        jobLimitShare: null,
+        runnerWaitMinutes: null,
+        timeouts: null,
+        reruns,
+    };
+    const [jobs] = await Promise.allSettled([ciJobs(reader, runs)]);
+    const workflows = await workflowDefinitions(reader, runs);
+    const sources = {
+        ciUsageJobs: reportSource(jobs),
+        ciUsageWorkflows: workflows.source,
+    };
+    if (jobs.status === "rejected")
+        return { data: empty, sources };
+    try {
+        return {
+            data: { ...jobData(jobs.value, workflows.definitions), reruns },
+            sources,
+        };
+    }
+    catch (reason) {
+        return {
+            data: empty,
+            sources: {
+                ...sources,
+                ciUsageJobs: reportSource({ status: "rejected", reason }),
+            },
+        };
+    }
+}

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

@@ -0,0 +1,13 @@
+import { type Fields } from "../protocol.ts";
+import type { ReportDatum } from "../report-statistics.ts";
+import { type Reader } from "./report-github-reader.ts";
+export declare function positiveInteger(value: unknown): number;
+export declare function mainRuns(reader: Reader, input: {
+    readonly since: string;
+    readonly activity: "created" | "updated";
+}): Promise<Readonly<Record<string, unknown>>[]>;
+export declare function ciRuns(reader: Reader, input: {
+    readonly since: string;
+    readonly activity: "created" | "updated";
+}): Promise<Readonly<Record<string, unknown>>[]>;
+export declare function firstPassData(reader: Reader, runs: readonly Fields[]): Promise<ReportDatum[]>;

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

@@ -0,0 +1,74 @@
+import { record } from "../protocol.js";
+import { rows, timestamp } from "./report-github-reader.js";
+export function positiveInteger(value) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1)
+        throw new Error("response");
+    return value;
+}
+export async function mainRuns(reader, input) {
+    return (await ciRuns(reader, input)).filter((run) => run["head_branch"] === "main");
+}
+export async function ciRuns(reader, input) {
+    const filter = input.activity === "created"
+        ? `branch=main&created=%3E%3D${encodeURIComponent(input.since)}&`
+        : "";
+    const runs = await runPages(reader, {
+        filter,
+        maximum: input.activity === "created" ? 1000 : Infinity,
+    });
+    return runs.filter((run) => {
+        if (run["name"] !== "CI")
+            return false;
+        if (timestamp(run[`${input.activity}_at`]) < Date.parse(input.since))
+            return false;
+        timestamp(run["created_at"]);
+        positiveInteger(run["run_attempt"]);
+        return true;
+    });
+}
+async function runPages(reader, input) {
+    const result = [];
+    const seen = new Set();
+    for (let page = 1;; page += 1) {
+        const response = record(await reader.read(`actions/runs?${input.filter}per_page=100&page=${String(page)}`));
+        if (Number(response?.["total_count"]) > input.maximum)
+            throw new Error("response-truncated");
+        const values = rows(response?.["workflow_runs"]);
+        for (const run of values) {
+            const id = positiveInteger(run["id"]);
+            if (seen.has(id))
+                throw new Error("response");
+            seen.add(id);
+            result.push(run);
+        }
+        if (values.length < 100)
+            return result;
+    }
+}
+export async function firstPassData(reader, runs) {
+    const result = [];
+    for (const run of runs) {
+        const first = run["run_attempt"] === 1
+            ? run
+            : record(await reader.read(`actions/runs/${String(run["id"])}/attempts/1`));
+        if (first === undefined ||
+            first["id"] !== run["id"] ||
+            first["run_attempt"] !== 1 ||
+            first["head_sha"] !== run["head_sha"])
+            throw new Error("response");
+        const conclusion = first["conclusion"];
+        if (conclusion !== null && typeof conclusion !== "string")
+            throw new Error("response");
+        result.push({
+            at: timestamp(run["created_at"]),
+            value: conclusion === "success" ? 1 : 0,
+            evidence: {
+                runId: run["id"],
+                commit: run["head_sha"],
+                attempt: 1,
+                conclusion,
+            },
+        });
+    }
+    return result;
+}

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

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

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[]>;