cloving 1.3.0 → 1.4.0

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

@@ -9,8 +9,9 @@ export declare function knownMerge(operation: Operation, expected: ReviewedPull
     readonly updated: string;
 }): Promise<{
     readonly head: string;
+    readonly open: boolean;
     readonly merged: string | undefined;
 }>;
 export declare function mergePull(operation: Operation, pull: ReviewedPull & {
     readonly updated: string;
-}): Promise<string>;
+}): Promise<string | Error>;

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

@@ -136,35 +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,
-            check: pull.check,
+            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);
 }
@@ -209,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",
@@ -77,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");
@@ -262,8 +270,10 @@ 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",

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

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

@@ -1,4 +1,4 @@
-import { activeQueueRuns } from "./queue-status.js";
+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";
@@ -155,7 +155,7 @@ async function submit(settings, pending) {
     const reply = await send(settings.runtimeDirectory, {
         operation: "run",
         parameters: {
-            workflowId: settings.workflowId ?? "develop-issue",
+            workflowId: settings.workflowId,
             source: "ticket",
             submission: { ticket: "next" },
             commandId,
@@ -178,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);
@@ -242,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;
@@ -252,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 activeQueueRuns(settings);
-        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;

package/dist/src/daemon/notify.js

@@ -1,27 +1,9 @@
 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";
+import { notificationEvents } from "./notify-events.js";
 const retentionMilliseconds = 7 * 24 * 60 * 60_000;
-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 flushNotifications(journal) {
     if (journal.unsaved.size === 0)
         return;
@@ -36,60 +18,6 @@ async function finishDelivery(journal, entry) {
     journal.unsaved.set(entry.key, entry);
     await flushNotifications(journal);
 }
-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;
-}
-async function events(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;
-}
 export function notifyCommand(command, notification) {
     return new Promise((resolve, reject) => {
         const [executable = "", ...argumentsList] = command;
@@ -210,7 +138,7 @@ async function check(settings, journal) {
             journal.retiredKeys.add(key);
         }
     }
-    for (const event of await events(settings.runtimeDirectory, journal.cache)) {
+    for (const event of await notificationEvents(settings.runtimeDirectory, journal.cache)) {
         if (journal.entries.has(event.key) || journal.retiredKeys.has(event.key))
             continue;
         const entry = {
@@ -237,12 +165,12 @@ export async function notifyRuns(settings) {
         unsaved: new Map(),
     };
     if (recorded === undefined) {
-        for (const event of await events(settings.runtimeDirectory, cache))
+        for (const event of await notificationEvents(settings.runtimeDirectory, cache))
             journal.entries.set(event.key, {
                 ...event,
-                state: "sent",
+                state: event.message.event === "schedule-stopped" ? "pending" : "sent",
                 attempts: 0,
-                lastAttemptAt: Date.now(),
+                lastAttemptAt: event.message.event === "schedule-stopped" ? null : Date.now(),
                 lastFailure: null,
             });
     }

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

@@ -11,6 +11,7 @@ export interface WorkerReport {
     readonly reason?: string;
 }
 export interface Recorded {
+    readonly stoppedBy?: "daemon-shutdown";
     readonly outcome: WorkerReport["outcome"];
     readonly result?: string;
     readonly reason?: string;

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

@@ -1,4 +1,10 @@
-export declare function activeQueueRuns(settings: {
+export declare function queueStatus(settings: {
     readonly runtimeDirectory: string;
-    readonly workflowId?: string;
-}): Promise<number>;
+    readonly workflowId: string;
+}): Promise<{
+    readonly busy: number;
+    readonly holding: boolean;
+}>;
+export declare function spendNotice(): (status: {
+    readonly holding: boolean;
+}) => boolean;