@dfsramos/foreman 0.0.0-stage → 0.2.0

package/dist/review/loop.js

@@ -0,0 +1,114 @@
+import { CI_MAX_RERUNS, decideReview, trackCi } from './decide.js';
+/**
+ * Review progress for an issue: what the tracker holds wins over the local record, so that rounds
+ * handled on another machine are believed. Before its first review round, everything since its
+ * last run counts as new.
+ */
+export async function progressOf(db, source, task) {
+    const held = await source.loadProgress?.(task);
+    return held ?? db.getReview(task.id) ?? { issueId: task.id, handledUntil: db.lastRunFinishedAt(task.id) ?? '', rounds: 0 };
+}
+/** Records review progress locally and then in the tracker, when it carries any, so another machine can resume from it. */
+export async function saveProgress(db, source, progress) {
+    db.saveReview(progress);
+    await source.saveProgress?.(progress);
+}
+/** The pull request's CI, when the project waits for it and the pull request is open; null otherwise. */
+export async function ciOf(git, project, pr) {
+    return project.waitForCi && pr?.state === 'OPEN' ? git.ciStatus(project.repoPath, pr.number) : null;
+}
+/**
+ * Hands an issue to a person over something about its pull request's head that no agent can settle,
+ * moving it to the approval state if it is still in review. A new push starts the head afresh.
+ */
+export async function handOverCi(db, source, task, stage, pr, needs) {
+    const moved = stage === 'review' ? ` Moved to "${source.describe().approval}"` : '';
+    await source.comment(task, `Foreman: the pull request needs a person: ${needs}.${moved}: ${pr.url}`).catch(() => { });
+    if (stage === 'review')
+        await source.approve(task);
+    await saveProgress(db, source, { ...(await progressOf(db, source, task)), ciHead: pr.headSha, ciHandled: true });
+}
+/**
+ * Looks at the pull request of every issue in review or awaiting approval: finishes the merged
+ * ones, moves plainly approved ones on, acts on their CI, and returns the rest of the new feedback
+ * for an agent. Issues in `busy` already have a run and are left alone.
+ */
+export async function checkReviews(deps, project, source, busy) {
+    const inReview = await source.fetchInReview();
+    const awaitingApproval = await source.fetchAwaitingApproval();
+    const stages = [
+        ['review', inReview],
+        ['approval', awaitingApproval],
+    ];
+    const work = [];
+    const errors = [];
+    for (const [stage, tasks] of stages) {
+        for (const task of tasks) {
+            if (busy.has(task.id))
+                continue;
+            const pr = await deps.git.pullRequest(project.repoPath, task.branchName);
+            let ci;
+            try {
+                ci = await ciOf(deps.git, project, pr);
+            }
+            catch (error) {
+                errors.push(`Could not read the checks of ${task.identifier}: ${error instanceof Error ? error.message : String(error)}`);
+                continue;
+            }
+            let progress = await progressOf(deps.db, source, task);
+            const tracked = pr ? trackCi(progress, pr, ci, deps.now()) : null;
+            if (tracked) {
+                progress = { ...progress, ...tracked };
+                await saveProgress(deps.db, source, progress);
+            }
+            const action = decideReview({ pr, progress, stage, ignoreAuthors: project.reviewIgnoreAuthors, now: deps.now(), mode: project.reviewMode, ci });
+            switch (action.kind) {
+                case 'none':
+                    break;
+                case 'finish':
+                    await source.finish(task);
+                    await source.comment(task, `Foreman: pull request merged (${action.pr.url}). Moved to "${source.describe().finished}".`).catch(() => { });
+                    break;
+                case 'approve':
+                    if (action.moveIssue) {
+                        await source.approve(task);
+                        await source
+                            .comment(task, `Foreman: the pull request was approved. Moved to "${source.describe().approval}"; a person now merges it: ${action.pr.url}`)
+                            .catch(() => { });
+                    }
+                    await saveProgress(deps.db, source, { ...(await progressOf(deps.db, source, task)), handledUntil: action.handledUntil, approvalHead: null });
+                    break;
+                case 'hold':
+                    await saveProgress(deps.db, source, { ...progress, handledUntil: action.handledUntil, approvalHead: action.pr.headSha });
+                    await source
+                        .comment(task, `Foreman: the pull request was approved; waiting for its checks to pass before moving it to "${source.describe().approval}": ${action.pr.url}`)
+                        .catch(() => { });
+                    break;
+                case 'rerun':
+                    try {
+                        for (const runId of action.runIds)
+                            await deps.git.rerunFailed(project.repoPath, runId);
+                    }
+                    catch (error) {
+                        await handOverCi(deps.db, source, task, stage, action.pr, `checks that could not be rerun (${action.checks.join(', ')}): ${error instanceof Error ? error.message : String(error)}`);
+                        break;
+                    }
+                    await saveProgress(deps.db, source, { ...progress, ciReruns: (progress.ciReruns ?? 0) + 1 });
+                    await source
+                        .comment(task, `Foreman: reran ${action.checks.join(', ')} (rerun ${(progress.ciReruns ?? 0) + 1} of ${CI_MAX_RERUNS}): GitHub Actions stopped them before they could judge the code.`)
+                        .catch(() => { });
+                    break;
+                case 'hand_over':
+                    await handOverCi(deps.db, source, task, stage, action.pr, action.needs);
+                    break;
+                case 'round':
+                    work.push({ task, pr: action.pr, feedback: action.feedback, conflict: action.conflict, stage, ...(action.ciFailures ? { ciFailures: action.ciFailures } : {}) });
+                    break;
+                case 'agent_review':
+                    work.push({ task, pr: action.pr, feedback: [], conflict: false, stage, agentReview: true });
+                    break;
+            }
+        }
+    }
+    return { inReview: inReview.length, awaitingApproval: awaitingApproval.length, work, errors };
+}