cloving 1.1.0 → 1.2.0

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

@@ -1,28 +1,10 @@
 import { existsSync } from "node:fs";
-import { setTimeout as delay } from "node:timers/promises";
 import { readRecord, writeRecord } from "./operation-journal.js";
-import { changeChecked, defaultBranch, existingTree, field, githubTiming, removeWorktree, repositoryPath, } from "./github-operation.js";
+import { changeChecked, defaultBranch, existingTree, field, removeWorktree, repositoryPath, } from "./github-operation.js";
 import { treePlace } from "./work-tree.js";
-function commitOf(value, name) {
-    if (typeof value !== "object" || value === null)
-        throw new Error("github-call-failed");
-    const commit = Reflect.get(value, name);
-    if (typeof commit !== "string")
-        throw new Error("github-call-failed");
-    return commit;
-}
-async function knownMerge(operation, expected) {
-    const pull = JSON.parse(await operation.calls.gh([
-        "api",
-        `${repositoryPath}/pulls/${String(expected.number)}`,
-    ]));
-    const head = commitOf(field(pull, "head"), "sha");
-    if (field(pull, "merged") !== true)
-        return { head, merged: undefined };
-    if (head !== expected.commit && head !== expected.updated)
-        throw new Error("merged-other-commit");
-    return { head, merged: commitOf(pull, "merge_commit_sha") };
-}
+import { waitForCi } from "./github-ci.js";
+import { githubText } from "./github-calls.js";
+import { knownMerge, mergePull, } from "./github-merge-call.js";
 async function abortMerge(operation, tree) {
     const path = (await operation.calls.git(tree.path, [
         "rev-parse",
@@ -69,14 +51,19 @@ async function updatedTree(operation, place) {
             place.base,
         ]);
     }
-    catch {
+    catch (error) {
         const conflicts = await calls.git(place.tree.path, [
             "diff",
             "--name-only",
             "--diff-filter=U",
         ]);
         await calls.git(place.tree.path, ["merge", "--abort"]);
-        throw new Error("merge-conflict", { cause: conflicts.trim() });
+        const output = commandOutput(error instanceof Error ? error.cause : error);
+        throw Object.assign(new Error("merge-conflict", { cause: error }), {
+            output: githubText(output + conflicts, operation.settings)
+                .slice(-6_000)
+                .trim(),
+        });
     }
 }
 async function checked(operation, place) {
@@ -115,52 +102,6 @@ async function refreshed(operation, place) {
     }
     throw new Error("base-moved");
 }
-async function mergedNow(operation, pull) {
-    const reply = JSON.parse(await operation.calls.gh([
-        "api",
-        "-X",
-        "PUT",
-        `${repositoryPath}/pulls/${String(pull.number)}/merge`,
-        "-f",
-        "merge_method=merge",
-        "-f",
-        `sha=${pull.commit}`,
-    ]));
-    return commitOf(reply, "sha");
-}
-async function waitForHead(operation, pull) {
-    const timing = operation.settings.timing ?? githubTiming;
-    for (let attempt = 0; attempt < 30; attempt += 1) {
-        if (attempt > 0)
-            await delay(timing.pollMilliseconds, undefined, {
-                signal: operation.signal,
-            });
-        const current = JSON.parse(await operation.calls.gh([
-            "api",
-            `${repositoryPath}/pulls/${String(pull.number)}`,
-        ]));
-        if (commitOf(field(current, "head"), "sha") === pull.commit)
-            return;
-    }
-    throw new Error("head-not-updated");
-}
-async function mergeUpdated(operation, pull) {
-    const timing = operation.settings.timing ?? githubTiming;
-    for (let attempt = 0;; attempt += 1) {
-        await waitForHead(operation, pull);
-        try {
-            return await mergedNow(operation, pull);
-        }
-        catch (error) {
-            const status = field(error, "status");
-            if (attempt === 2 || (status !== 405 && status !== 409))
-                throw error;
-            await delay(timing.pollMilliseconds, undefined, {
-                signal: operation.signal,
-            });
-        }
-    }
-}
 async function removed(operation, place) {
     const { settings, calls } = operation;
     await calls
@@ -191,35 +132,47 @@ async function recordedHead(operation, commit) {
 }
 async function readyHead(operation, pull) {
     const tree = existingTree(operation);
-    const updated = await refreshed(operation, {
-        tree,
-        commit: pull.commit,
-        recorded: pull.recorded,
-    });
-    if (updated === pull.commit)
-        return updated;
-    if (pull.recorded !== updated)
-        await writeRecord(operation.folder, {
-            name: "updated-head.json",
-            value: { commit: pull.commit, updated },
+    let recorded = pull.recorded;
+    let remote = pull.remote;
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        const updated = await refreshed(operation, {
+            tree,
+            commit: pull.commit,
+            recorded,
         });
-    if (pull.remote !== updated)
-        await operation.calls.git(tree.path, [
-            "push",
-            "--quiet",
-            "origin",
-            `${updated}:refs/heads/${tree.branch}`,
-        ]);
-    return updated;
+        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;
+    }
+    throw new Error("base-moved");
 }
 function checkOutput(cause) {
+    return commandOutput(cause).slice(-6_000);
+}
+function commandOutput(cause) {
     return ["stdout", "stderr"]
         .map((name) => {
         const value = field(cause, name);
         return typeof value === "string" ? value : "";
     })
-        .join("")
-        .slice(-6_000);
+        .join("");
 }
 export async function merge(operation, pull) {
     try {
@@ -232,10 +185,13 @@ export async function merge(operation, pull) {
         const reason = error.message;
         if (reason !== "check-failed" && reason !== "merge-conflict")
             throw error;
-        const conflicts = typeof error.cause === "string" ? error.cause : "";
+        const detail = field(error, "output");
+        const conflicts = typeof detail === "string" ? detail : "";
         return {
             reason,
-            output: reason === "check-failed" ? checkOutput(error.cause) : conflicts,
+            output: reason === "check-failed"
+                ? checkOutput(error.cause)
+                : githubText(conflicts, operation.settings),
         };
     }
 }
@@ -252,8 +208,9 @@ async function completedMerge(operation, pull) {
     const updated = known.merged === undefined
         ? await readyHead(operation, { ...pull, recorded, remote: known.head })
         : (recorded ?? pull.commit);
-    const mergeCall = updated === pull.commit ? mergedNow : mergeUpdated;
-    const merged = known.merged ?? (await mergeCall(operation, { ...pull, commit: updated }));
+    if (typeof updated !== "string")
+        return updated;
+    const merged = known.merged ?? (await mergePull(operation, { ...pull, updated }));
     await removed(operation, place);
     return { number: pull.number, commit: pull.commit, updated, merged };
 }

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

@@ -1,5 +1,33 @@
+import { type Finding, type Scored } from "./github-calls.ts";
 import { type Operation } from "./github-operation.ts";
 export type { GithubTiming, MethodSettings } from "./github-operation.ts";
 export declare const methodReasons: ReadonlySet<string>;
+export interface ReviewResult extends Scored {
+    readonly number: number;
+    readonly commit: string;
+    readonly findings: readonly Finding[];
+}
+interface ReviewFailure {
+    readonly call: "read-review" | "request-review";
+    readonly reason: "github-call-failed" | "invalid-review-response";
+    readonly status?: number;
+}
+interface ReviewClock {
+    readonly now: () => number;
+    readonly sleep: (milliseconds: number, signal: AbortSignal) => Promise<void>;
+}
+interface ReviewWait {
+    readonly clock: ReviewClock;
+    failedReads: number;
+    requests: number;
+    acceptedRequests: number;
+    requestedAt: number;
+    lastFailure: ReviewFailure | null;
+}
+export declare class ReviewTimeout extends Error {
+    readonly detail: string;
+    constructor(wait: ReviewWait);
+}
+export declare function waitReview(operation: Operation, clock?: ReviewClock): Promise<ReviewResult>;
 export type Method = (operation: Operation) => Promise<unknown>;
 export declare const methods: ReadonlyMap<string, Method>;

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

@@ -1,17 +1,21 @@
 import { setTimeout as delay } from "node:timers/promises";
-import { findingsOf, scoreOf } from "./github-calls.js";
+import { appendFile } from "node:fs/promises";
+import { join } from "node:path";
+import { findingsOf, scoreOf, } from "./github-calls.js";
 import { closeIssue, partialIssue } from "./github-ticket-status.js";
 import { merge } from "./github-merge.js";
 import { createIssue, discard } 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([
     "draft-not-available",
     "invalid-draft",
     "post-uncertain",
     "private-texts-not-set",
     "github-call-failed",
+    "github-network-failed",
     "github-issue-conflict",
     "git-call-failed",
     "check-failed",
@@ -157,30 +161,90 @@ async function reviewed(operation, pull) {
     const lines = await read(`pulls/${String(number)}/comments?per_page=100`);
     return { number, commit, ...scored, findings: findingsOf(lines, commit) };
 }
-async function waitReview(operation) {
+const reviewClock = {
+    now: () => Date.now(),
+    sleep: async (milliseconds, signal) => {
+        await delay(milliseconds, undefined, { signal });
+    },
+};
+export class ReviewTimeout extends Error {
+    detail;
+    constructor(wait) {
+        super("review-not-received");
+        this.detail = JSON.stringify({
+            failedReads: wait.failedReads,
+            requests: wait.requests,
+            acceptedRequests: wait.acceptedRequests,
+            lastFailure: wait.lastFailure,
+        });
+    }
+}
+async function reviewFailure(operation, failed) {
+    const { wait, call, error } = failed;
+    const status = field(error, "status");
+    const failure = {
+        call,
+        reason: error instanceof SyntaxError
+            ? "invalid-review-response"
+            : "github-call-failed",
+        ...(typeof status === "number" &&
+            Number.isInteger(status) &&
+            status >= 400 &&
+            status <= 599
+            ? { status }
+            : {}),
+    };
+    wait.lastFailure = failure;
+    await appendFile(join(operation.folder, "review-failures.jsonl"), JSON.stringify(failure) + "\n", { mode: 0o600 }).catch(() => undefined);
+}
+async function requestReview(operation, request) {
+    const { wait, number } = request;
+    wait.requests++;
+    try {
+        await operation.calls.gh([
+            "pr",
+            "comment",
+            String(number),
+            "--body",
+            triggerText,
+        ]);
+        wait.acceptedRequests++;
+        wait.requestedAt = wait.clock.now();
+    }
+    catch (error) {
+        await reviewFailure(operation, { wait, call: "request-review", error });
+    }
+}
+export async function waitReview(operation, clock = reviewClock) {
     const pull = {
         number: integer(operation, "number"),
         commit: text(operation, "commit"),
     };
     const timing = operation.settings.timing ?? githubTiming;
-    const startedAt = Date.now();
-    let triggered = false;
+    const startedAt = clock.now();
+    const wait = {
+        clock,
+        failedReads: 0,
+        requests: 0,
+        acceptedRequests: 0,
+        requestedAt: startedAt,
+        lastFailure: null,
+    };
     for (;;) {
-        const review = await reviewed(operation, pull).catch(() => undefined);
+        const review = await reviewed(operation, pull).catch(async (error) => {
+            wait.failedReads++;
+            await reviewFailure(operation, { wait, call: "read-review", error });
+            return undefined;
+        });
         if (review !== undefined)
             return review;
-        const waited = Date.now() - startedAt;
+        const waited = clock.now() - startedAt;
         if (waited >= timing.limitMilliseconds)
-            throw new Error("review-not-received");
-        if (!triggered && waited >= timing.triggerMilliseconds) {
-            triggered = true;
-            await operation.calls
-                .gh(["pr", "comment", String(pull.number), "--body", triggerText])
-                .catch(() => undefined);
-        }
-        await delay(timing.pollMilliseconds, undefined, {
-            signal: operation.signal,
-        });
+            throw new ReviewTimeout(wait);
+        if (wait.acceptedRequests < maximumReviewRequests &&
+            clock.now() - wait.requestedAt >= timing.triggerMilliseconds)
+            await requestReview(operation, { wait, number: pull.number });
+        await clock.sleep(timing.pollMilliseconds, operation.signal);
     }
 }
 export const methods = new Map([

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

@@ -3,6 +3,8 @@ export interface GithubTiming {
     readonly pollMilliseconds: number;
     readonly triggerMilliseconds: number;
     readonly limitMilliseconds: number;
+    readonly ciLimitMilliseconds?: number;
+    readonly ciGraceMilliseconds?: number;
 }
 export declare const githubTiming: GithubTiming;
 export interface MethodSettings extends CallSettings {

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

@@ -0,0 +1,6 @@
+import { type Operation } from "./github-operation.ts";
+export declare function retryGithub<Result>(operation: Operation, retry: {
+    readonly action: (attempt: number) => Promise<Result>;
+    readonly statuses?: readonly number[];
+}): Promise<Result>;
+export declare function githubRead(operation: Operation, parts: readonly string[]): Promise<string>;

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

@@ -0,0 +1,49 @@
+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"),
+    });
+}
+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-ticket-status.js

@@ -87,12 +87,38 @@ function statusText(history) {
         lines.push(`Completed in pull request #${String(history.completedPullRequest)}.`);
     return `## Cloving status\n${lines.join("\n")}\n\n`;
 }
+function legacyFence(line) {
+    const marker = /^( {0,3}(?:[-+*]|\d{1,9}[.)])[ \t]+)? {0,3}(`{3,}|~{3,})/.exec(line);
+    if (marker === null || marker[2] === undefined)
+        return undefined;
+    const delimiter = marker[2];
+    if (delimiter.startsWith("`") && line.slice(marker[0].length).includes("`"))
+        return undefined;
+    const indentation = (marker[1]?.length ?? 0) + 3;
+    return new RegExp(`^ {0,${String(indentation)}}${delimiter.charAt(0)}{${String(delimiter.length)},}[ \\t]*\\r?\\n?$`);
+}
+function legacyStatusStart(body) {
+    let fence;
+    let offset = 0;
+    for (const line of body.split(/(?<=\n)/)) {
+        const start = offset;
+        offset += line.length;
+        if (fence !== undefined) {
+            fence = fence.test(line) ? undefined : fence;
+            continue;
+        }
+        if (line.trimEnd() === "## Cloving status")
+            return start;
+        fence = legacyFence(line);
+    }
+    return body.length;
+}
 function statusSection(body) {
     const empty = { version: 1, partialRuns: [] };
     const marker = /^<!-- cloving-status(?=\s|-->|$)/gm;
     const start = [...body.matchAll(marker)].at(-1)?.index;
     if (start === undefined)
-        return { outside: body, history: empty };
+        return { outside: body.slice(0, legacyStatusStart(body)), history: empty };
     const tail = body.slice(start);
     const end = tail.indexOf("-->");
     if (end !== -1 && tail.slice(end + 3).trim() !== "")

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

@@ -1,7 +1,7 @@
 import { readdir } from "node:fs/promises";
 import { join } from "node:path";
 import { calls } from "./github-calls.js";
-import { methodReasons, methods, } from "./github-methods.js";
+import { methodReasons, methods, ReviewTimeout, } from "./github-methods.js";
 import { interrupted, located, readRecord, replied, reportOf, writeRecord, } from "./operation-journal.js";
 const worker = "github";
 const closing = "github-worker-closed";
@@ -62,6 +62,7 @@ async function outcome(parts, run) {
         return {
             ...interrupted(methodReasons.has(reason) ? reason : "github-call-failed"),
             ...(typeof detail === "string" ? { detail } : {}),
+            ...(error instanceof ReviewTimeout ? { result: error.detail } : {}),
         };
     }
 }

package/dist/src/daemon/handoff-worker.d.ts

@@ -0,0 +1,10 @@
+import type { EffectDelivery } from "./delivery-router.ts";
+interface Settings {
+    readonly runtimeDirectory: string;
+    readonly journal: string;
+    readonly document: (digest: string) => Promise<string | undefined>;
+    readonly runStatus: (runId: string) => Promise<string | undefined>;
+    readonly retryMilliseconds?: number;
+}
+export declare function handoffWorker(settings: Settings): EffectDelivery;
+export {};