cloving 1.3.0 → 1.5.0

package/dist/src/cli/mcp-tools.js

@@ -0,0 +1,242 @@
+import { isRecordKey } from "../authority/commands.js";
+import { record, } from "../protocol.js";
+import { mutate } from "./client.js";
+import { commandJson, decisionRequest, readCommandReply, readCommandRequest, runCommandRequest, runRequest, } from "./command-requests.js";
+import { argumentRules, } from "./runtime-arguments.js";
+const identifierSchema = {
+    type: "string",
+    minLength: 1,
+    maxLength: 128,
+    pattern: "^[A-Za-z0-9._:/-]+$",
+};
+function matching(pattern, schema) {
+    return {
+        schema,
+        valid: (value) => typeof value === "string" && pattern.test(value),
+    };
+}
+function whole(range) {
+    return {
+        schema: { type: "integer", ...range },
+        valid: (value) => typeof value === "number" &&
+            Number.isSafeInteger(value) &&
+            value >= range.minimum &&
+            value <= range.maximum,
+    };
+}
+const key = { schema: identifierSchema, valid: isRecordKey };
+const identifier = matching(argumentRules.identifier, identifierSchema);
+const reference = matching(argumentRules.decisionReference, {
+    ...identifierSchema,
+    maxLength: 256,
+});
+const digest = matching(argumentRules.sha256Digest, {
+    type: "string",
+    pattern: "^sha256:[0-9a-f]{64}$",
+});
+const revision = whole(argumentRules.revisions);
+const words = matching(/\S/, { type: "string", pattern: "\\S" });
+const limit = whole({ minimum: 1, maximum: 500 });
+const object = {
+    schema: { type: "object" },
+    valid: (value) => record(value) !== undefined,
+};
+function commandInput(kind, values) {
+    const { runId, limit, after } = values;
+    return {
+        kind,
+        ...(typeof runId === "string" ? { runId } : {}),
+        ...(typeof limit === "number" ? { limit } : {}),
+        ...(typeof after === "string" || typeof after === "number"
+            ? { after }
+            : {}),
+    };
+}
+function read(kind, properties) {
+    return {
+        name: `cloving_${kind}`,
+        arguments: properties,
+        required: [],
+        annotations: { readOnlyHint: true },
+        call: (values) => ({
+            kind: "read",
+            request: readCommandRequest(commandInput(kind, values)),
+        }),
+    };
+}
+const mutation = { readOnlyHint: false, idempotentHint: true };
+const repeat = "If the reply is lost, send the same commandId again.";
+const decisionDescriptions = {
+    answer: "Answer an open question.",
+    approve: "Approve an open approval.",
+    deny: "Deny an open approval. A feedback text is optional.",
+};
+const runCommandDescriptions = {
+    pause: "Pause a run.",
+    resume: "Resume a paused run.",
+    drop: "Drop a run. A dropped run does not continue.",
+};
+function mutationCall(values, request) {
+    const commandId = String(values["commandId"]);
+    return { kind: "mutation", commandId, request: request(commandId) };
+}
+function decisionCall(command, values) {
+    const { text } = values;
+    return mutationCall(values, (commandId) => decisionRequest({
+        command,
+        reference: String(values["reference"]),
+        text: typeof text === "string" ? text : null,
+        expectedRevision: Number(values["expectedRevision"]),
+        generation: Number(values["generation"]),
+        subjectDigest: String(values["subjectDigest"]),
+        commandId,
+    }));
+}
+function decision(command) {
+    const binding = {
+        expectedRevision: revision,
+        generation: revision,
+        subjectDigest: digest,
+        commandId: key,
+    };
+    return {
+        name: `cloving_${command}`,
+        description: `${decisionDescriptions[command]} Read the values from cloving_questions. ${repeat}`,
+        arguments: {
+            reference,
+            ...(command === "approve" ? {} : { text: words }),
+            ...binding,
+        },
+        required: [
+            "reference",
+            ...(command === "answer" ? ["text"] : []),
+            ...Object.keys(binding),
+        ],
+        annotations: mutation,
+        call: (values) => decisionCall(command, values),
+    };
+}
+function runCommand(command) {
+    return {
+        name: `cloving_${command}`,
+        description: `${runCommandDescriptions[command]} Read expectedRevision from cloving_status. ${repeat}`,
+        arguments: { runId: key, expectedRevision: revision, commandId: key },
+        required: ["runId", "expectedRevision", "commandId"],
+        annotations: command === "drop" ? { ...mutation, destructiveHint: true } : mutation,
+        call: (values) => mutationCall(values, (commandId) => runCommandRequest({
+            command,
+            runId: String(values["runId"]),
+            expectedRevision: Number(values["expectedRevision"]),
+            commandId,
+        })),
+    };
+}
+function runSource(values) {
+    const { prompt, ticket, input } = values;
+    const given = [prompt, ticket, input].filter((value) => value !== undefined);
+    if (given.length !== 1)
+        return undefined;
+    if (typeof prompt === "string")
+        return { kind: "prompt", text: prompt };
+    if (typeof ticket === "string")
+        return { kind: "ticket", id: ticket };
+    const submission = record(input);
+    return submission === undefined ? undefined : { kind: "input", submission };
+}
+function runCall(values) {
+    const source = runSource(values);
+    if (source === undefined)
+        return undefined;
+    return mutationCall(values, (commandId) => runRequest({ workflowId: String(values["workflowId"]), source, commandId }));
+}
+const tools = [
+    read("status", { runId: key, limit, after: identifier }),
+    read("questions", { runId: key }),
+    read("events", {
+        runId: key,
+        after: whole({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER }),
+        limit: whole({ minimum: 1, maximum: 1000 }),
+    }),
+    {
+        name: "cloving_run",
+        description: `Submit a run of a workflow. Give exactly one of prompt, ticket and input. A ticket can be next. ${repeat}`,
+        arguments: {
+            workflowId: identifier,
+            prompt: words,
+            ticket: key,
+            input: object,
+            commandId: key,
+        },
+        required: ["workflowId", "commandId"],
+        annotations: mutation,
+        call: runCall,
+    },
+    decision("answer"),
+    decision("approve"),
+    decision("deny"),
+    runCommand("pause"),
+    runCommand("resume"),
+    runCommand("drop"),
+];
+function listing(tool) {
+    return {
+        name: tool.name,
+        ...(tool.description === undefined
+            ? {}
+            : { description: tool.description }),
+        inputSchema: {
+            type: "object",
+            properties: Object.fromEntries(Object.entries(tool.arguments).map(([name, argument]) => [
+                name,
+                argument.schema,
+            ])),
+            ...(tool.required.length === 0 ? {} : { required: tool.required }),
+            additionalProperties: false,
+        },
+        annotations: tool.annotations,
+    };
+}
+export const mcpTools = tools.map(listing);
+function validArguments(values, tool) {
+    if (tool.required.some((name) => !Object.hasOwn(values, name)))
+        return false;
+    return Object.entries(values).every(([name, value]) => Object.hasOwn(tool.arguments, name) &&
+        tool.arguments[name]?.valid(value) === true);
+}
+export function mcpToolCall(parameters) {
+    const selected = tools.find((tool) => tool.name === parameters["name"]);
+    if (selected === undefined)
+        return undefined;
+    const values = parameters["arguments"] === undefined
+        ? {}
+        : record(parameters["arguments"]);
+    if (values === undefined || !validArguments(values, selected))
+        return undefined;
+    return selected.call(values);
+}
+function aborted(signal) {
+    return new Promise((settle) => {
+        signal.addEventListener("abort", () => {
+            settle();
+        }, { once: true });
+    });
+}
+function toolReply(runtimeDirectory, exchange) {
+    const { call, signal } = exchange;
+    if (call.kind === "read")
+        return readCommandReply(runtimeDirectory, { ...call.request, signal });
+    return mutate(runtimeDirectory, {
+        request: call.request,
+        signal: aborted(signal),
+    });
+}
+export async function callMcpTool(runtimeDirectory, exchange) {
+    const { call } = exchange;
+    const reply = await toolReply(runtimeDirectory, exchange);
+    const structuredContent = commandJson(reply, call.kind === "mutation" ? { commandId: call.commandId } : {});
+    return {
+        structuredContent,
+        content: [{ type: "text", text: JSON.stringify(structuredContent) }],
+        ...(reply.kind === "error" ? { isError: true } : {}),
+    };
+}

package/dist/src/cli/queue-arguments.d.ts

@@ -0,0 +1,15 @@
+import type { ServiceRequest } from "../protocol.ts";
+export interface QueueInvocation {
+    readonly kind: "queue";
+    readonly action: "show" | "resume" | "drain";
+    readonly commandId: string | null;
+    readonly json: boolean;
+}
+export declare function queueInvocation(request: {
+    readonly positionals: readonly string[];
+    readonly options: readonly {
+        readonly name: string;
+        readonly value: string | undefined;
+    }[];
+}): QueueInvocation | string;
+export declare function queueServiceRequest(invocation: QueueInvocation, commandId: string): ServiceRequest;

package/dist/src/cli/queue-arguments.js

@@ -0,0 +1,31 @@
+import { isRecordKey } from "../authority/commands.js";
+function givenCommandId(options) {
+    const value = options.find((option) => option.name === "command-id")?.value;
+    if (value === undefined)
+        return null;
+    return isRecordKey(value) ? value : undefined;
+}
+export function queueInvocation(request) {
+    const [action, ...rest] = request.positionals;
+    const names = request.options.map((option) => option.name);
+    const allowed = action === undefined ? ["json"] : ["command-id", "json"];
+    if (names.some((name) => !allowed.includes(name)))
+        return "unexpected-option";
+    const json = names.includes("json");
+    if (action === undefined)
+        return { kind: "queue", action: "show", commandId: null, json };
+    if (action !== "resume" && action !== "drain")
+        return "invalid-queue-action";
+    if (rest.length > 0)
+        return "unexpected-argument";
+    const commandId = givenCommandId(request.options);
+    if (commandId === undefined)
+        return "invalid-option-value";
+    return { kind: "queue", action, commandId, json };
+}
+export function queueServiceRequest(invocation, commandId) {
+    return {
+        operation: "queue-command",
+        parameters: { command: invocation.action, commandId },
+    };
+}

package/dist/src/cli/queue-render.d.ts

@@ -0,0 +1,3 @@
+import { type Fields } from "../protocol.ts";
+export declare function queueHeadline(queue: Fields): string;
+export declare function queueStateLines(queue: Fields): readonly string[];

package/dist/src/cli/queue-render.js

@@ -0,0 +1,26 @@
+import { record } from "../protocol.js";
+import { visible } from "./terminal-text.js";
+function instant(value) {
+    return typeof value === "number" && Number.isFinite(value)
+        ? new Date(value).toISOString()
+        : undefined;
+}
+export function queueHeadline(queue) {
+    const state = typeof queue["state"] === "string" ? `${visible(queue["state"])}, ` : "";
+    return `Queue: ${state}${visible(queue["busy"])} of ${visible(queue["lanes"])} lanes busy`;
+}
+export function queueStateLines(queue) {
+    const reason = record(queue["stop"])?.["reason"];
+    const failed = queue["failedRunIds"];
+    const drain = record(queue["drain"]);
+    const started = instant(drain?.["startedAt"]);
+    const drained = instant(drain?.["drainedAt"]);
+    return [
+        ...(reason === undefined ? [] : [`Stop reason: ${visible(reason)}`]),
+        ...(Array.isArray(failed) && failed.length > 0
+            ? [`Failed runs in a row: ${failed.map(visible).join(", ")}`]
+            : []),
+        ...(started === undefined ? [] : [`Drain started: ${started}`]),
+        ...(drained === undefined ? [] : [`Drained: ${drained}`]),
+    ];
+}

package/dist/src/cli/reload-render.d.ts

@@ -0,0 +1,2 @@
+import type { Fields } from "../protocol.ts";
+export declare function reloadFieldLines(result: Fields): readonly string[];

package/dist/src/cli/reload-render.js

@@ -0,0 +1,12 @@
+import { show, visible } from "./terminal-text.js";
+function fieldLine(label, value) {
+    return Array.isArray(value) && value.length > 0
+        ? [`${label}: ${visible(value.map(show).join(", "))}`]
+        : [];
+}
+export function reloadFieldLines(result) {
+    return [
+        ...fieldLine("Reloaded fields", result["reloadedFields"]),
+        ...fieldLine("Fields that need a restart", result["restartFields"]),
+    ];
+}

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

@@ -1,5 +1,5 @@
 import { type Fields } from "../protocol.ts";
-export declare function oneLine(value: unknown): string;
+export { oneLine } from "./terminal-text.ts";
 export declare function errorText(error: Fields): string;
 export declare function runOverview(result: Fields): Fields;
 export declare function queueLines(value: unknown): readonly string[];

package/dist/src/cli/render.js

@@ -1,35 +1,13 @@
-import { priceText, usageText, totalsSuffix, attemptTexts, } from "./usage-render.js";
+import { shownCommandWaits, commandWaitText } from "./command-waits.js";
+import { priceText, queueSpendLines, usageText, totalsSuffix, attemptTexts, } from "./usage-render.js";
 import { record } from "../protocol.js";
 import { workflowRefusals } from "../workflow-refusals.js";
 import { commandText, shownCommands } from "./command-effects.js";
-function show(value) {
-    return typeof value === "string" ? value : JSON.stringify(value);
-}
-function escaped(character) {
-    return `\\u${(character.codePointAt(0) ?? 0).toString(16).padStart(4, "0")}`;
-}
-const hiddenRanges = [
-    [0x00, 0x1f],
-    [0x7f, 0x9f],
-    [0x061c, 0x061c],
-    [0x200b, 0x200f],
-    [0x2028, 0x202e],
-    [0x2060, 0x2069],
-    [0xfeff, 0xfeff],
-];
-function hidden(character) {
-    const code = character.codePointAt(0) ?? 0;
-    return hiddenRanges.some(([first, last]) => code >= first && code <= last);
-}
-export function oneLine(value) {
-    return Array.from(show(value), (character) => hidden(character) ? escaped(character) : character).join("");
-}
-function visible(value) {
-    return show(value)
-        .split("\n")
-        .map((line) => Array.from(line, (character) => hidden(character) ? escaped(character) : character).join(""))
-        .join("\n    ");
-}
+import { scheduledText, statusScheduleLines, scheduleLines, } from "./schedule-render.js";
+import { show, oneLine, visible } from "./terminal-text.js";
+import { queueHeadline, queueStateLines } from "./queue-render.js";
+import { reloadFieldLines } from "./reload-render.js";
+export { oneLine } from "./terminal-text.js";
 export function errorText(error) {
     const { candidates } = error;
     const lines = [`${visible(error["code"])}: ${visible(error["detail"])}`];
@@ -62,7 +40,7 @@ function admitted(result) {
     ];
 }
 function runLine(run) {
-    const line = `  ${show(part(run, "runId"))}  ${show(part(run, "workflowId"))}  ${show(part(run, "condition"))}  revision ${show(part(run, "revision"))}  latest at ${show(part(run, "latestAt") ?? "none")}`;
+    const line = `  ${show(part(run, "runId"))}  ${show(part(run, "workflowId"))}  ${show(part(run, "condition"))}  revision ${show(part(run, "revision"))}  latest at ${show(part(run, "latestAt") ?? "none")}${part(run, "scheduled") === undefined ? "" : `  ${scheduledText(part(run, "scheduled"))}`}`;
     return [
         line,
         ...ciLines(run).map((notice) => `    ${notice}`),
@@ -102,20 +80,33 @@ export function runOverview(result) {
         hiddenRuns: Math.max(0, finished.length - 20),
     };
 }
+function refusalLines(value) {
+    const refusals = workflowRefusals(value);
+    if (refusals.length === 0)
+        return [];
+    return [
+        "Refused workflows:",
+        ...refusals.map((entry) => `  ${entry.scope} ${entry.label}: ${entry.codes.join(", ")}`),
+    ];
+}
+function reloadLines(result) {
+    return [
+        `Reload: ${show(result["status"])}`,
+        `Bundle digest: ${show(result["previousBundleDigest"])} -> ${show(result["bundleDigest"])}`,
+        `Workflows: ${visible(listing(result["workflows"]))}`,
+        ...reloadFieldLines(result),
+        ...refusalLines(result["workflowRefusals"]),
+    ];
+}
 function runList(result) {
     const runs = result["runs"];
     const lines = Array.isArray(runs) ? runs.map(runLine) : [];
     const hiddenRuns = result["hiddenRuns"];
-    const refusals = workflowRefusals(result["workflowRefusals"]);
     return [
         `Workflows: ${visible(listing(result["workflows"]))}`,
         ...queueLines(result["queue"]),
-        ...(refusals.length === 0
-            ? []
-            : [
-                "Refused workflows:",
-                ...refusals.map((entry) => `  ${entry.scope} ${entry.label}: ${entry.codes.join(", ")}`),
-            ]),
+        ...statusScheduleLines(result["schedules"]).map(oneLine),
+        ...refusalLines(result["workflowRefusals"]),
         "Runs:",
         ...(lines.length === 0 ? ["  none"] : lines),
         ...(typeof hiddenRuns === "number" && hiddenRuns > 0
@@ -131,7 +122,9 @@ export function queueLines(value) {
         return [];
     const skipped = queue["skipped"];
     return [
-        `Queue: ${visible(queue["busy"])} of ${visible(queue["lanes"])} lanes busy`,
+        queueHeadline(queue),
+        ...queueStateLines(queue),
+        ...queueSpendLines(queue["spend"]),
         ...(Array.isArray(skipped)
             ? skipped.map((item) => {
                 const dependencies = part(item, "dependencies");
@@ -194,6 +187,16 @@ function modelLines(attempts) {
     });
 }
 export { statusJson } from "./usage-render.js";
+function turnDetailsLines(value) {
+    const state = part(value, "state");
+    if (state === "deleted")
+        return ["Turn details were deleted by the retention rule"];
+    if (state !== "archived")
+        return [];
+    return [
+        `Turn details are archived in the journal folder of the archive: ${visible(part(value, "folder"))}`,
+    ];
+}
 function inputText(value) {
     const text = visible(record(value) ?? null);
     const characters = Array.from(text);
@@ -209,6 +212,7 @@ export function runStatus(result) {
     const suffix = totalsSuffix(part(run, "state"));
     return [
         `Run ${show(part(run, "runId"))} (${show(part(run, "workflowId"))})`,
+        ...[scheduledText(part(run, "scheduled"))].filter((mark) => mark !== ""),
         `Title: ${visible(part(run, "title") ?? "none")}`,
         `State: ${show(part(run, "state"))}`,
         ...outcomeLines(part(run, "outcome")),
@@ -225,6 +229,13 @@ export function runStatus(result) {
         `Cost${suffix}: ${priceText(part(run, "claudeCostUsd"), part(run, "estimatedCostUsd"))}`,
         `Token usage${suffix}: ${usageText(part(run, "usage"))}`,
         ...workerLines(part(run, "workerTurns")),
+        ...turnDetailsLines(part(run, "turnDetails")),
+        ...shownCommandWaits(part(run, "commandWaits")).map((wait) => visible(commandWaitText(wait))),
+        ...(record(part(run, "budget")) === undefined
+            ? []
+            : [
+                `Effects: ${show(part(part(run, "budget"), "spent"))} of ${show(part(part(run, "budget"), "limit"))}`,
+            ]),
         ...shownCommands(part(run, "commandEffects")).map((effect) => visible(commandText(effect))),
         `Next action: ${show(part(run, "nextAction") ?? "none")}${at === null ? "" : ` at ${show(at)}`}`,
         `Human input can help: ${part(run, "humanInputCanHelp") === true ? "yes" : "no"}`,
@@ -296,13 +307,18 @@ function eventPage(result) {
     return (Array.isArray(events) ? events : []).map((event) => eventText(record(event) ?? {}));
 }
 const renderers = new Map([
+    ["schedules", scheduleLines],
+    ["schedule", scheduleLines],
     ["run-admitted", admitted],
     ["run-list", runList],
     ["run-status", runStatus],
     ["decision-list", decisionList],
     ["decision-recorded", decisionRecorded],
     ["run-command", runCommand],
+    ["queue", (result) => queueLines(result["queue"])],
+    ["queue-command", (result) => queueLines(result["queue"])],
     ["event-page", eventPage],
+    ["reload", reloadLines],
 ]);
 export function rendered(result) {
     const lines = renderers.get(show(result["kind"]))?.(result) ?? [];

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

@@ -0,0 +1,23 @@
+import { type Fields } from "../protocol.ts";
+import { type Reader } from "./report-github-reader.ts";
+export interface ReportJob {
+    readonly details: Fields;
+    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 ciJobs(reader: Reader, runs: readonly Fields[]): Promise<ReportJob[]>;
+export declare function readCiJobs(reader: Reader, runs: readonly Fields[]): Promise<{
+    jobs: ReportJob[];
+    names: Record<number, readonly string[]>;
+    jobLogs: {
+        read: number;
+        notRead: number;
+        limit: number;
+        maximumBytes: number;
+    };
+}>;

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

@@ -0,0 +1,103 @@
+import { record } from "../protocol.js";
+import { rows, timestamp } from "./report-github-reader.js";
+import { positiveInteger } from "./report-ci.js";
+function parsedJob(row, run) {
+    const name = row["name"];
+    const commit = run["head_sha"];
+    const conclusion = jobConclusion(row["conclusion"]);
+    if (typeof name !== "string" ||
+        name === "" ||
+        typeof commit !== "string" ||
+        !/^[a-f0-9]{40,64}$/i.test(commit) ||
+        row["head_sha"] !== commit ||
+        row["run_id"] !== run["id"])
+        throw new Error("response");
+    return {
+        details: row,
+        id: positiveInteger(row["id"]),
+        name,
+        commit,
+        conclusion,
+        runId: positiveInteger(run["id"]),
+        attempt: positiveInteger(run["run_attempt"]),
+        at: timestamp(row["completed_at"] ?? row["started_at"] ?? run["created_at"]),
+    };
+}
+async function attemptJobs(reader, run) {
+    const result = [];
+    const seen = new Set();
+    for (let page = 1;; page += 1) {
+        const response = record(await reader.read(`actions/runs/${String(run["id"])}/attempts/${String(run["run_attempt"])}/jobs?per_page=100&page=${String(page)}`));
+        const values = rows(response?.["jobs"]);
+        for (const row of values) {
+            const job = parsedJob(row, run);
+            if (seen.has(job.id))
+                throw new Error("response");
+            seen.add(job.id);
+            result.push(job);
+        }
+        if (values.length < 100)
+            return result;
+    }
+}
+export async function ciJobs(reader, runs) {
+    const jobs = [];
+    for (const run of runs) {
+        const attempts = positiveInteger(run["run_attempt"]);
+        for (let attempt = 1; attempt <= attempts; attempt += 1)
+            jobs.push(...(await attemptJobs(reader, { ...run, run_attempt: attempt })));
+    }
+    return jobs;
+}
+export async function readCiJobs(reader, runs) {
+    const jobs = await ciJobs(reader, runs);
+    const names = {};
+    const failed = [
+        ...new Map(jobs
+            .filter((item) => item.conclusion === "failure")
+            .map((job) => [job.id, job])).values(),
+    ];
+    for (const job of failed.slice(0, 50)) {
+        const log = await reader
+            .readLog(`actions/jobs/${String(job.id)}/logs`)
+            .catch(() => "");
+        names[job.id] = failedTestNames(log);
+    }
+    return {
+        jobs,
+        names,
+        jobLogs: {
+            read: Math.min(failed.length, 50),
+            notRead: Math.max(0, failed.length - 50),
+            limit: 50,
+            maximumBytes: 2 * 1024 * 1024,
+        },
+    };
+}
+function failedTestNames(log) {
+    const lines = log
+        .split(/\r?\n/)
+        .map((line) => line.replace(/^\d{4}-\d{2}-\d{2}T\S+ /, ""));
+    const names = new Set();
+    let reading = false;
+    for (const line of lines) {
+        if (line === "Failed tests:") {
+            reading = true;
+            continue;
+        }
+        if (!reading || /^\s/.test(line))
+            continue;
+        if (line === "" ||
+            /^(?:\d+ failures not shown\.|Error: test-report-failure\. Full test report:)/.test(line)) {
+            reading = false;
+            continue;
+        }
+        names.add(line);
+    }
+    return names.size === 0 ? ["unknown"] : [...names];
+}
+function jobConclusion(value) {
+    if (value === null || typeof value === "string")
+        return value;
+    throw new Error("response");
+}

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

@@ -0,0 +1,9 @@
+import { type Fields } from "../protocol.ts";
+import { type ReportCiData } from "../report-ci.ts";
+import { reportSource, type Reader } from "./report-github-reader.ts";
+interface CiUsageRead {
+    readonly data: ReportCiData;
+    readonly sources: Readonly<Record<"ciUsageJobs" | "ciUsageWorkflows", ReturnType<typeof reportSource>>>;
+}
+export declare function readCiUsage(reader: Reader, runs: readonly Fields[]): Promise<CiUsageRead>;
+export {};