cloving 1.2.0 → 1.4.0

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

@@ -15,11 +15,12 @@ export async function knownMerge(operation, expected) {
         `${repositoryPath}/pulls/${String(expected.number)}`,
     ]));
     const head = commitOf(field(pull, "head"), "sha");
+    const open = field(pull, "state") === "open";
     if (field(pull, "merged") !== true)
-        return { head, merged: undefined };
+        return { head, open, merged: undefined };
     if (head !== expected.commit && head !== expected.updated)
         throw new Error("merged-other-commit");
-    return { head, merged: commitOf(pull, "merge_commit_sha") };
+    return { head, open, merged: commitOf(pull, "merge_commit_sha") };
 }
 async function mergedNow(operation, pull) {
     const reply = JSON.parse(await operation.calls.gh([
@@ -63,11 +64,17 @@ export function mergePull(operation, pull) {
         },
         statuses: pull.updated === pull.commit ? [] : [405, 409],
     }).catch(async (error) => {
-        if (!(error instanceof Error) || error.message !== "github-network-failed")
+        if (!(error instanceof Error))
+            throw error;
+        const refused = error.message === "github-call-failed" &&
+            [405, 409].includes(Number(field(error, "status")));
+        if (error.message !== "github-network-failed" && !refused)
             throw error;
         const known = await knownMerge(operation, pull);
         if (known.merged !== undefined)
             return known.merged;
+        if (refused && known.open)
+            return error;
         throw error;
     });
 }

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;
 }
@@ -135,34 +136,64 @@ async function readyHead(operation, pull) {
     let recorded = pull.recorded;
     let remote = pull.remote;
     for (let attempt = 0; attempt < 3; attempt += 1) {
-        const updated = await refreshed(operation, {
+        const updated = await pushedHead(operation, {
+            ...pull,
             tree,
-            commit: pull.commit,
             recorded,
+            remote,
         });
-        if (updated !== pull.commit && recorded !== updated)
-            await writeRecord(operation.folder, {
-                name: "updated-head.json",
-                value: { commit: pull.commit, updated },
-            });
-        if (updated !== pull.commit && remote !== updated)
-            await operation.calls.git(tree.path, [
-                "push",
-                "--quiet",
-                "origin",
-                `${updated}:refs/heads/${tree.branch}`,
-            ]);
         const ci = await waitForCi(operation, updated);
         if (ci !== undefined)
             return ci;
-        const newest = await fetched(operation, await defaultBranch(operation));
-        if ((await operation.calls.git(tree.path, ["merge-base", updated, newest])).trim() === newest)
-            return updated;
         recorded = updated;
         remote = updated;
+        if (!(await containsBase(operation, updated)))
+            continue;
+        const merged = await mergePull(operation, { ...pull, updated });
+        if (typeof merged === "string")
+            return { updated, merged };
+        if (await containsBase(operation, updated))
+            throw merged;
+        await recordRefusal(operation, { error: merged, updated, attempt });
     }
     throw new Error("base-moved");
 }
+async function recordRefusal(operation, refusal) {
+    const observation = await operation.observe?.({
+        condition: "working",
+        reason: "github-merge-refused",
+        evidence: `github-merge/HTTP-${String(field(refusal.error, "status"))}/head-${refusal.updated}/merge-main`,
+        attempt: refusal.attempt + 1,
+        limit: 3,
+    });
+    if (observation !== undefined &&
+        !["accepted", "duplicate"].includes(observation.kind))
+        throw new Error("github-call-failed");
+}
+async function pushedHead(operation, pull) {
+    const updated = await refreshed(operation, pull);
+    if (updated !== pull.commit && pull.recorded !== updated)
+        await writeRecord(operation.folder, {
+            name: "updated-head.json",
+            value: { commit: pull.commit, updated },
+        });
+    if (updated !== pull.commit && pull.remote !== updated)
+        await operation.calls.git(pull.tree.path, [
+            "push",
+            "--quiet",
+            "origin",
+            `${updated}:refs/heads/${pull.tree.branch}`,
+        ]);
+    return updated;
+}
+async function containsBase(operation, updated) {
+    const newest = await fetched(operation, await defaultBranch(operation));
+    return ((await operation.calls.git(existingTree(operation).path, [
+        "merge-base",
+        updated,
+        newest,
+    ])).trim() === newest);
+}
 function checkOutput(cause) {
     return commandOutput(cause).slice(-6_000);
 }
@@ -175,6 +206,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);
     }
@@ -205,12 +238,11 @@ async function completedMerge(operation, pull) {
         ...pull,
         updated: recorded ?? pull.commit,
     });
-    const updated = known.merged === undefined
+    const result = known.merged === undefined
         ? await readyHead(operation, { ...pull, recorded, remote: known.head })
-        : (recorded ?? pull.commit);
-    if (typeof updated !== "string")
-        return updated;
-    const merged = known.merged ?? (await mergePull(operation, { ...pull, updated }));
+        : { updated: recorded ?? pull.commit, merged: known.merged };
+    if ("reason" in result)
+        return result;
     await removed(operation, place);
-    return { number: pull.number, commit: pull.commit, updated, merged };
+    return { number: pull.number, commit: pull.commit, ...result };
 }

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

@@ -2,15 +2,20 @@ import { setTimeout as delay } from "node:timers/promises";
 import { appendFile } from "node:fs/promises";
 import { join } from "node:path";
 import { findingsOf, scoreOf, } from "./github-calls.js";
+import { attachAsset } from "./github-attach.js";
 import { closeIssue, partialIssue } from "./github-ticket-status.js";
 import { merge } from "./github-merge.js";
-import { createIssue, discard } from "./github-issue-methods.js";
+import { captureDraft, createIssue, discard, repositoryName, } from "./github-issue-methods.js";
 import { existingTree, defaultBranch, changeChecked, field, githubTiming, repositoryPath, text, } from "./github-operation.js";
 import { workTree } from "./work-tree.js";
 const triggerText = "@greptileai";
 const maximumReviewRequests = 3;
 export const methodReasons = new Set([
+    "attachment-not-available",
+    "attachment-too-large",
     "draft-not-available",
+    "draft-changed",
+    "draft-too-large",
     "invalid-draft",
     "post-uncertain",
     "private-texts-not-set",
@@ -21,6 +26,7 @@ export const methodReasons = new Set([
     "check-failed",
     "merge-conflict",
     "check-required",
+    "check-not-configured",
     "base-moved",
     "head-not-updated",
     "uncommitted-change",
@@ -37,6 +43,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"]);
@@ -68,7 +82,10 @@ function labels(operation, name) {
     });
 }
 async function label(operation) {
-    const repository = `${text(operation, "owner")}/${text(operation, "repository")}`;
+    const repository = !Object.hasOwn(operation.payload, "owner") &&
+        !Object.hasOwn(operation.payload, "repository")
+        ? repositoryName(await operation.calls.gh(["repo", "view", "--json", "nameWithOwner"]))
+        : `${text(operation, "owner")}/${text(operation, "repository")}`;
     const number = integer(operation, "number");
     if (!/^[\w.-]+\/[\w.-]+$/.test(repository) || !Number.isSafeInteger(number))
         throw new Error("invalid-payload");
@@ -253,14 +270,17 @@ export const methods = new Map([
     ["partial-issue", partialIssue],
     ["label", label],
     ["create-issue", createIssue],
+    ["capture-draft", captureDraft],
     ["discard", discard],
     ["open-pr", openPull],
+    ["attach-asset", attachAsset],
     ["wait-review", waitReview],
     [
         "merge",
         (operation) => merge(operation, {
             number: integer(operation, "number"),
             commit: text(operation, "commit"),
+            check: mergeCheck(operation),
         }),
     ],
 ]);

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

@@ -1,4 +1,5 @@
 import type { CallSettings, Calls } from "./github-calls.ts";
+import type { ObservationReport } from "../service/worker-port.ts";
 export interface GithubTiming {
     readonly pollMilliseconds: number;
     readonly triggerMilliseconds: number;
@@ -10,6 +11,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 {
@@ -19,6 +21,9 @@ export interface Operation {
     readonly payload: Readonly<Record<string, unknown>>;
     readonly signal: AbortSignal;
     readonly folder: string;
+    readonly observe?: (report: Pick<ObservationReport, "condition" | "reason" | "evidence" | "attempt" | "limit">) => Promise<{
+        readonly kind: string;
+    } | undefined>;
 }
 export interface Place {
     readonly path: string;

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

@@ -1,6 +1,8 @@
 import { homedir } from "node:os";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
+import { rm } from "node:fs/promises";
+import { attachmentFolder } from "./attachments.js";
 import { treePlace } from "./work-tree.js";
 export const githubTiming = {
     pollMilliseconds: 30_000,
@@ -32,6 +34,10 @@ export async function removeWorktree(operation, place) {
         await repository(["worktree", "remove", "--force", place.path]);
     if ((await repository(["branch", "--list", place.branch])).trim() !== "")
         await repository(["branch", "-D", place.branch]);
+    await rm(attachmentFolder({
+        worktrees: operation.settings.worktrees,
+        target: operation.target,
+    }), { recursive: true, force: true });
 }
 export async function defaultBranch(operation) {
     const reference = await operation.calls.git(operation.settings.repository, [

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/github-worker.d.ts

@@ -1,4 +1,5 @@
 import type { Delivery } from "../broker/actor/delivery-intents.ts";
+import type { ObservationReport } from "../service/worker-port.ts";
 import { type MethodSettings } from "./github-methods.ts";
 import { type WorkerReport } from "./operation-journal.ts";
 export type { GithubTiming } from "./github-methods.ts";
@@ -6,6 +7,9 @@ export interface GithubWorkerSettings extends MethodSettings {
     readonly journal: string;
     readonly document: (digest: string) => Promise<string | undefined>;
     readonly report: (report: WorkerReport) => Promise<unknown>;
+    readonly observe?: (report: ObservationReport) => Promise<{
+        readonly kind: string;
+    }>;
     readonly operationStatus: (operationId: string) => Promise<string | undefined>;
     readonly runStatus: (runId: string) => Promise<string | undefined>;
 }

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

@@ -47,6 +47,12 @@ async function outcome(parts, run) {
             target: intent.target,
             payload,
             signal,
+            observe: async (observation) => settings.observe?.({
+                ...observation,
+                runId: intent.runId,
+                operationId: intent.operationId,
+                commandId: `github:${run.key}:merge-refused:${String(observation.attempt)}`,
+            }),
         });
         return {
             outcome: "completed",

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 { queueStatus, spendNotice } 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,
             source: "ticket",
             submission: { ticket: "next" },
             commandId,
@@ -201,6 +178,7 @@ async function submit(settings, pending) {
         "workflow-active",
         "ticket-active",
         "ticket-dependency-open",
+        "queue-spend-limit",
     ].includes(reply.error.code))
         throw new Error(reply.error.code);
     pending.commands.delete(commandId);
@@ -265,7 +243,13 @@ async function cycle(settings, signal) {
         pending.failures.length = 0;
         await pending.save();
     }
-    const holding = updateHold(settings.directory, pending);
+    const update = updateHold(settings.directory, pending);
+    const notice = spendNotice();
+    const holding = async (activeRuns = 0) => {
+        const updating = await update(activeRuns);
+        const spend = notice(await queueStatus(settings));
+        return updating || spend;
+    };
     await rm(join(settings.directory, "queue-submission"), { force: true });
     await recover(settings, pending);
     const stopped = () => signal.aborted;
@@ -275,15 +259,13 @@ async function cycle(settings, signal) {
             return;
         const pendingRuns = await completed(settings, pending);
         const lanes = settings.lanes ?? 1;
-        if (pendingRuns >= lanes) {
-            await holding(pendingRuns);
-            continue;
-        }
-        const activeRuns = await active(settings.runtimeDirectory);
-        const held = await holding(activeRuns);
-        if (activeRuns >= lanes || activeRuns < pendingRuns)
+        const status = await queueStatus(settings);
+        const spend = notice(status);
+        const updating = await update(status.busy);
+        if (Math.max(pendingRuns, status.busy) >= lanes ||
+            status.busy < pendingRuns)
             continue;
-        if (held)
+        if (updating || spend)
             continue;
         if (stopped())
             return;

package/dist/src/daemon/notify-events.d.ts

@@ -0,0 +1,6 @@
+import { type NotifyEvent } from "./notify-message.ts";
+export type OutcomeCache = Map<string, {
+    readonly latestSequence: number;
+    readonly event: NotifyEvent | undefined;
+}>;
+export declare function notificationEvents(runtimeDirectory: string, cache: OutcomeCache): Promise<readonly NotifyEvent[]>;

package/dist/src/daemon/notify-events.js

@@ -0,0 +1,84 @@
+import { send } from "../cli/client.js";
+import { record } from "../protocol.js";
+import { decisionNotification, outcomeNotification, scheduleStopNotifications, } from "./notify-message.js";
+async function request(runtimeDirectory, request) {
+    const reply = await send(runtimeDirectory, request);
+    if (reply.kind === "error")
+        throw new Error(reply.error.code);
+    return reply.result;
+}
+function rows(value) {
+    if (!Array.isArray(value))
+        throw new Error("invalid-notify-list");
+    return value.map((item) => {
+        const row = record(item);
+        if (row === undefined)
+            throw new Error("invalid-notify-row");
+        return row;
+    });
+}
+async function scheduleNotifications(runtimeDirectory) {
+    const reply = await send(runtimeDirectory, {
+        operation: "schedule",
+        parameters: { action: "list" },
+    });
+    if (reply.kind !== "error")
+        return rows(reply.result["stops"]).flatMap(scheduleStopNotifications);
+    if (reply.error.code === "schedules-unavailable")
+        return [];
+    throw new Error(reply.error.code);
+}
+async function observedOutcome(summary, source) {
+    const { runtimeDirectory, cache } = source;
+    const latestSequence = summary["latestSequence"];
+    if (typeof latestSequence !== "number")
+        throw new Error("invalid-notify-sequence");
+    const runId = String(summary["runId"]);
+    const previous = cache.get(runId);
+    if (previous !== undefined && previous.latestSequence === latestSequence)
+        return previous.event;
+    const status = await request(runtimeDirectory, {
+        operation: "status",
+        parameters: { runId },
+    });
+    const run = record(status["run"]);
+    if (run === undefined)
+        throw new Error("invalid-notify-status");
+    const event = outcomeNotification(run);
+    cache.set(runId, { latestSequence, event });
+    return event;
+}
+export async function notificationEvents(runtimeDirectory, cache) {
+    const found = [];
+    const runs = new Map();
+    let after = "";
+    do {
+        const page = await request(runtimeDirectory, {
+            operation: "status",
+            parameters: { after, limit: 500 },
+        });
+        for (const summary of rows(page["runs"])) {
+            runs.set(String(summary["runId"]), summary);
+            const outcome = await observedOutcome(summary, {
+                runtimeDirectory,
+                cache,
+            });
+            if (outcome !== undefined)
+                found.push(outcome);
+        }
+        const next = page["next"];
+        if (next !== null && (typeof next !== "string" || next <= after))
+            throw new Error("invalid-notify-page");
+        after = next;
+    } while (after !== null);
+    const questions = await request(runtimeDirectory, {
+        operation: "questions",
+        parameters: {},
+    });
+    for (const decision of rows(questions["decisions"])) {
+        const run = runs.get(String(decision["runId"]));
+        if (run !== undefined)
+            found.push(decisionNotification(run, decision));
+    }
+    return [...found, ...(await scheduleNotifications(runtimeDirectory))];
+}

package/dist/src/daemon/notify-journal.js

@@ -46,7 +46,7 @@ function notification(value) {
     const message = record(value);
     if (message === undefined)
         return false;
-    return (["decision", "blocked", "failed"].includes(String(message["event"])) &&
+    return (["decision", "blocked", "failed", "schedule-stopped"].includes(String(message["event"])) &&
         ["event", "runId", "workflowId", "subject", "body"].every((field) => typeof message[field] === "string"));
 }
 function deliveryState(value) {

package/dist/src/daemon/notify-message.d.ts

@@ -1,10 +1,11 @@
 import { type Fields } from "../protocol.ts";
 export interface Notification {
-    readonly event: "decision" | "blocked" | "failed";
+    readonly event: "decision" | "blocked" | "failed" | "schedule-stopped";
     readonly runId: string;
     readonly workflowId: string;
     readonly subject: string;
     readonly body: string;
+    readonly failedRunIds?: readonly string[];
 }
 export interface NotifyEvent {
     readonly key: string;
@@ -12,3 +13,5 @@ export interface NotifyEvent {
 }
 export declare function decisionNotification(run: Fields, decision: Fields): NotifyEvent;
 export declare function outcomeNotification(run: Fields): NotifyEvent | undefined;
+export declare function stoppedScheduleNotification(schedule: Fields): NotifyEvent | undefined;
+export declare function scheduleStopNotifications(schedule: Fields): readonly NotifyEvent[];

package/dist/src/daemon/notify-message.js

@@ -47,3 +47,39 @@ export function outcomeNotification(run) {
         }),
     };
 }
+export function stoppedScheduleNotification(schedule) {
+    if (schedule["state"] !== "stopped")
+        return undefined;
+    const failedRunIds = schedule["failedRunIds"];
+    if (!Array.isArray(failedRunIds) || failedRunIds.length !== 3)
+        throw new Error("invalid-stopped-schedule");
+    const ids = failedRunIds.map((runId) => String(runId));
+    const workflowId = String(schedule["workflowId"]);
+    return {
+        key: `schedule-stopped:${workflowId}:${String(schedule["stoppedSlot"])}`,
+        message: {
+            ...message({ workflowId, runId: ids[2] }, {
+                event: "schedule-stopped",
+                body: body(`Schedule stopped after three failed runs:\n${ids.join("\n")}`, [`cloving schedule resume ${workflowId}`]),
+            }),
+            failedRunIds: ids,
+        },
+    };
+}
+export function scheduleStopNotifications(schedule) {
+    const stops = schedule["stops"];
+    if (stops === undefined) {
+        const event = stoppedScheduleNotification(schedule);
+        return event === undefined ? [] : [event];
+    }
+    if (!Array.isArray(stops))
+        throw new Error("invalid-stopped-schedule");
+    return stops.flatMap((stop) => {
+        const event = stoppedScheduleNotification({
+            ...record(stop),
+            workflowId: schedule["workflowId"],
+            state: "stopped",
+        });
+        return event === undefined ? [] : [event];
+    });
+}

package/dist/src/daemon/notify.d.ts

@@ -1,4 +1,4 @@
-import { type Notification } from "./notify-message.ts";
+import type { Notification } from "./notify-message.ts";
 interface NotifySettings {
     readonly directory: string;
     readonly runtimeDirectory: string;