cloving 1.3.0 → 1.4.0

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

@@ -0,0 +1,80 @@
+import { isRecordKey } from "../authority/commands.js";
+import { record } from "../protocol.js";
+import { commandJson, readCommandReply, readCommandRequest, } from "./command-requests.js";
+const identifier = {
+    type: "string",
+    minLength: 1,
+    maxLength: 128,
+    pattern: "^[A-Za-z0-9._:/-]+$",
+};
+const limit = { type: "integer", minimum: 1, maximum: 500 };
+function tool(name, properties) {
+    return {
+        name,
+        inputSchema: { type: "object", properties, additionalProperties: false },
+        annotations: { readOnlyHint: true },
+    };
+}
+export const mcpTools = [
+    tool("cloving_status", { runId: identifier, limit, after: identifier }),
+    tool("cloving_questions", { runId: identifier }),
+    tool("cloving_events", {
+        runId: identifier,
+        after: { type: "integer", minimum: 0, maximum: Number.MAX_SAFE_INTEGER },
+        limit: { ...limit, maximum: 1000 },
+    }),
+];
+function validArgument(value, schema) {
+    if (schema["type"] === "string")
+        return typeof value === "string" && /^[A-Za-z0-9._:/-]{1,128}$/.test(value);
+    return (typeof value === "number" &&
+        Number.isSafeInteger(value) &&
+        value >= Number(schema["minimum"]) &&
+        value <= Number(schema["maximum"]));
+}
+function validArguments(argumentsObject, schemas) {
+    for (const [name, value] of Object.entries(argumentsObject)) {
+        const schema = schemas[name];
+        if (schema === undefined || !validArgument(value, schema))
+            return false;
+        if (name === "runId" && !isRecordKey(value))
+            return false;
+    }
+    return true;
+}
+function commandInput(kind, argumentsObject) {
+    const { runId, limit, after } = argumentsObject;
+    return {
+        kind,
+        ...(typeof runId === "string" ? { runId } : {}),
+        ...(typeof limit === "number" ? { limit } : {}),
+        ...(typeof after === "string" || typeof after === "number"
+            ? { after }
+            : {}),
+    };
+}
+export function mcpToolRequest(parameters) {
+    const selected = mcpTools.find((tool) => tool.name === parameters["name"]);
+    if (selected === undefined)
+        return undefined;
+    const argumentsObject = parameters["arguments"] === undefined
+        ? {}
+        : record(parameters["arguments"]);
+    if (argumentsObject === undefined)
+        return undefined;
+    if (!validArguments(argumentsObject, selected.inputSchema.properties))
+        return undefined;
+    const kind = selected.name.slice("cloving_".length);
+    if (kind !== "status" && kind !== "questions" && kind !== "events")
+        return undefined;
+    return readCommandRequest(commandInput(kind, argumentsObject));
+}
+export async function callMcpTool(runtimeDirectory, request) {
+    const reply = await readCommandReply(runtimeDirectory, request);
+    const structuredContent = commandJson(reply);
+    return {
+        structuredContent,
+        content: [{ type: "text", text: JSON.stringify(structuredContent) }],
+        ...(reply.kind === "error" ? { isError: true } : {}),
+    };
+}

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,11 @@
-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";
+export { oneLine } from "./terminal-text.js";
 export function errorText(error) {
     const { candidates } = error;
     const lines = [`${visible(error["code"])}: ${visible(error["detail"])}`];
@@ -62,7 +38,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}`),
@@ -110,6 +86,7 @@ function runList(result) {
     return [
         `Workflows: ${visible(listing(result["workflows"]))}`,
         ...queueLines(result["queue"]),
+        ...statusScheduleLines(result["schedules"]).map(oneLine),
         ...(refusals.length === 0
             ? []
             : [
@@ -132,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");
@@ -209,6 +187,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 +204,12 @@ 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"}`,
@@ -296,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[];
+}>;