@doist/doistbot-cli 1.0.1 → 1.0.3

package/sandbox/dist/tasks/issue-triage/fix-loop/effects.js

@@ -0,0 +1,464 @@
+import { logger } from '../../../core/logging.js';
+import { withRetry } from '../../../core/retry.js';
+import { renderPriorityBadge } from '../../review/github-comment-format.js';
+import { runLocalReview as defaultRunLocalReview } from '../../review/local.js';
+import { parseSeverity } from '../../review/severity.js';
+import { runFixCore as defaultRunFixCore, stripPRTitleSection } from '../fix-attempt.js';
+import { resolveHeroTeamSlug } from '../hero-group-map.js';
+import { FIX_LOOP_START_MARKER } from '../markers.js';
+import { commitAndPushFix as defaultCommitAndPushFix, commitAndPushIteration as defaultCommitAndPushIteration, openDraftFixPR as defaultOpenDraftFixPR, } from '../pr-creator.js';
+export function buildFixLoopStartCommentBody(args) {
+    const p0 = renderPriorityBadge('P0') ?? 'P0';
+    const p1 = renderPriorityBadge('P1') ?? 'P1';
+    return [
+        FIX_LOOP_START_MARKER,
+        '',
+        '### Working on a fix',
+        '',
+        `I've opened a draft PR with an initial fix: ${args.prUrl}`,
+        '',
+        `The PR targets \`${args.targetRepoFullName}\`. I'll review it locally, iterate on ${p0} and ${p1} findings, and run CI. Once everything passes, I'll promote the PR out of draft and request a hero review on it.`,
+    ].join('\n');
+}
+const DRY_RUN_HEAD_SHA = '0'.repeat(40);
+const DRY_RUN_BRANCH = 'doistbot/dry-run';
+const DRY_RUN_PR_NUMBER = 0;
+const FAILURE_CONCLUSIONS = new Set([
+    'failure',
+    'cancelled',
+    'timed_out',
+    'action_required',
+    'startup_failure',
+]);
+const FAILURE_STATUS_STATES = new Set(['error', 'failure']);
+function defaultDeps() {
+    return {
+        runFixCore: defaultRunFixCore,
+        commitAndPushFix: defaultCommitAndPushFix,
+        commitAndPushIteration: defaultCommitAndPushIteration,
+        openDraftFixPR: defaultOpenDraftFixPR,
+        runLocalReview: defaultRunLocalReview,
+    };
+}
+export class DefaultLoopEffects {
+    session;
+    opts;
+    deps;
+    constructor(session, opts = {}, deps = defaultDeps()) {
+        this.session = session;
+        this.opts = opts;
+        this.deps = deps;
+    }
+    logContext(extra = {}) {
+        const session = this.session;
+        return {
+            task: session.kind,
+            delivery_id: session.ctx.deliveryId,
+            source_repository: `${session.ctx.owner}/${session.ctx.repo}`,
+            target_repository: session.targetRepo.repository.fullName,
+            // issue_number identifies the source issue the bot is triaging in
+            // Run 1. Promotion (Run 2) has no source issue, so the field is
+            // emitted only when the session is fix-loop-shaped.
+            ...(session.kind === 'fix-loop' ? { issue_number: session.ctx.issueNumber } : {}),
+            ...extra,
+        };
+    }
+    async runFix(input) {
+        const session = this.session;
+        const result = await this.deps.runFixCore({
+            ctx: session.ctx,
+            triageOutput: session.triageOutput,
+            fixAssessment: session.fixAssessment,
+            targetRepo: session.targetRepo,
+            issueTitle: session.issueTitle,
+            issueUrl: session.issueUrl,
+            ghToken: session.ghToken,
+            ...(input.prevHeadSha !== undefined && { resetTo: input.prevHeadSha }),
+            ...(input.previousFindings !== undefined && {
+                previousFindings: input.previousFindings,
+            }),
+        });
+        if (!result.ok) {
+            return { ok: false, reason: result.reason };
+        }
+        return {
+            ok: true,
+            diff: result.diff,
+            codexOutput: result.codexOutput,
+            generatedPRTitle: result.generatedPRTitle,
+            generatedPRBody: result.generatedPRBody,
+        };
+    }
+    async runReview(input) {
+        const session = this.session;
+        const workspaceDir = this.opts.reviewWorkspaceDir ?? session.targetRepo.localPath;
+        const source = input.reviewBaseSha !== undefined
+            ? { kind: 'sha-range', baseSha: input.reviewBaseSha }
+            : 'base';
+        const result = await this.deps.runLocalReview({
+            workspaceDir,
+            source,
+            apiKeys: session.apiKeys,
+        });
+        if (result.reviewResult.status !== 'reviewed') {
+            // Only `empty_review` means the review actually ran and the
+            // reviewer produced zero comments. The other skip reasons signal
+            // the review pipeline never reached a verdict (no models, no diff
+            // to review, model returned nothing), and an unreviewed fix must
+            // NOT advance toward CI/promotion.
+            if (result.reviewResult.reason === 'empty_review') {
+                logger.info('Review returned no comments; treating as clean', this.logContext({
+                    iteration: input.iteration,
+                }));
+                return { kind: 'reviewed', findings: [], raw: { summary: '', comments: [] } };
+            }
+            logger.warn('Review unverified; escalating', this.logContext({
+                iteration: input.iteration,
+                reason: result.reviewResult.reason,
+            }));
+            return { kind: 'unverified', reason: result.reviewResult.reason };
+        }
+        const review = result.reviewResult.review;
+        const comments = review.comments;
+        const findings = comments.map((c) => ({
+            path: c.path,
+            line: c.line,
+            severity: parseSeverity(c.body),
+            body: c.body,
+        }));
+        return { kind: 'reviewed', findings, raw: review };
+    }
+    async pushCommit(input) {
+        if (input.iteration > 0 && input.branch === undefined) {
+            // Iteration > 0 always appends to an existing branch — opening a
+            // fresh draft PR would orphan the new commit from the original
+            // one. The runner should thread state.branch through; reaching
+            // here means a caller bug.
+            throw new Error(`DefaultLoopEffects.pushCommit: iteration ${input.iteration} requires a branch from the prior push`);
+        }
+        if (this.opts.dryRun) {
+            logger.info('DRY RUN: would commit and push fix', this.logContext({
+                iteration: input.iteration,
+                diff_lines: input.diff.split('\n').length,
+            }));
+            const isFirstPush = input.branch === undefined;
+            if (isFirstPush) {
+                logger.info('DRY RUN: would open draft fix PR', this.logContext());
+                logger.info('DRY RUN: would post fix-loop start comment on source issue', {
+                    ...this.logContext(),
+                    source_issue_number: this.session.ctx.issueNumber,
+                });
+            }
+            return {
+                headSha: DRY_RUN_HEAD_SHA,
+                branch: input.branch ?? DRY_RUN_BRANCH,
+                prNumber: DRY_RUN_PR_NUMBER,
+            };
+        }
+        if (input.branch === undefined) {
+            return this.pushFirstCommit(input);
+        }
+        return this.pushIteration(input, input.branch);
+    }
+    async pushFirstCommit(input) {
+        const session = this.session;
+        const { branch, headSha } = await this.deps.commitAndPushFix({
+            repoOwner: session.targetRepo.repository.owner,
+            repoName: session.targetRepo.repository.repo,
+            repoLocalPath: session.targetRepo.localPath,
+            githubToken: session.pushToken,
+            issueNumber: session.ctx.issueNumber,
+            issueTitle: session.issueTitle,
+            ...(input.generatedPRTitle ? { prTitle: input.generatedPRTitle } : {}),
+        });
+        const prResult = await this.deps.openDraftFixPR({
+            repoOwner: session.targetRepo.repository.owner,
+            repoName: session.targetRepo.repository.repo,
+            octokit: session.octokit,
+            issueNumber: session.ctx.issueNumber,
+            issueTitle: session.issueTitle,
+            issueUrl: session.issueUrl,
+            triageAnalysis: session.triageOutput,
+            fixDescription: stripPRTitleSection(input.codexOutput),
+            branch,
+            ...(input.generatedPRTitle ? { prTitle: input.generatedPRTitle } : {}),
+            ...(input.generatedPRBody ? { prBody: input.generatedPRBody } : {}),
+            fixAssessment: session.fixAssessment,
+        });
+        await this.postFixStartedSourceIssueComment({
+            prUrl: prResult.prUrl,
+            prNumber: prResult.prNumber,
+        });
+        return {
+            headSha,
+            branch,
+            prNumber: prResult.prNumber,
+            prUrl: prResult.prUrl,
+        };
+    }
+    async postFixStartedSourceIssueComment(args) {
+        const session = this.session;
+        const body = buildFixLoopStartCommentBody({
+            prUrl: args.prUrl,
+            targetRepoFullName: session.targetRepo.repository.fullName,
+        });
+        try {
+            // Find-or-update by marker so a redelivery (after an opened PR but
+            // a failed response on this side) does not double-post.
+            const existing = await this.findSourceIssueCommentByMarker(FIX_LOOP_START_MARKER);
+            if (existing) {
+                await session.octokit.rest.issues.updateComment({
+                    owner: session.ctx.owner,
+                    repo: session.ctx.repo,
+                    comment_id: existing.id,
+                    body,
+                });
+            }
+            else {
+                await session.octokit.rest.issues.createComment({
+                    owner: session.ctx.owner,
+                    repo: session.ctx.repo,
+                    issue_number: session.ctx.issueNumber,
+                    body,
+                });
+            }
+            logger.info('fix-loop: posted start comment on source issue', this.logContext({
+                pr_number: args.prNumber,
+                source_issue_number: session.ctx.issueNumber,
+            }));
+        }
+        catch (error) {
+            // Comment posting is best-effort — never fail the PR creation if
+            // it errors. The PR is already open and the loop must keep going.
+            logger.warn('fix-loop: failed to post start comment on source issue', this.logContext({
+                pr_number: args.prNumber,
+                source_issue_number: session.ctx.issueNumber,
+                error: error instanceof Error ? error.message : String(error),
+            }));
+        }
+    }
+    async findSourceIssueCommentByMarker(marker) {
+        const session = this.session;
+        const comments = await session.octokit.paginate(session.octokit.rest.issues.listComments, {
+            owner: session.ctx.owner,
+            repo: session.ctx.repo,
+            issue_number: session.ctx.issueNumber,
+            per_page: 100,
+        });
+        return comments.find((c) => typeof c.body === 'string' && c.body.includes(marker));
+    }
+    async pushIteration(input, branch) {
+        const session = this.session;
+        // Subsequent iterations must update the existing PR by pushing to the
+        // same branch. commitAndPushFix would generate a fresh branch and
+        // orphan the new commit from the open PR, so we use
+        // commitAndPushIteration.
+        const { headSha } = await this.deps.commitAndPushIteration({
+            repoOwner: session.targetRepo.repository.owner,
+            repoName: session.targetRepo.repository.repo,
+            repoLocalPath: session.targetRepo.localPath,
+            branch,
+            githubToken: session.pushToken,
+            issueNumber: session.ctx.issueNumber,
+            issueTitle: session.issueTitle,
+            ...(input.generatedPRTitle ? { prTitle: input.generatedPRTitle } : {}),
+        });
+        return { headSha, branch };
+    }
+    async applyLabels(input) {
+        if (this.opts.dryRun) {
+            logger.info('DRY RUN: would apply labels', this.logContext({ pr_number: input.prNumber, labels: input.labels }));
+            return;
+        }
+        await withRetry(() => this.session.octokit.rest.issues.addLabels({
+            owner: this.session.targetRepo.repository.owner,
+            repo: this.session.targetRepo.repository.repo,
+            issue_number: input.prNumber,
+            labels: input.labels,
+        }));
+    }
+    async postIssueComment(input) {
+        if (this.opts.dryRun) {
+            logger.info('DRY RUN: would post issue comment', this.logContext({
+                pr_number: input.prNumber,
+                body_chars: input.body.length,
+                marker: input.marker,
+            }));
+            return;
+        }
+        const owner = this.session.targetRepo.repository.owner;
+        const repo = this.session.targetRepo.repository.repo;
+        const body = input.marker ? `${input.marker}\n\n${input.body}` : input.body;
+        if (input.marker !== undefined) {
+            const existing = await this.findCommentByMarker(input.prNumber, input.marker);
+            if (existing) {
+                await this.session.octokit.rest.issues.updateComment({
+                    owner,
+                    repo,
+                    comment_id: existing.id,
+                    body,
+                });
+                return;
+            }
+        }
+        await this.session.octokit.rest.issues.createComment({
+            owner,
+            repo,
+            issue_number: input.prNumber,
+            body,
+        });
+    }
+    async findCommentByMarker(prNumber, marker) {
+        const comments = await this.session.octokit.paginate(this.session.octokit.rest.issues.listComments, {
+            owner: this.session.targetRepo.repository.owner,
+            repo: this.session.targetRepo.repository.repo,
+            issue_number: prNumber,
+            per_page: 100,
+        });
+        return comments.find((c) => typeof c.body === 'string' && c.body.includes(marker));
+    }
+    async cloneRepo(_input) {
+        // Cloning is handled by the triage entrypoint before DefaultLoopEffects is
+        // constructed; the cloned repo is supplied via session.targetRepo.
+        return this.session.targetRepo;
+    }
+    async checkCIStatus(headSha) {
+        // Both endpoints collapse history to one entry per name/context. For
+        // checks: `filter=latest` keeps only the most recent run per check
+        // name (matters when a workflow has been re-run). For commit statuses:
+        // /commits/{ref}/status returns one combined object whose `statuses`
+        // array is already the latest entry per context — so we call it
+        // directly (not via paginate, which would yield combined-status
+        // objects, not the inner status entries).
+        const [checkRuns, combined] = await Promise.all([
+            this.session.octokit.paginate(this.session.octokit.rest.checks.listForRef, {
+                owner: this.session.targetRepo.repository.owner,
+                repo: this.session.targetRepo.repository.repo,
+                ref: headSha,
+                filter: 'latest',
+                per_page: 100,
+            }),
+            this.session.octokit.rest.repos.getCombinedStatusForRef({
+                owner: this.session.targetRepo.repository.owner,
+                repo: this.session.targetRepo.repository.repo,
+                ref: headSha,
+            }),
+        ]);
+        const statuses = combined.data.statuses;
+        const failedChecks = [];
+        const pendingChecks = [];
+        let totalEntries = 0;
+        for (const cr of checkRuns) {
+            totalEntries++;
+            const info = {
+                name: cr.name,
+                conclusion: cr.conclusion ?? null,
+                url: cr.html_url ?? cr.details_url ?? '',
+            };
+            if (cr.status !== 'completed') {
+                pendingChecks.push(info);
+                continue;
+            }
+            if (cr.conclusion && FAILURE_CONCLUSIONS.has(cr.conclusion)) {
+                failedChecks.push(info);
+            }
+        }
+        for (const status of statuses) {
+            totalEntries++;
+            const info = {
+                name: status.context,
+                conclusion: status.state ?? null,
+                url: status.target_url ?? '',
+            };
+            if (status.state === 'pending') {
+                pendingChecks.push(info);
+                continue;
+            }
+            if (FAILURE_STATUS_STATES.has(status.state ?? '')) {
+                failedChecks.push(info);
+            }
+        }
+        if (totalEntries === 0) {
+            return { kind: 'no_checks', headSha };
+        }
+        if (failedChecks.length > 0) {
+            return { kind: 'failed', headSha, failedChecks };
+        }
+        if (pendingChecks.length > 0) {
+            return { kind: 'pending', headSha, pendingChecks };
+        }
+        return { kind: 'passed', headSha };
+    }
+    async promoteToReady(prNumber) {
+        if (this.opts.dryRun) {
+            logger.info('DRY RUN: would promote PR to ready', this.logContext({
+                pr_number: prNumber,
+            }));
+            return;
+        }
+        // TODO: thread node_id through from the webhook handler's
+        // fetchPRPromotionState so this second pulls.get goes away.
+        const pr = await withRetry(() => this.session.octokit.rest.pulls.get({
+            owner: this.session.targetRepo.repository.owner,
+            repo: this.session.targetRepo.repository.repo,
+            pull_number: prNumber,
+        }));
+        // Idempotency: markPullRequestReadyForReview throws
+        // `UNPROCESSABLE: Pull request is not a draft` if the PR is already
+        // ready. On webhook redelivery the catch block in runPromotionFlow
+        // would re-arm awaiting-ci and loop on every subsequent CI event.
+        if (!pr.data.draft) {
+            return;
+        }
+        await withRetry(() => this.session.octokit.graphql(`mutation($pullRequestId: ID!) {
+                    markPullRequestReadyForReview(input: { pullRequestId: $pullRequestId }) {
+                        pullRequest { isDraft }
+                    }
+                }`, { pullRequestId: pr.data.node_id }));
+    }
+    async applyAskLabel(prNumber) {
+        if (this.opts.dryRun) {
+            logger.info('DRY RUN: would apply ask label', this.logContext({ pr_number: prNumber }));
+            return;
+        }
+        const labels = await this.session.octokit.paginate(this.session.octokit.rest.issues.listLabelsForRepo, {
+            owner: this.session.targetRepo.repository.owner,
+            repo: this.session.targetRepo.repository.repo,
+            per_page: 100,
+        });
+        // `\bask\b` matches `ask`, `Ask`, `ask: review`, `Review:Ask`, etc.
+        // without false-positives on labels that merely contain the substring
+        // (e.g. `Type:Task`). The repo-label search is the contract because
+        // the actual label name is repo-specific.
+        const candidates = labels.filter((label) => /\bask\b/i.test(label.name));
+        if (candidates.length === 0) {
+            logger.warn('No ask-style label found on target repo; promoted PR will not be marked for pre-merge review', this.logContext({ pr_number: prNumber }));
+            return;
+        }
+        const chosen = candidates[0].name;
+        if (candidates.length > 1) {
+            logger.info('Multiple ask-style label candidates found; applying the first match', this.logContext({
+                pr_number: prNumber,
+                candidates: candidates.map((c) => c.name),
+                chosen,
+            }));
+        }
+        await this.applyLabels({ prNumber, labels: [chosen] });
+    }
+    async requestHeroReview(prNumber) {
+        const team = resolveHeroTeamSlug(this.session.targetRepo.repository);
+        if (this.opts.dryRun) {
+            logger.info('DRY RUN: would request hero review', this.logContext({
+                pr_number: prNumber,
+                team,
+            }));
+            return;
+        }
+        await withRetry(() => this.session.octokit.rest.pulls.requestReviewers({
+            owner: this.session.targetRepo.repository.owner,
+            repo: this.session.targetRepo.repository.repo,
+            pull_number: prNumber,
+            team_reviewers: [team],
+        }));
+    }
+}

package/sandbox/dist/tasks/issue-triage/fix-loop/effects.types.js

@@ -0,0 +1 @@
+export {};

package/sandbox/dist/tasks/issue-triage/fix-loop/fake-effects.js

@@ -0,0 +1,65 @@
+/**
+ * Test fake for LoopEffects. Pre-program responses by passing arrays;
+ * each call shifts one response off the queue (throws if empty). Inspect
+ * `calls` to assert what the runner actually invoked and with what input.
+ */
+export class FakeLoopEffects {
+    calls = [];
+    fixOutputs;
+    reviewResults;
+    pushResults;
+    ciStatuses;
+    cloneOut;
+    constructor(config = {}) {
+        this.fixOutputs = [...(config.fixOutputs ?? [])];
+        this.reviewResults = [...(config.reviewResults ?? [])];
+        this.pushResults = [...(config.pushResults ?? [])];
+        this.ciStatuses = [...(config.ciStatuses ?? [])];
+        this.cloneOut = config.cloneRepo;
+    }
+    take(queue, method) {
+        const value = queue.shift();
+        if (value === undefined) {
+            throw new Error(`FakeLoopEffects: no programmed response for ${method}`);
+        }
+        return value;
+    }
+    async runFix(input) {
+        this.calls.push({ method: 'runFix', input });
+        return this.take(this.fixOutputs, 'runFix');
+    }
+    async runReview(input) {
+        this.calls.push({ method: 'runReview', input });
+        return this.take(this.reviewResults, 'runReview');
+    }
+    async pushCommit(input) {
+        this.calls.push({ method: 'pushCommit', input });
+        return this.take(this.pushResults, 'pushCommit');
+    }
+    async applyLabels(input) {
+        this.calls.push({ method: 'applyLabels', input });
+    }
+    async postIssueComment(input) {
+        this.calls.push({ method: 'postIssueComment', input });
+    }
+    async cloneRepo(input) {
+        this.calls.push({ method: 'cloneRepo', input });
+        if (!this.cloneOut) {
+            throw new Error('FakeLoopEffects: no programmed response for cloneRepo');
+        }
+        return this.cloneOut;
+    }
+    async checkCIStatus(headSha) {
+        this.calls.push({ method: 'checkCIStatus', headSha });
+        return this.take(this.ciStatuses, 'checkCIStatus');
+    }
+    async promoteToReady(prNumber) {
+        this.calls.push({ method: 'promoteToReady', prNumber });
+    }
+    async requestHeroReview(prNumber) {
+        this.calls.push({ method: 'requestHeroReview', prNumber });
+    }
+    async applyAskLabel(prNumber) {
+        this.calls.push({ method: 'applyAskLabel', prNumber });
+    }
+}

package/sandbox/dist/tasks/issue-triage/fix-loop/promotion-task.js

@@ -0,0 +1,110 @@
+import { performance } from 'node:perf_hooks';
+import { logger } from '../../../core/logging.js';
+import { createGitHubClients, parseBaseContext, requiredEnv } from '../../../core/shared.js';
+import { findRepositoryTarget } from '../hero-group-map.js';
+import { DefaultLoopEffects } from './effects.js';
+import { runPromotionFlow } from './runners.js';
+/**
+ * Parses the env vars dispatched by the webhook handler's
+ * promotion-ci-gate route (apps/webhook-handler/src/tasks/promotion-ci-gate/fargate.ts).
+ * Throws a descriptive error for any missing or malformed variable so the
+ * sandbox task fails fast instead of degrading mid-run.
+ */
+export function parsePromotionTaskInput() {
+    return {
+        base: parseBaseContext(),
+        headSha: requiredEnv('HEAD_SHA'),
+        dryRun: process.env.DRY_RUN?.toLowerCase() === 'true',
+    };
+}
+/**
+ * Builds the PromotionSession. Promotion is API-only (no codex / push /
+ * review), so the session carries only the fields the promotion-flow
+ * effects actually read, and cloning the repo is skipped — none of the
+ * effects reads `localPath`.
+ */
+export function buildPromotionSession({ input, octokit, }) {
+    const { owner, repo } = input.base;
+    // Single source of truth: look up the canonical RepositoryTarget here
+    // (with real surfaces) so downstream effects like requestHeroReview can
+    // route by surface without re-scanning PRODUCT_REPOSITORIES.
+    const repository = findRepositoryTarget(owner, repo) ?? {
+        owner,
+        repo,
+        fullName: `${owner}/${repo}`,
+        // Fallback for repos not in the registry. surfaces=[] makes
+        // resolveHeroGroup fall through to cx-hero — the desired behavior
+        // for unknown targets.
+        product: 'Todoist',
+        surfaces: [],
+    };
+    return {
+        kind: 'fix-loop-promotion',
+        ctx: {
+            owner,
+            repo,
+            installationId: input.base.installationId,
+            deliveryId: input.base.deliveryId ?? 'unknown',
+            dryRun: input.dryRun,
+        },
+        octokit,
+        targetRepo: {
+            repository,
+            localPath: '',
+        },
+    };
+}
+export async function runPromotionTask(input) {
+    const startedAt = performance.now();
+    const { base, headSha, dryRun } = input;
+    const repository = `${base.owner}/${base.repo}`;
+    logger.setBaseContext({
+        delivery_id: base.deliveryId ?? 'unknown',
+        repository,
+    });
+    logger.info('Fix-loop promotion task started', {
+        task: 'fix-loop-promotion',
+        repository,
+        pr_number: base.prNumber,
+        head_sha: headSha,
+        dry_run: dryRun,
+    });
+    try {
+        const { writeOctokit } = await createGitHubClients(base);
+        const session = buildPromotionSession({ input, octokit: writeOctokit });
+        const effects = new DefaultLoopEffects(session, { dryRun });
+        const finalState = await runPromotionFlow(effects, {
+            prNumber: base.prNumber,
+            headSha,
+        });
+        logger.info('Fix-loop promotion task completed', {
+            task: 'fix-loop-promotion',
+            repository,
+            pr_number: base.prNumber,
+            terminal_state: finalState.kind,
+            duration_ms: performance.now() - startedAt,
+        });
+    }
+    catch (error) {
+        logger.error('Fix-loop promotion task failed', {
+            task: 'fix-loop-promotion',
+            repository,
+            pr_number: base.prNumber,
+            head_sha: headSha,
+            error: error instanceof Error ? error.message : String(error),
+            duration_ms: performance.now() - startedAt,
+        });
+        throw error;
+    }
+}
+export async function main() {
+    try {
+        await runPromotionTask(parsePromotionTaskInput());
+    }
+    catch {
+        process.exitCode = 1;
+    }
+}
+if (process.env.VITEST !== 'true' && process.env.TASK_TYPE === 'fix-loop-promotion') {
+    main();
+}