@todoist/doistbot-cli 0.0.0-stage → 1.0.16

package/sandbox/dist/tasks/issue-triage/fix-dispatch.js

@@ -0,0 +1,263 @@
+import { SpanStatusCode } from '@opentelemetry/api';
+import { repositoryKey } from 'doistbot-issue-routing';
+import { logger } from '../../core/logging.js';
+import { withPhase } from '../../core/tracing.js';
+import { DefaultLoopEffects } from './fix-loop/effects.js';
+import { IssueFixRecovery } from './fix-loop/recovery.js';
+import { runFixLoop } from './fix-loop/runners.js';
+import { buildFixAssessmentSkipReason, shouldAttemptFix } from './fix-attempt.js';
+import { fixSource } from './fix-context.js';
+import { FIX_LOOP_FAILED_REASON_PREFIX } from './fix-failure-reasons.js';
+function fallbackRepository(input) {
+    return (input.fixAssessment.targetRepo ??
+        (input.clonedRepos.length === 1
+            ? input.clonedRepos[0].repository.fullName
+            : `${input.ctx.owner}/${input.ctx.repo}`));
+}
+function resolveFixTarget(input) {
+    if (input.clonedRepos.length === 0) {
+        return {
+            ok: false,
+            repository: fallbackRepository(input),
+            reason: 'No cloned repositories available for fix attempt.',
+        };
+    }
+    if (input.fixAssessment.targetRepo) {
+        const targetRepo = input.clonedRepos.find((repo) => repositoryKey(repo.repository.fullName) ===
+            repositoryKey(input.fixAssessment.targetRepo));
+        if (targetRepo) {
+            return { ok: true, targetRepo };
+        }
+        return {
+            ok: false,
+            repository: fallbackRepository(input),
+            reason: `Unable to resolve a unique target repository from assessment: ${input.fixAssessment.targetRepo}`,
+        };
+    }
+    if (input.clonedRepos.length === 1) {
+        return { ok: true, targetRepo: input.clonedRepos[0] };
+    }
+    return {
+        ok: false,
+        repository: fallbackRepository(input),
+        reason: 'Unable to resolve a unique target repository from assessment: missing targetRepo',
+    };
+}
+function stateLogMeta(state) {
+    return {
+        kind: state.kind,
+        ...(state.kind !== 'AWAITING_FIRST_FIX' && 'iteration' in state
+            ? { iteration: state.iteration }
+            : {}),
+        ...('branch' in state && state.branch !== undefined ? { branch: state.branch } : {}),
+        ...('prNumber' in state && state.prNumber !== undefined
+            ? { pr_number: state.prNumber }
+            : {}),
+    };
+}
+function logDryRunTransition({ from, event, to }) {
+    logger.info('DRY RUN: fix loop state transition', {
+        task: 'fix-loop',
+        from: stateLogMeta(from),
+        event: event.kind,
+        to: stateLogMeta(to),
+    });
+}
+function errorReason(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function prUrlFor(targetRepo, prNumber) {
+    return `https://github.com/${targetRepo.repository.fullName}/pull/${prNumber}`;
+}
+export async function runConfiguredFix(input) {
+    return withPhase(input.phaseName ?? 'triage.fix-attempt', { 'gen_ai.operation.name': 'invoke_agent', 'gen_ai.agent.name': 'codex.fix' }, async (span) => {
+        function finish(result) {
+            const prCreated = 'prCreated' in result ? result.prCreated : false;
+            // Only a real PR number counts as PR-evidence — dry-run loop
+            // states can carry a placeholder prNumber of 0.
+            const prNumber = 'prNumber' in result && result.prNumber !== undefined && result.prNumber > 0
+                ? result.prNumber
+                : undefined;
+            // Dry-run skips are expected outcomes, not failures — signaled
+            // by the stable dryRun flag on the result, never by parsing
+            // the human-readable reason copy.
+            const isDryRunSkip = 'dryRun' in result && result.dryRun === true;
+            let outcome;
+            if (prCreated) {
+                outcome = 'pr-created';
+            }
+            else if (isDryRunSkip) {
+                outcome = 'dry-run';
+            }
+            else if (prNumber !== undefined) {
+                // The loop opened a PR earlier (REVIEWING/ITERATING) but
+                // ended needing a human: a PR exists, the autonomous
+                // attempt did not finish.
+                outcome = 'pr-opened-needs-human';
+            }
+            else if (result.attempted) {
+                outcome = 'attempted-no-pr';
+            }
+            else {
+                outcome = 'not-attempted';
+            }
+            span.setAttributes({
+                'fix.attempted': result.attempted,
+                'fix.repository': result.repository,
+                'fix.pr_created': prCreated,
+                ...(prNumber !== undefined ? { 'fix.pr_number': prNumber } : {}),
+                'fix.outcome': outcome,
+            });
+            // A real attempt that did not deliver a ready PR is a failure
+            // (including pr-opened-needs-human — someone must take over);
+            // a legitimate skip or a dry-run is not. withPhase does not
+            // force OK on a normal return, so this ERROR survives to
+            // phase.end.
+            if (result.attempted && !prCreated && !isDryRunSkip && 'reason' in result) {
+                span.setStatus({ code: SpanStatusCode.ERROR, message: result.reason });
+            }
+            return result;
+        }
+        const target = resolveFixTarget(input);
+        if (!target.ok) {
+            return finish({
+                attempted: false,
+                repository: target.repository,
+                reason: target.reason,
+            });
+        }
+        const targetRepo = target.targetRepo;
+        if (!input.retry && !shouldAttemptFix(input.fixAssessment)) {
+            return finish({
+                attempted: false,
+                repository: targetRepo.repository.fullName,
+                reason: buildFixAssessmentSkipReason(input.fixAssessment),
+            });
+        }
+        let recovery;
+        let initial;
+        try {
+            if (!input.ctx.dryRun) {
+                recovery = new IssueFixRecovery({
+                    issueUrl: input.issueUrl,
+                    ...fixSource(input.ctx),
+                    triageOutput: input.triageOutput,
+                    targetRepo,
+                    githubToken: input.ctx.githubToken,
+                    octokit: input.octokit,
+                    bucket: process.env.LOG_SNAPSHOT_BUCKET,
+                });
+                initial = await recovery.prepare(input.retry === true);
+            }
+        }
+        catch (error) {
+            return finish({
+                attempted: true,
+                prCreated: false,
+                repository: targetRepo.repository.fullName,
+                reason: `Could not restore saved fix: ${errorReason(error)}`,
+                recoveryRefused: true,
+                ...(recovery?.existingPR ? { prNumber: recovery.existingPR } : {}),
+            });
+        }
+        const session = {
+            kind: 'fix-loop',
+            ctx: input.ctx,
+            octokit: input.octokit,
+            triageOutput: input.triageOutput,
+            fixAssessment: input.fixAssessment,
+            targetRepo,
+            issueTitle: input.issueTitle,
+            issueUrl: input.issueUrl,
+            ghToken: input.ghToken,
+            pushToken: input.ctx.githubToken,
+            assigneeReview: input.assigneeReview,
+            manualRetry: input.retry,
+            modelPhaseName: `${input.phaseName ?? 'triage.fix-attempt'}.model`,
+            apiKeys: {
+                openai: input.ctx.openaiApiKey,
+                ...(input.ctx.geminiApiKey !== undefined && { gemini: input.ctx.geminiApiKey }),
+            },
+        };
+        const effects = new DefaultLoopEffects(session, { dryRun: input.ctx.dryRun, recovery });
+        let recoverySaved = false;
+        const saveRecovery = recovery
+            ? async (state) => {
+                await recovery.beforeStep(state);
+                if (!recoverySaved) {
+                    if (input.onRecoverySaved && !recovery.shared)
+                        throw new Error('Could not save the shared fix checkpoint');
+                    await input.onRecoverySaved?.();
+                    recoverySaved = true;
+                }
+            }
+            : undefined;
+        let finalState;
+        try {
+            finalState = await runFixLoop({
+                effects,
+                initial,
+                beforeStep: saveRecovery,
+                beforeFinish: saveRecovery
+                    ? (state) => effects.interruption ? Promise.resolve() : saveRecovery(state)
+                    : undefined,
+                ...(input.ctx.dryRun ? { onTransition: logDryRunTransition } : {}),
+            });
+        }
+        catch (error) {
+            return finish({
+                attempted: true,
+                repository: targetRepo.repository.fullName,
+                prCreated: false,
+                reason: `${FIX_LOOP_FAILED_REASON_PREFIX} ${errorReason(error)}`,
+                ...(recovery && 'prNumber' in recovery.state
+                    ? { prNumber: recovery.state.prNumber }
+                    : {}),
+                ...(recovery
+                    ? {
+                        interruption: {
+                            stage: recovery.state.kind === 'REVIEWING' ? 'review' : 'fix',
+                            saved: recovery.shared,
+                        },
+                    }
+                    : {}),
+            });
+        }
+        if (finalState.kind === 'PUSHED_AWAITING_CI') {
+            if (input.ctx.dryRun) {
+                return finish({
+                    attempted: true,
+                    repository: targetRepo.repository.fullName,
+                    prCreated: false,
+                    reason: 'Dry run: PR not created.',
+                    dryRun: true,
+                });
+            }
+            const prNumber = finalState.prNumber;
+            const prUrl = prUrlFor(targetRepo, prNumber);
+            return finish({
+                attempted: true,
+                repository: targetRepo.repository.fullName,
+                prCreated: true,
+                prUrl,
+                prNumber,
+            });
+        }
+        const reason = finalState.kind === 'DONE_NEEDS_HUMAN'
+            ? finalState.reason
+            : `Fix loop ended in ${finalState.kind}`;
+        return finish({
+            attempted: true,
+            repository: targetRepo.repository.fullName,
+            prCreated: false,
+            reason,
+            ...(effects.interruption ? { interruption: effects.interruption } : {}),
+            // If a PR was opened earlier in the loop (REVIEWING/ITERATING reached
+            // before DONE_NEEDS_HUMAN), surface it so callers can distinguish a
+            // silent failure from an in-progress PR.
+            ...('prNumber' in finalState && finalState.prNumber !== undefined
+                ? { prNumber: finalState.prNumber }
+                : {}),
+        });
+    });
+}

package/sandbox/dist/tasks/issue-triage/fix-failure-reasons.js

@@ -0,0 +1,2 @@
+export const CODEX_CANNOT_FIX_REASON = 'Codex determined fix cannot be applied automatically.';
+export const FIX_LOOP_FAILED_REASON_PREFIX = 'Fix loop failed:';