cloving 1.2.0 → 1.4.0

package/dist/src/cli/render.js

@@ -1,31 +1,11 @@
-import { priceText, usageText, totalsSuffix } 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";
-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);
-}
-function visible(value) {
-    return show(value)
-        .split("\n")
-        .map((line) => Array.from(line, (character) => hidden(character) ? escaped(character) : character).join(""))
-        .join("\n    ");
-}
+import { commandText, shownCommands } from "./command-effects.js";
+import { scheduledText, statusScheduleLines, scheduleLines, } from "./schedule-render.js";
+import { show, oneLine, visible } from "./terminal-text.js";
+export { oneLine } from "./terminal-text.js";
 export function errorText(error) {
     const { candidates } = error;
     const lines = [`${visible(error["code"])}: ${visible(error["detail"])}`];
@@ -58,16 +38,27 @@ 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")}`;
-    return [line, ...chainLines(run).map((link) => `    ${link}`)].join("\n");
+    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}`),
+        ...chainLines(run).map((link) => `    ${link}`),
+    ].join("\n");
 }
 function chainLines(run) {
     return [
+        ...(typeof part(run, "awaitedRunId") === "string"
+            ? [`Awaited run: ${visible(part(run, "awaitedRunId"))}`]
+            : []),
         `Parent run: ${visible(part(run, "parentRunId") ?? "none")}`,
         `Chain: ${visible(part(run, "chainId") ?? part(run, "runId") ?? "none")}`,
         `Child runs: ${visible(listing(part(run, "childRunIds")))}`,
     ];
 }
+function ciLines(run) {
+    const reruns = part(run, "ciReruns");
+    return (Array.isArray(reruns) ? reruns : []).map((rerun) => `CI rerun after a failed check: workflow ${visible(part(rerun, "run"))}, commit ${visible(part(rerun, "commit"))}`);
+}
 function ended(run) {
     return ["completed", "failed", "cancelled"].includes(show(run["state"]));
 }
@@ -95,6 +86,7 @@ function runList(result) {
     return [
         `Workflows: ${visible(listing(result["workflows"]))}`,
         ...queueLines(result["queue"]),
+        ...statusScheduleLines(result["schedules"]).map(oneLine),
         ...(refusals.length === 0
             ? []
             : [
@@ -117,6 +109,7 @@ export function queueLines(value) {
     const skipped = queue["skipped"];
     return [
         `Queue: ${visible(queue["busy"])} of ${visible(queue["lanes"])} lanes busy`,
+        ...queueSpendLines(queue["spend"]),
         ...(Array.isArray(skipped)
             ? skipped.map((item) => {
                 const dependencies = part(item, "dependencies");
@@ -154,38 +147,31 @@ function outcomeLines(value) {
             : []),
     ];
 }
+function labelled(label, value) {
+    return typeof value === "string" ? [`  ${label}: ${visible(value)}`] : [];
+}
 function workerLines(value) {
     return (Array.isArray(value) ? value : []).flatMap((turn) => [
         `Worker turn ${visible(part(turn, "operationId"))}: ${priceText(part(turn, "costUsd"), part(turn, "estimatedCostUsd"))}`,
+        ...labelled("Harness", part(turn, "harness")),
+        ...labelled("Model", part(turn, "model")),
         `  ${usageText(part(turn, "usage"))}`,
+        ...attemptTexts(part(turn, "attempts")).map((text) => `  ${oneLine(text)}`),
+        ...modelLines(part(turn, "attempts")),
+        ...labelled("Report", part(turn, "summary")),
     ]);
 }
-export function statusJson(result) {
-    const run = record(result["run"]);
-    if (result["kind"] !== "run-status" || run === undefined)
-        return result;
-    const turns = run["workerTurns"];
-    return {
-        ...result,
-        run: {
-            ...run,
-            costDisplay: priceText(run["claudeCostUsd"], run["estimatedCostUsd"]),
-            ...(Array.isArray(turns)
-                ? {
-                    workerTurns: turns.map((turn) => {
-                        const fields = record(turn);
-                        if (fields === undefined)
-                            return turn;
-                        return {
-                            ...fields,
-                            costDisplay: priceText(fields["costUsd"], fields["estimatedCostUsd"]),
-                        };
-                    }),
-                }
-                : {}),
-        },
-    };
-}
+function modelLines(attempts) {
+    if (!Array.isArray(attempts))
+        return [];
+    return attempts.flatMap((attempt) => {
+        const models = part(attempt, "models");
+        if (!Array.isArray(models))
+            return [];
+        return models.map((model) => `  ${visible(part(model, "model"))}: ${usageText(part(model, "usage"))}`);
+    });
+}
+export { statusJson } from "./usage-render.js";
 function inputText(value) {
     const text = visible(record(value) ?? null);
     const characters = Array.from(text);
@@ -201,9 +187,11 @@ 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")),
+        ...ciLines(run),
         `Condition: ${show(part(run, "condition"))}`,
         `Reason: ${show(part(reason, "code"))}: ${show(part(reason, "detail"))}`,
         `Input: ${inputText(part(run, "input"))}`,
@@ -216,12 +204,25 @@ export function runStatus(result) {
         `Cost${suffix}: ${priceText(part(run, "claudeCostUsd"), part(run, "estimatedCostUsd"))}`,
         `Token usage${suffix}: ${usageText(part(run, "usage"))}`,
         ...workerLines(part(run, "workerTurns")),
+        ...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"}`,
         ...feedbackLines(part(run, "feedback")),
+        ...decidedLines(part(run, "decisions")),
         ...chainLines(run),
     ];
 }
+function decidedLines(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.map((decision) => `Decision ${visible(part(decision, "decisionId"))}: ${visible(part(decision, "decision"))} by ${visible(part(decision, "actor"))}`);
+}
 function binding(decision) {
     return `--expected-revision ${show(part(decision, "revision"))} --generation ${show(part(decision, "generation"))} --subject-digest ${show(part(decision, "subjectDigest"))}`;
 }
@@ -280,6 +281,8 @@ 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],

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 {};

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