cloving 1.2.0 → 1.3.0

package/dist/src/daemon/github-ci-rerun.js

@@ -0,0 +1,92 @@
+import { field, repositoryPath } from "./github-operation.js";
+import { githubRead } from "./github-retry.js";
+import { operationKey, writeRecord } from "./operation-journal.js";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+function isRerun(value) {
+    return (typeof field(value, "run") === "string" &&
+        /^\d+$/.test(String(field(value, "run"))) &&
+        typeof field(value, "requestedAt") === "number" &&
+        typeof field(value, "output") === "string");
+}
+export async function ciWait(operation, commit) {
+    const text = await readFile(join(operation.folder, `ci-${operationKey(commit)}.json`), "utf8").catch((error) => {
+        if (field(error, "code") === "ENOENT")
+            return undefined;
+        throw error;
+    });
+    if (text === undefined)
+        return { commit, startedAt: Date.now(), reruns: [] };
+    const stored = JSON.parse(text);
+    const startedAt = field(stored, "startedAt");
+    const reruns = field(stored, "reruns");
+    if (field(stored, "commit") !== commit ||
+        typeof startedAt !== "number" ||
+        !Array.isArray(reruns) ||
+        !reruns.every(isRerun))
+        throw new Error("github-call-failed");
+    return { commit, startedAt, reruns };
+}
+export async function workflowAttempt(operation, run) {
+    const value = JSON.parse(await githubRead(operation, [
+        "api",
+        `${repositoryPath}/actions/runs/${run}`,
+    ]));
+    const attempt = field(value, "run_attempt");
+    const status = field(value, "status");
+    if (typeof attempt !== "number" ||
+        !Number.isSafeInteger(attempt) ||
+        attempt < 1 ||
+        typeof status !== "string")
+        throw new Error("github-call-failed");
+    return { attempt, status };
+}
+export async function attemptChecks(operation, workflow) {
+    const pages = JSON.parse(await githubRead(operation, [
+        "api",
+        "--paginate",
+        "--slurp",
+        `${repositoryPath}/actions/runs/${workflow.run}/attempts/${String(workflow.attempt)}/jobs?per_page=100`,
+    ]));
+    if (!Array.isArray(pages) || pages.length === 0)
+        throw new Error("github-call-failed");
+    const ids = new Set();
+    for (const page of pages) {
+        const jobs = field(page, "jobs");
+        if (!Array.isArray(jobs))
+            throw new Error("github-call-failed");
+        for (const job of jobs) {
+            const id = /\/check-runs\/(\d+)$/.exec(String(field(job, "check_run_url")))?.[1];
+            if (id === undefined)
+                throw new Error("github-call-failed");
+            ids.add(Number(id));
+        }
+    }
+    return ids;
+}
+export async function rerunCi(operation, request) {
+    const { wait, rerun } = request;
+    wait.reruns.push(rerun);
+    await writeRecord(operation.folder, {
+        name: `ci-${operationKey(wait.commit)}.json`,
+        value: wait,
+        permissions: "private",
+    });
+    if (Date.now() >= request.deadline)
+        return;
+    try {
+        await operation.calls.gh(["run", "rerun", rerun.run, "--failed"]);
+    }
+    catch (error) {
+        operation.signal.throwIfAborted();
+        throw Object.assign(new Error("github-network-failed", { cause: error }), {
+            detail: field(error, "detail"),
+        });
+    }
+}
+export function attemptOutput(attempts) {
+    const allowance = Math.floor(6_000 / attempts.length) - 40;
+    return attempts
+        .map((output, index) => `Attempt ${String(index + 1)}:\n${output.length <= allowance ? output : output.slice(0, 400) + "\n…\n" + output.slice(-(allowance - 404))}`)
+        .join("\n");
+}

package/dist/src/daemon/github-ci.js

@@ -1,6 +1,8 @@
+import { settingsEnvironment } from "../cli/project-settings.js";
 import { setTimeout as delay } from "node:timers/promises";
 import { githubText } from "./github-calls.js";
 import { githubRead } from "./github-retry.js";
+import { ciWait, workflowAttempt, attemptChecks, rerunCi, attemptOutput, } from "./github-ci-rerun.js";
 import { field, githubTiming, repositoryPath, } from "./github-operation.js";
 function isCheckRun(value) {
     const conclusion = field(value, "conclusion");
@@ -117,12 +119,18 @@ async function failedOutput(operation, checks) {
         .join("\n")
         .slice(0, 6_000);
 }
+function requiredCheckNames(operation) {
+    if (operation.settings.requiredChecks !== undefined)
+        return operation.settings.requiredChecks === null
+            ? undefined
+            : operation.settings.requiredChecks;
+    const setting = settingsEnvironment({ ...process.env, ...operation.settings.environment }, operation.settings.repository)["CLOVING_REQUIRED_CHECKS"];
+    return setting === undefined ? undefined : JSON.parse(setting);
+}
 function requiredChecks(operation) {
-    const setting = operation.settings.environment?.["CLOVING_REQUIRED_CHECKS"] ??
-        process.env["CLOVING_REQUIRED_CHECKS"];
-    if (setting === undefined)
+    const names = requiredCheckNames(operation);
+    if (names === undefined)
         return undefined;
-    const names = JSON.parse(setting);
     if (!Array.isArray(names) ||
         !names.every((name) => typeof name === "string" && name.trim() !== ""))
         throw new Error("invalid-payload");
@@ -131,6 +139,70 @@ function requiredChecks(operation) {
 function pendingChecks(checks, names) {
     return [...names].filter((name) => !checks.some((check) => check.name === name && check.status === "completed"));
 }
+function runOf(check) {
+    return check.app?.slug === "github-actions"
+        ? /\/actions\/runs\/(\d+)/.exec(check.details_url ?? "")?.[1]
+        : undefined;
+}
+async function rerunBeforeDeadline(operation, request) {
+    if (Date.now() >= request.deadline)
+        return;
+    const output = await failedOutput(operation, request.checks);
+    const requestedAt = Date.now();
+    if (requestedAt >= request.deadline)
+        return;
+    await rerunCi(operation, {
+        wait: request.wait,
+        rerun: { run: request.run, requestedAt, output },
+        deadline: request.deadline,
+    });
+}
+async function rerunFailedChecks(operation, input) {
+    const { wait, failed } = input;
+    const failures = failed.filter((check) => runOf(check) === undefined);
+    const pending = [];
+    const runs = new Set(failed.flatMap((check) => runOf(check) ?? []));
+    for (const run of runs) {
+        const checks = failed.filter((check) => runOf(check) === run);
+        const recorded = wait.reruns.find((rerun) => rerun.run === run);
+        const workflow = await workflowAttempt(operation, run);
+        if (workflow.attempt === 1 &&
+            recorded === undefined &&
+            workflow.status === "completed")
+            await rerunBeforeDeadline(operation, {
+                wait,
+                run,
+                checks,
+                deadline: input.deadline,
+            });
+        if (workflow.attempt === 1) {
+            pending.push(`workflow ${run} rerun`);
+            continue;
+        }
+        const ids = await attemptChecks(operation, {
+            run,
+            attempt: workflow.attempt,
+        });
+        const current = checks.filter((check) => ids.has(check.id));
+        if (current.length === 0) {
+            pending.push(`workflow ${run} rerun`);
+            continue;
+        }
+        failures.push(...current);
+    }
+    return { failures, pending };
+}
+async function ciFailureOutput(operation, input) {
+    const { wait, failed } = input;
+    const previous = wait.reruns.filter((rerun) => failed.some((check) => runOf(check) === rerun.run));
+    const current = await failedOutput(operation, failed);
+    return previous.length === 0
+        ? current
+        : attemptOutput([
+            previous.map((rerun) => rerun.output).join("\n"),
+            current,
+        ]);
+}
 export async function waitForCi(operation, commit) {
     const { pollMilliseconds: poll, ciGraceMilliseconds: grace, ciLimitMilliseconds: limit, } = {
         ...githubTiming,
@@ -138,7 +210,8 @@ export async function waitForCi(operation, commit) {
         ciLimitMilliseconds: 5_400_000,
         ...operation.settings.timing,
     };
-    const started = Date.now();
+    const wait = await ciWait(operation, commit);
+    const started = wait.startedAt;
     const required = requiredChecks(operation);
     const names = new Set(required);
     for (;;) {
@@ -146,12 +219,20 @@ export async function waitForCi(operation, commit) {
         for (const check of checks)
             names.add(check.name);
         const failed = checks.filter((check) => check.status === "completed" && !passing.has(check.conclusion ?? ""));
-        if (failed.length > 0)
+        const retried = await rerunFailedChecks(operation, {
+            wait,
+            failed,
+            deadline: started + limit,
+        });
+        if (retried.failures.length > 0)
             return {
                 reason: "ci-failed",
-                output: await failedOutput(operation, failed),
+                output: await ciFailureOutput(operation, {
+                    wait,
+                    failed: retried.failures,
+                }),
             };
-        const pending = pendingChecks(checks, names);
+        const pending = [...pendingChecks(checks, names), ...retried.pending];
         if (pending.length === 0 &&
             (required !== undefined ||
                 names.size > 0 ||

package/dist/src/daemon/github-merge-call.d.ts

@@ -1,7 +1,9 @@
 import { type Operation } from "./github-operation.ts";
+export type MergeCheck = "beforeMerge" | null;
 export interface ReviewedPull {
     readonly number: number;
     readonly commit: string;
+    readonly check?: MergeCheck | undefined;
 }
 export declare function knownMerge(operation: Operation, expected: ReviewedPull & {
     readonly updated: string;

package/dist/src/daemon/github-merge.js

@@ -69,12 +69,13 @@ async function updatedTree(operation, place) {
 async function checked(operation, place) {
     await changeChecked(operation, place);
     const head = await headOf(operation, place.tree);
-    if (operation.settings.check !== undefined)
-        await operation.calls.run(operation.settings.check, place.tree.path);
+    const command = place.check === null ? undefined : operation.settings.check;
+    if (command !== undefined)
+        await operation.calls.run(command, place.tree.path);
     await clean(operation, place.tree);
     if ((await headOf(operation, place.tree)) !== head)
         throw new Error("uncommitted-change");
-    if (head !== place.commit && operation.settings.check === undefined)
+    if (head !== place.commit && command === undefined && place.check !== null)
         throw new Error("check-required");
     return head;
 }
@@ -139,6 +140,7 @@ async function readyHead(operation, pull) {
             tree,
             commit: pull.commit,
             recorded,
+            check: pull.check,
         });
         if (updated !== pull.commit && recorded !== updated)
             await writeRecord(operation.folder, {
@@ -175,6 +177,8 @@ function commandOutput(cause) {
         .join("");
 }
 export async function merge(operation, pull) {
+    if (pull.check === "beforeMerge" && operation.settings.check === undefined)
+        throw new Error("check-not-configured");
     try {
         return await completedMerge(operation, pull);
     }

package/dist/src/daemon/github-methods.js

@@ -21,6 +21,7 @@ export const methodReasons = new Set([
     "check-failed",
     "merge-conflict",
     "check-required",
+    "check-not-configured",
     "base-moved",
     "head-not-updated",
     "uncommitted-change",
@@ -37,6 +38,14 @@ function integer(operation, name) {
         throw new Error("invalid-payload");
     return value;
 }
+function mergeCheck(operation) {
+    if (!Object.hasOwn(operation.payload, "check"))
+        return undefined;
+    const value = operation.payload["check"];
+    if (value === null || value === "beforeMerge")
+        return value;
+    throw new Error("invalid-payload");
+}
 async function prepare(operation) {
     const { settings, calls, target, signal } = operation;
     await calls.git(settings.repository, ["fetch", "--quiet", "origin"]);
@@ -261,6 +270,7 @@ export const methods = new Map([
         (operation) => merge(operation, {
             number: integer(operation, "number"),
             commit: text(operation, "commit"),
+            check: mergeCheck(operation),
         }),
     ],
 ]);

package/dist/src/daemon/github-operation.d.ts

@@ -10,6 +10,7 @@ export declare const githubTiming: GithubTiming;
 export interface MethodSettings extends CallSettings {
     readonly worktrees: string;
     readonly timing?: GithubTiming;
+    readonly requiredChecks?: readonly string[] | null;
     readonly check?: readonly string[];
 }
 export interface Operation {

package/dist/src/daemon/github-retry.js

@@ -1,49 +1,13 @@
-import { setTimeout as delay } from "node:timers/promises";
-import { field, githubTiming } from "./github-operation.js";
-function transient(error) {
-    if (!(error instanceof Error) || error.message !== "github-call-failed")
-        return false;
-    const detail = field(error, "detail");
-    if (typeof detail !== "string")
-        return false;
-    const status = field(error, "status");
-    if ([500, 502, 503, 504].includes(Number(status)))
-        return true;
-    return ((status === undefined ||
-        (typeof status === "number" && Number.isNaN(status))) &&
-        /TLS handshake timeout|connection reset|i\/o timeout|\bEOF\b/i.test(detail));
-}
-function retryFactor(error, retry) {
-    const network = transient(error);
-    if (!network && !retry.statuses.includes(Number(field(error, "status"))))
-        throw error;
-    if (retry.attempt < 2)
-        return network ? retry.attempt + 1 : 1;
-    if (!network)
-        throw error;
-    throw Object.assign(new Error("github-network-failed", { cause: error }), {
-        detail: field(error, "detail"),
+import { githubRetry } from "../cli/github-retry.js";
+import { githubTiming } from "./github-operation.js";
+export function retryGithub(operation, retry) {
+    return githubRetry({
+        ...retry,
+        signal: operation.signal,
+        pollMilliseconds: (operation.settings.timing ?? githubTiming)
+            .pollMilliseconds,
     });
 }
-export async function retryGithub(operation, retry) {
-    const timing = operation.settings.timing ?? githubTiming;
-    for (let attempt = 0;; attempt += 1) {
-        operation.signal.throwIfAborted();
-        try {
-            return await retry.action(attempt);
-        }
-        catch (error) {
-            operation.signal.throwIfAborted();
-            const factor = retryFactor(error, {
-                attempt,
-                statuses: retry.statuses ?? [],
-            });
-            await delay(timing.pollMilliseconds * factor, undefined, {
-                signal: operation.signal,
-            });
-        }
-    }
-}
 export function githubRead(operation, parts) {
     return retryGithub(operation, { action: () => operation.calls.gh(parts) });
 }

package/dist/src/daemon/issue-queue.d.ts

@@ -4,6 +4,7 @@ interface QueueSettings {
     readonly intervalMilliseconds: number;
     readonly lanes?: number;
     readonly resetQueue?: boolean;
+    readonly workflowId?: string;
 }
 export declare function issueQueue(settings: QueueSettings): {
     readonly stop: () => Promise<void>;

package/dist/src/daemon/issue-queue.js

@@ -1,3 +1,4 @@
+import { activeQueueRuns } from "./queue-status.js";
 import { randomUUID } from "node:crypto";
 import { readFile, rename, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
@@ -147,30 +148,6 @@ async function completed(settings, pending) {
         await retired(pending, ending);
     return pendingRuns;
 }
-async function active(runtimeDirectory) {
-    let count = 0;
-    let after = "";
-    do {
-        const reply = await send(runtimeDirectory, {
-            operation: "status",
-            parameters: { after, limit: 500 },
-        });
-        if (reply.kind === "error")
-            throw new Error(reply.error.code);
-        const runs = reply.result["runs"];
-        if (!Array.isArray(runs))
-            throw new Error("invalid-run-list");
-        count += runs.filter((value) => {
-            const run = record(value);
-            return run?.["workflowId"] === "develop-issue" && !terminal(run);
-        }).length;
-        const next = reply.result["next"];
-        if (next !== null && (typeof next !== "string" || next <= after))
-            throw new Error("invalid-run-page");
-        after = next;
-    } while (after !== null);
-    return count;
-}
 async function submit(settings, pending) {
     const commandId = pending.retryCommandId ?? randomUUID();
     pending.commands.add(commandId);
@@ -178,7 +155,7 @@ async function submit(settings, pending) {
     const reply = await send(settings.runtimeDirectory, {
         operation: "run",
         parameters: {
-            workflowId: "develop-issue",
+            workflowId: settings.workflowId ?? "develop-issue",
             source: "ticket",
             submission: { ticket: "next" },
             commandId,
@@ -279,7 +256,7 @@ async function cycle(settings, signal) {
             await holding(pendingRuns);
             continue;
         }
-        const activeRuns = await active(settings.runtimeDirectory);
+        const activeRuns = await activeQueueRuns(settings);
         const held = await holding(activeRuns);
         if (activeRuns >= lanes || activeRuns < pendingRuns)
             continue;

package/dist/src/daemon/notify.js

@@ -2,6 +2,7 @@ import { recordedNotifications, saveNotifications, } from "./notify-journal.js";
 import { spawn } from "node:child_process";
 import { join } from "node:path";
 import { send } from "../cli/client.js";
+import { deliveryBackoffMilliseconds } from "../delivery-backoff.js";
 import { record } from "../protocol.js";
 import { decisionNotification, outcomeNotification, } from "./notify-message.js";
 const retentionMilliseconds = 7 * 24 * 60 * 60_000;
@@ -132,7 +133,7 @@ async function prepareDelivery(journal, entry) {
         });
     if (entry.attempts === 5)
         return undefined;
-    const backoff = [0, 60_000, 300_000, 900_000, 3_600_000][entry.attempts] ?? 0;
+    const backoff = deliveryBackoffMilliseconds[entry.attempts] ?? 0;
     if (entry.lastAttemptAt !== null &&
         Date.now() - entry.lastAttemptAt < backoff)
         return undefined;

package/dist/src/daemon/opencode-stream.d.ts

@@ -0,0 +1,5 @@
+export declare function opencodeStream(): {
+    line: (line: string) => readonly string[];
+    stderr: (chunk: string) => void;
+    result: (exitCode: number | null) => string;
+};

package/dist/src/daemon/opencode-stream.js

@@ -0,0 +1,87 @@
+import { record } from "../protocol.js";
+import { sumUsage, usageOf, tokenCount, } from "../worker-usage.js";
+function parsed(line) {
+    try {
+        return record(JSON.parse(line)) ?? {};
+    }
+    catch {
+        return {};
+    }
+}
+function tokens(value) {
+    const counts = record(value) ?? {};
+    const cache = record(counts["cache"]) ?? {};
+    const output = tokenCount(counts["output"]);
+    const reasoning = tokenCount(counts["reasoning"]);
+    return usageOf({
+        input_tokens: counts["input"],
+        cache_read_input_tokens: cache["read"],
+        output_tokens: output === null || reasoning === null ? null : output + reasoning,
+    });
+}
+function errorMessage(value) {
+    const error = record(value) ?? {};
+    const data = record(error["data"]) ?? {};
+    const message = data["message"] ?? error["name"];
+    return typeof message === "string" ? message : "opencode error";
+}
+function translated(line, state) {
+    const event = parsed(line);
+    const part = record(event["part"]) ?? {};
+    if (typeof event["sessionID"] === "string")
+        state.sessionId = event["sessionID"];
+    if (typeof event["model"] === "string")
+        state.model = event["model"];
+    if (event["type"] === "error")
+        state.error = errorMessage(event["error"]);
+    if (event["type"] === "step_finish") {
+        state.steps.push(tokens(part["tokens"]));
+        state.reason = part["reason"];
+    }
+    if (event["type"] !== "text" || typeof part["text"] !== "string")
+        return [];
+    state.message = part["text"];
+    return [
+        JSON.stringify({
+            type: "assistant",
+            message: { content: [{ type: "text", text: state.message }] },
+        }),
+    ];
+}
+function result(exitCode, state) {
+    const success = exitCode === 0 && state.error === null && state.reason === "stop";
+    const failure = exitCode === 0
+        ? "opencode ended without a final stop step"
+        : `opencode ended with the code ${String(exitCode)}`;
+    return JSON.stringify({
+        type: "result",
+        subtype: success ? "success" : "error_during_execution",
+        is_error: !success,
+        result: success
+            ? state.message
+            : state.error || state.stderr.trim() || failure,
+        total_cost_usd: null,
+        model: state.model,
+        usage: sumUsage(state.steps),
+        session_id: state.sessionId,
+        num_turns: state.steps.length,
+    });
+}
+export function opencodeStream() {
+    const state = {
+        steps: [],
+        message: "",
+        sessionId: null,
+        model: null,
+        reason: null,
+        error: null,
+        stderr: "",
+    };
+    return {
+        line: (line) => translated(line, state),
+        stderr: (chunk) => {
+            state.stderr = (state.stderr + chunk).slice(-16_000);
+        },
+        result: (exitCode) => result(exitCode, state),
+    };
+}

package/dist/src/daemon/queue-status.d.ts

@@ -0,0 +1,4 @@
+export declare function activeQueueRuns(settings: {
+    readonly runtimeDirectory: string;
+    readonly workflowId?: string;
+}): Promise<number>;

package/dist/src/daemon/queue-status.js

@@ -0,0 +1,38 @@
+import { send } from "../cli/client.js";
+import { record } from "../protocol.js";
+function queueBusy(value) {
+    const busy = record(value)?.["busy"];
+    if (typeof busy !== "number")
+        return undefined;
+    if (!Number.isSafeInteger(busy) || busy < 0)
+        throw new Error("invalid-queue-status");
+    return busy;
+}
+export async function activeQueueRuns(settings) {
+    let count = 0;
+    let after = "";
+    do {
+        const reply = await send(settings.runtimeDirectory, {
+            operation: "status",
+            parameters: { after, limit: 500 },
+        });
+        if (reply.kind === "error")
+            throw new Error(reply.error.code);
+        const busy = queueBusy(reply.result["queue"]);
+        if (busy !== undefined)
+            return busy;
+        const runs = reply.result["runs"];
+        if (!Array.isArray(runs))
+            throw new Error("invalid-run-list");
+        count += runs.filter((value) => {
+            const run = record(value);
+            return (run?.["workflowId"] === (settings.workflowId ?? "develop-issue") &&
+                !["completed", "failed", "cancelled"].includes(String(run["state"])));
+        }).length;
+        const next = reply.result["next"];
+        if (next !== null && (typeof next !== "string" || next <= after))
+            throw new Error("invalid-run-page");
+        after = next;
+    } while (after !== null);
+    return count;
+}

package/dist/src/daemon/retry-worktree.d.ts

@@ -0,0 +1,18 @@
+export interface RetryTree {
+    readonly directory: string;
+    readonly signal: AbortSignal;
+}
+interface GitResult {
+    readonly text: string;
+    readonly code: number | null;
+}
+export declare function retryGit(tree: RetryTree, parts: readonly string[]): Promise<GitResult>;
+export declare function turnHead(tree: RetryTree): Promise<string | null>;
+export declare function retryEvidence(tree: RetryTree, startCommit: string | null): Promise<string>;
+export interface IndexFailure {
+    readonly reason: "worktree-index-unknown" | "worktree-index-locked";
+    readonly lockPath?: string;
+    readonly fix: string;
+}
+export declare function indexFailure(tree: RetryTree): Promise<IndexFailure | null>;
+export {};