cloving 1.3.0 → 1.5.0

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

@@ -0,0 +1,148 @@
+import { pullRequestTrigger, triggerKind, workflowApplies, } from "./github-ci-filters.js";
+import { field, repositoryPath } from "./github-operation.js";
+import { githubRead } from "./github-retry.js";
+async function pullBase(operation) {
+    const pull = JSON.parse(await githubRead(operation, [
+        "api",
+        `${repositoryPath}/pulls/${String(operation.payload["number"])}`,
+    ]));
+    if (typeof pull !== "object" || pull === null || !("base" in pull))
+        throw new Error("github-call-failed");
+    const baseData = pull.base;
+    if (typeof baseData !== "object" || baseData === null)
+        throw new Error("github-call-failed");
+    const base = field(baseData, "sha");
+    const branch = field(baseData, "ref");
+    if (typeof base !== "string" ||
+        !/^[0-9a-f]{40,64}$/.test(base) ||
+        typeof branch !== "string")
+        throw new Error("github-call-failed");
+    return { base, branch };
+}
+async function appliesToPull(operation, input) {
+    const { commit, trigger } = input;
+    if (trigger === false)
+        return false;
+    if (typeof trigger !== "object" || trigger === null)
+        return true;
+    if (!["paths", "paths-ignore", "branches", "branches-ignore"].some((key) => Object.hasOwn(trigger, key)))
+        return true;
+    const { base, branch } = await pullBase(operation);
+    await operation.calls.git(operation.settings.repository, [
+        "fetch",
+        "--quiet",
+        "--no-tags",
+        "origin",
+        base,
+    ]);
+    const paths = await operation.calls.git(operation.settings.repository, [
+        "diff",
+        "--name-only",
+        "-z",
+        `${base}...${commit}`,
+    ]);
+    return workflowApplies(trigger, {
+        branch,
+        paths: paths.split("\0").filter((path) => path !== ""),
+    });
+}
+export async function pullRequestWorkflows(operation, commit) {
+    const read = (parts) => operation.calls.git(operation.settings.repository, parts);
+    const paths = await read([
+        "ls-tree",
+        "-r",
+        "--name-only",
+        "-z",
+        commit,
+        "--",
+        ".github/workflows",
+    ]);
+    const workflows = [];
+    for (const path of paths.split("\0")) {
+        if (!/^\.github\/workflows\/[^/]+\.ya?ml$/.test(path))
+            continue;
+        const trigger = pullRequestTrigger(await read(["show", `${commit}:${path}`]));
+        if (await appliesToPull(operation, { commit, trigger }))
+            workflows.push({ path, kind: triggerKind(trigger) });
+    }
+    if (workflows.length === 0)
+        return workflows;
+    const inactive = await inactiveWorkflows(operation);
+    return workflows.filter((workflow) => !inactive.has(workflow.path));
+}
+function isList(value) {
+    return Array.isArray(value);
+}
+async function actionPages(operation, request) {
+    const pages = JSON.parse(await githubRead(operation, ["api", "--paginate", "--slurp", request.path]));
+    if (!isList(pages) || pages.length === 0)
+        throw new Error("github-call-failed");
+    return pages.flatMap((page) => {
+        if (typeof page !== "object" || page === null)
+            throw new Error("github-call-failed");
+        const items = field(page, request.key);
+        if (!isList(items))
+            throw new Error("github-call-failed");
+        return items;
+    });
+}
+async function inactiveWorkflows(operation) {
+    const workflows = await actionPages(operation, {
+        path: `${repositoryPath}/actions/workflows?per_page=100`,
+        key: "workflows",
+    });
+    const inactive = new Set();
+    for (const workflow of workflows) {
+        if (typeof workflow !== "object" || workflow === null)
+            throw new Error("github-call-failed");
+        const path = field(workflow, "path");
+        const state = field(workflow, "state");
+        if (typeof path !== "string" || typeof state !== "string")
+            throw new Error("github-call-failed");
+        if (state !== "active")
+            inactive.add(path);
+    }
+    return inactive;
+}
+function isWorkflowRun(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const conclusion = field(value, "conclusion");
+    return (typeof field(value, "id") === "number" &&
+        ["path", "head_sha", "event", "status"].every((key) => typeof field(value, key) === "string") &&
+        (conclusion === null || typeof conclusion === "string"));
+}
+async function workflowRuns(operation, commit) {
+    const runs = await actionPages(operation, {
+        path: `${repositoryPath}/actions/runs?head_sha=${commit}&event=pull_request&per_page=100`,
+        key: "workflow_runs",
+    });
+    if (!runs.every(isWorkflowRun))
+        throw new Error("github-call-failed");
+    return runs;
+}
+export async function pendingWorkflows(operation, input) {
+    if (input.workflows.length === 0)
+        return [];
+    const paths = input.workflows.map((workflow) => workflow.path);
+    const latest = new Map();
+    for (const run of await workflowRuns(operation, input.commit)) {
+        if (run.head_sha !== input.commit || run.event !== "pull_request")
+            continue;
+        const path = paths
+            .filter((expected) => run.path === expected || run.path.startsWith(`${expected}@`))
+            .sort((left, right) => right.length - left.length)[0];
+        if (path === undefined)
+            continue;
+        if (run.id > (latest.get(path)?.id ?? -1))
+            latest.set(path, run);
+    }
+    const pending = input.workflows.filter((workflow) => {
+        const run = latest.get(workflow.path);
+        if (run === undefined)
+            return workflow.kind === "push";
+        return (run.status !== "completed" ||
+            !["success", "neutral", "skipped"].includes(run.conclusion ?? ""));
+    });
+    return pending.length === 0 ? [] : ["waiting for GitHub Actions checks"];
+}

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

@@ -2,6 +2,7 @@ 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 { pendingWorkflows, pullRequestWorkflows, } from "./github-ci-workflows.js";
 import { ciWait, workflowAttempt, attemptChecks, rerunCi, attemptOutput, } from "./github-ci-rerun.js";
 import { field, githubTiming, repositoryPath, } from "./github-operation.js";
 function isCheckRun(value) {
@@ -203,16 +204,29 @@ async function ciFailureOutput(operation, input) {
             current,
         ]);
 }
-export async function waitForCi(operation, commit) {
-    const { pollMilliseconds: poll, ciGraceMilliseconds: grace, ciLimitMilliseconds: limit, } = {
+async function ciSettings(operation, commit) {
+    const timing = {
         ...githubTiming,
         ciGraceMilliseconds: 60_000,
         ciLimitMilliseconds: 5_400_000,
         ...operation.settings.timing,
     };
+    const required = requiredChecks(operation);
+    const workflows = required === undefined ? await pullRequestWorkflows(operation, commit) : [];
+    return {
+        required,
+        workflows,
+        poll: timing.pollMilliseconds,
+        limit: timing.ciLimitMilliseconds,
+        grace: workflows.some((workflow) => workflow.kind === "push")
+            ? Infinity
+            : timing.ciGraceMilliseconds,
+    };
+}
+export async function waitForCi(operation, commit) {
     const wait = await ciWait(operation, commit);
     const started = wait.startedAt;
-    const required = requiredChecks(operation);
+    const { required, workflows, grace, poll, limit } = await ciSettings(operation, commit);
     const names = new Set(required);
     for (;;) {
         const checks = latestRuns(await checkRuns(operation, commit), required);
@@ -232,7 +246,11 @@ export async function waitForCi(operation, commit) {
                     failed: retried.failures,
                 }),
             };
-        const pending = [...pendingChecks(checks, names), ...retried.pending];
+        const pending = [
+            ...pendingChecks(checks, names),
+            ...retried.pending,
+            ...(await pendingWorkflows(operation, { commit, workflows })),
+        ];
         if (pending.length === 0 &&
             (required !== undefined ||
                 names.size > 0 ||

package/dist/src/daemon/github-issue-methods.d.ts

@@ -1,3 +1,5 @@
 import { type Operation } from "./github-operation.ts";
+export declare function repositoryName(reply: string): string;
+export declare function captureDraft(operation: Operation): Promise<unknown>;
 export declare function createIssue(operation: Operation): Promise<unknown>;
 export declare function discard(operation: Operation): Promise<unknown>;

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

@@ -1,4 +1,5 @@
 import { existsSync } from "node:fs";
+import { createHash } from "node:crypto";
 import { lstat, readFile } from "node:fs/promises";
 import { basename, join } from "node:path";
 import { existingTree, removeWorktree, repositoryPath, text, } from "./github-operation.js";
@@ -30,7 +31,7 @@ function issuePage(line) {
         throw new Error("github-call-failed");
     return page.map((issue) => issueOf(issue));
 }
-function repositoryName(reply) {
+export function repositoryName(reply) {
     const repository = JSON.parse(reply);
     if (typeof repository !== "object" ||
         repository === null ||
@@ -50,6 +51,28 @@ async function draftOf(operation) {
         throw new Error("draft-not-available");
     return readFile(path, "utf8");
 }
+function draftDigest(text) {
+    return "sha256:" + createHash("sha256").update(text).digest("hex");
+}
+export async function captureDraft(operation) {
+    const text = await draftOf(operation);
+    const capture = { text, digest: draftDigest(text) };
+    if (Buffer.byteLength(JSON.stringify(capture)) > 65_536)
+        throw new Error("draft-too-large");
+    return capture;
+}
+function checkDraftDigest(operation, draft) {
+    if (!Object.hasOwn(operation.payload, "expectedDigests"))
+        return;
+    const digests = operation.payload["expectedDigests"];
+    if (!Array.isArray(digests) ||
+        digests.length === 0 ||
+        !digests.every((digest) => typeof digest === "string" && /^sha256:[0-9a-f]{64}$/.test(digest)))
+        throw new Error("invalid-payload");
+    const current = draftDigest(draft);
+    if (!digests.every((digest) => digest === current))
+        throw new Error("draft-changed");
+}
 async function knownIssue(operation, marker) {
     const output = await operation.calls.gh([
         "api",
@@ -62,7 +85,10 @@ async function knownIssue(operation, marker) {
 }
 export async function createIssue(operation) {
     operatorPrivateTexts(operation.settings);
-    const draft = await draftOf(operation);
+    const draft = Object.hasOwn(operation.payload, "text")
+        ? reportText(operation)
+        : await draftOf(operation);
+    checkDraftDigest(operation, draft);
     const [heading = "", ...lines] = draft.split("\n");
     if (!heading.startsWith("# ") || heading.slice(2).trim() === "")
         throw new Error("invalid-draft");
@@ -89,6 +115,15 @@ export async function createIssue(operation) {
     const url = printed.trim().split("\n").at(-1) ?? "";
     return issueFromUrl(url);
 }
+function reportText(operation) {
+    if (Object.hasOwn(operation.payload, "draft") ||
+        Object.hasOwn(operation.payload, "expectedDigests"))
+        throw new Error("invalid-payload");
+    const report = text(operation, "text");
+    if (Buffer.byteLength(report) > 65536)
+        throw new Error("draft-too-large");
+    return report;
+}
 export async function discard(operation) {
     const place = treePlace({
         worktrees: operation.settings.worktrees,

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,21 @@ 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 { inMergeTurn } from "./merge-turns.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 +83,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,15 +271,20 @@ 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, {
+        (operation) => inMergeTurn({
+            repository: operation.settings.repository,
+            signal: operation.signal,
+        }, () => 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;
@@ -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

@@ -1,12 +1,15 @@
+import { type QueuePort } from "../queue-state.ts";
 interface QueueSettings {
     readonly directory: string;
     readonly runtimeDirectory: string;
     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>;
+    readonly port: QueuePort;
+    readonly ready: Promise<void>;
 };
 export {};