@doist/doistbot-cli 1.0.1 → 1.0.3

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

@@ -2,8 +2,9 @@ import { execFileSync } from 'child_process';
 import { logger } from '../../core/logging.js';
 import { fillPromptTemplate, loadPromptTemplateFile } from '../../core/prompt-template.js';
 import { validateDiff } from './diff-validator.js';
+import { CODEX_CANNOT_FIX_REASON, FIX_LOOP_FAILED_REASON_PREFIX } from './fix-failure-reasons.js';
 import { CX_HERO_MANUAL_HANDLE, resolveHeroGroup } from './hero-group-map.js';
-import { HERO_AUTOFIX_MARKER } from './markers.js';
+import { AUTOFIX_FAILURE_MARKER, FIX_LOOP_START_MARKER, HERO_AUTOFIX_MARKER } from './markers.js';
 import { invokeTriageModel } from './model.js';
 import { commitAndPushFix, findPRTemplate, openDraftFixPR } from './pr-creator.js';
 const FIX_PROMPT_FILE = 'issue-triage-fix-prompt.md';
@@ -18,6 +19,9 @@ export function shouldAttemptFix(assessment) {
     }
     return assessment.confidence === 'high' || assessment.confidence === 'medium';
 }
+export function buildFixAssessmentSkipReason(assessment) {
+    return `Assessment: ${assessment.classification} (confidence: ${assessment.confidence})`;
+}
 function loadFixPromptTemplate() {
     return loadPromptTemplateFile({
         fileName: FIX_PROMPT_FILE,
@@ -80,7 +84,7 @@ export function parsePRBodyFromOutput(output) {
 function buildFixPrompt({ ctx, triageOutput, fixAssessment, issueTitle, issueUrl, targetRepo, prTemplate, }) {
     const template = loadFixPromptTemplate();
     return fillPromptTemplate(template, {
-        REPO_FULL: targetRepo.fullName,
+        REPO_FULL: targetRepo.repository.fullName,
         ISSUE_NUMBER: String(ctx.issueNumber),
         ISSUE_TITLE: issueTitle,
         ISSUE_URL: issueUrl,
@@ -160,6 +164,110 @@ export function buildFollowUpCommentBody({ prUrl, targetRepoFullName, fixAssessm
         `The PR targets \`${targetRepoFullName}\`. Please review it carefully before merging.`,
     ].join('\n');
 }
+function isNonRetryableFailure(reason) {
+    return reason.includes(CODEX_CANNOT_FIX_REASON);
+}
+async function findSourceIssueCommentByMarker({ octokit, ctx, marker, }) {
+    const comments = await octokit.paginate(octokit.rest.issues.listComments, {
+        owner: ctx.owner,
+        repo: ctx.repo,
+        issue_number: ctx.issueNumber,
+        per_page: 100,
+    });
+    return comments.find((c) => typeof c.body === 'string' && c.body.includes(marker));
+}
+export async function shouldPostAutoFixFailureComment(fixResult, { dryRun, octokit, ctx }) {
+    if (dryRun)
+        return false;
+    if (!fixResult.attempted)
+        return false;
+    if (fixResult.prCreated)
+        return false;
+    // A PR opened during the loop is already announced via FIX_LOOP_START_MARKER;
+    // a "didn't produce a fix PR" comment would be misleading.
+    if (fixResult.prNumber !== undefined)
+        return false;
+    if (isNonRetryableFailure(fixResult.reason))
+        return false;
+    if (fixResult.reason.startsWith(FIX_LOOP_FAILED_REASON_PREFIX)) {
+        try {
+            const hasFixLoopStartComment = await sourceIssueHasFixLoopStartComment({ octokit, ctx });
+            if (hasFixLoopStartComment) {
+                logger.info('Auto-fix failure comment skipped', {
+                    task: 'issue-triage',
+                    issue_number: ctx.issueNumber,
+                    reason: 'fix-loop start comment exists',
+                });
+                return false;
+            }
+        }
+        catch (error) {
+            logger.warn('Failed to check fix-loop start comment', {
+                task: 'issue-triage',
+                issue_number: ctx.issueNumber,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return false;
+        }
+    }
+    return true;
+}
+export async function sourceIssueHasFixLoopStartComment({ octokit, ctx, }) {
+    const comment = await findSourceIssueCommentByMarker({
+        octokit,
+        ctx,
+        marker: FIX_LOOP_START_MARKER,
+    });
+    return comment !== undefined;
+}
+export function buildAutoFixFailureCommentBody({ reason, targetRepoFullName, }) {
+    const repoNote = targetRepoFullName ? ` in \`${targetRepoFullName}\`` : '';
+    return [
+        AUTOFIX_FAILURE_MARKER,
+        '',
+        '### Automated fix attempt failed',
+        '',
+        `I attempted an automated fix but couldn't open a fix PR${repoNote}.`,
+        '',
+        '**Reason:**',
+        '',
+        '```',
+        reason,
+        '```',
+        '',
+        'You can retry by commenting `@doistbot /fix`.',
+    ].join('\n');
+}
+export async function postAutoFixFailureComment({ octokit, ctx, reason, targetRepoFullName, }) {
+    const body = buildAutoFixFailureCommentBody({ reason, targetRepoFullName });
+    const existing = await findSourceIssueCommentByMarker({
+        octokit,
+        ctx,
+        marker: AUTOFIX_FAILURE_MARKER,
+    });
+    if (existing) {
+        await octokit.rest.issues.updateComment({
+            owner: ctx.owner,
+            repo: ctx.repo,
+            comment_id: existing.id,
+            body,
+        });
+    }
+    else {
+        await octokit.rest.issues.createComment({
+            owner: ctx.owner,
+            repo: ctx.repo,
+            issue_number: ctx.issueNumber,
+            body,
+        });
+    }
+    logger.info('Auto-fix failure comment posted', {
+        task: 'issue-triage',
+        issue_number: ctx.issueNumber,
+        target_repo: targetRepoFullName,
+        operation: existing ? 'update' : 'create',
+    });
+}
 async function postFollowUpComment({ octokit, ctx, prUrl, prNumber, targetRepo, fixAssessment, }) {
     const heroGroup = resolveHeroGroup([], targetRepo);
     if (!heroGroup) {
@@ -193,6 +301,18 @@ async function postFollowUpComment({ octokit, ctx, prUrl, prNumber, targetRepo,
 }
 export async function runFixCore(input) {
     const { ctx, triageOutput, fixAssessment, targetRepo, resetTo = 'HEAD' } = input;
+    if (!input.force && !shouldAttemptFix(fixAssessment)) {
+        logger.info('Fix core skipped: assessment does not qualify', {
+            task: 'issue-triage',
+            issue_number: ctx.issueNumber,
+            classification: fixAssessment.classification,
+            confidence: fixAssessment.confidence,
+        });
+        return {
+            ok: false,
+            reason: buildFixAssessmentSkipReason(fixAssessment),
+        };
+    }
     // Reset repo to clean state before fix attempt (triage Codex may have modified files).
     // Use `git reset --hard` to clear both the working tree and the index, since
     // captureGitDiff stages files with `git add -A`.
@@ -213,7 +333,7 @@ export async function runFixCore(input) {
         logger.warn('Failed to reset repo state before fix attempt', {
             task: 'issue-triage',
             issueNumber: ctx.issueNumber,
-            targetRepo: targetRepo.fullName,
+            targetRepo: targetRepo.repository.fullName,
             error: reason,
         });
         return {
@@ -226,7 +346,7 @@ export async function runFixCore(input) {
         logger.info('PR template found for fix attempt', {
             task: 'issue-triage',
             issueNumber: ctx.issueNumber,
-            targetRepo: targetRepo.fullName,
+            targetRepo: targetRepo.repository.fullName,
             templateChars: prTemplate.length,
         });
     }
@@ -277,7 +397,7 @@ export async function runFixCore(input) {
             issueNumber: ctx.issueNumber,
             output: fixDescription.slice(0, 500),
         });
-        return { ok: false, reason: 'Codex determined fix cannot be applied automatically.' };
+        return { ok: false, reason: CODEX_CANNOT_FIX_REASON };
     }
     // Capture the diff
     const diff = captureGitDiff(targetRepo.localPath);
@@ -328,7 +448,9 @@ export async function attemptFix(input) {
     const { ctx, octokit, triageOutput, fixAssessment, clonedRepos, force } = input;
     const startedAt = Date.now();
     const fallbackRepository = fixAssessment.targetRepo ??
-        (clonedRepos.length === 1 ? clonedRepos[0].fullName : `${ctx.owner}/${ctx.repo}`);
+        (clonedRepos.length === 1
+            ? clonedRepos[0].repository.fullName
+            : `${ctx.owner}/${ctx.repo}`);
     if (!force && !shouldAttemptFix(fixAssessment)) {
         logger.info('Fix attempt skipped — assessment does not qualify', {
             task: 'issue-triage',
@@ -339,7 +461,7 @@ export async function attemptFix(input) {
         return {
             attempted: false,
             repository: fallbackRepository,
-            reason: `Assessment: ${fixAssessment.classification} (confidence: ${fixAssessment.confidence})`,
+            reason: buildFixAssessmentSkipReason(fixAssessment),
         };
     }
     if (clonedRepos.length === 0) {
@@ -350,7 +472,7 @@ export async function attemptFix(input) {
         };
     }
     const matched = fixAssessment.targetRepo
-        ? clonedRepos.find((r) => r.fullName === fixAssessment.targetRepo)
+        ? clonedRepos.find((r) => r.repository.fullName === fixAssessment.targetRepo)
         : clonedRepos.length === 1
             ? clonedRepos[0]
             : undefined;
@@ -365,7 +487,7 @@ export async function attemptFix(input) {
     logger.info('Fix attempt starting', {
         task: 'issue-triage',
         issueNumber: ctx.issueNumber,
-        targetRepo: targetRepo.fullName,
+        targetRepo: targetRepo.repository.fullName,
         trigger: ctx.triggerType,
     });
     const coreResult = await runFixCore({
@@ -376,11 +498,12 @@ export async function attemptFix(input) {
         issueTitle: input.issueTitle,
         issueUrl: input.issueUrl,
         ghToken: input.ghToken,
+        force,
     });
     if (!coreResult.ok) {
         return {
             attempted: true,
-            repository: targetRepo.fullName,
+            repository: targetRepo.repository.fullName,
             prCreated: false,
             reason: coreResult.reason,
         };
@@ -389,29 +512,30 @@ export async function attemptFix(input) {
         logger.info('Fix attempt dry run — would create PR', {
             task: 'issue-triage',
             issueNumber: ctx.issueNumber,
-            targetRepo: targetRepo.fullName,
+            targetRepo: targetRepo.repository.fullName,
             diffLines: coreResult.diff.split('\n').length,
         });
         return {
             attempted: true,
-            repository: targetRepo.fullName,
+            repository: targetRepo.repository.fullName,
             prCreated: false,
             reason: 'Dry run — PR not created.',
         };
     }
+    let openedPr;
     try {
         const { branch } = await commitAndPushFix({
-            repoOwner: targetRepo.owner,
-            repoName: targetRepo.repo,
+            repoOwner: targetRepo.repository.owner,
+            repoName: targetRepo.repository.repo,
             repoLocalPath: targetRepo.localPath,
             githubToken: ctx.githubToken,
             issueNumber: ctx.issueNumber,
             issueTitle: input.issueTitle,
             prTitle: coreResult.generatedPRTitle ?? undefined,
         });
-        const prResult = await openDraftFixPR({
-            repoOwner: targetRepo.owner,
-            repoName: targetRepo.repo,
+        openedPr = await openDraftFixPR({
+            repoOwner: targetRepo.repository.owner,
+            repoName: targetRepo.repository.repo,
             octokit,
             issueNumber: ctx.issueNumber,
             issueTitle: input.issueTitle,
@@ -427,38 +551,43 @@ export async function attemptFix(input) {
         await postFollowUpComment({
             octokit,
             ctx,
-            prUrl: prResult.prUrl,
-            prNumber: prResult.prNumber,
+            prUrl: openedPr.prUrl,
+            prNumber: openedPr.prNumber,
             targetRepo: targetRepo.repository,
             fixAssessment,
         });
         logger.info('Fix attempt completed successfully', {
             task: 'issue-triage',
             issueNumber: ctx.issueNumber,
-            prUrl: prResult.prUrl,
-            prNumber: prResult.prNumber,
+            prUrl: openedPr.prUrl,
+            prNumber: openedPr.prNumber,
             durationMs: Date.now() - startedAt,
         });
         return {
             attempted: true,
-            repository: targetRepo.fullName,
+            repository: targetRepo.repository.fullName,
             prCreated: true,
-            prUrl: prResult.prUrl,
-            prNumber: prResult.prNumber,
+            prUrl: openedPr.prUrl,
+            prNumber: openedPr.prNumber,
         };
     }
     catch (error) {
-        logger.error('Fix PR creation failed', {
+        const reason = error instanceof Error ? error.message : String(error);
+        logger.error(openedPr ? 'Fix PR follow-up failed' : 'Fix PR creation failed', {
             task: 'issue-triage',
             issueNumber: ctx.issueNumber,
-            error: error instanceof Error ? error.message : String(error),
+            error: reason,
+            ...(openedPr ? { pr_number: openedPr.prNumber, pr_url: openedPr.prUrl } : {}),
             durationMs: Date.now() - startedAt,
         });
         return {
             attempted: true,
-            repository: targetRepo.fullName,
+            repository: targetRepo.repository.fullName,
             prCreated: false,
-            reason: `PR creation failed: ${error instanceof Error ? error.message : String(error)}`,
+            reason: openedPr
+                ? `PR follow-up failed after opening PR: ${reason}`
+                : `PR creation failed: ${reason}`,
+            ...(openedPr ? { prNumber: openedPr.prNumber } : {}),
         };
     }
 }

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

@@ -0,0 +1,190 @@
+import { logger } from '../../core/logging.js';
+import { DefaultLoopEffects } from './fix-loop/effects.js';
+import { runFixLoop } from './fix-loop/runners.js';
+import { attemptFix, buildFixAssessmentSkipReason, shouldAttemptFix } from './fix-attempt.js';
+import { FIX_LOOP_FAILED_REASON_PREFIX } from './fix-failure-reasons.js';
+import { getAutoFixMode } from './repo-config.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) {
+    // TODO: Refactor attemptFix to accept a resolved target repo so dispatch and
+    // the legacy engine do not duplicate target-resolution logic.
+    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) => repo.repository.fullName === 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 toAttemptFixInput(input) {
+    return {
+        ctx: input.ctx,
+        octokit: input.octokit,
+        triageOutput: input.triageOutput,
+        fixAssessment: input.fixAssessment,
+        clonedRepos: input.clonedRepos,
+        issueTitle: input.issueTitle,
+        issueUrl: input.issueUrl,
+        ghToken: input.ghToken,
+    };
+}
+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) {
+    const target = resolveFixTarget(input);
+    if (!target.ok) {
+        return { attempted: false, repository: target.repository, reason: target.reason };
+    }
+    const targetRepo = target.targetRepo;
+    let repoConfig;
+    try {
+        repoConfig = await input.loadRepoConfig(targetRepo.repository);
+    }
+    catch (error) {
+        logger.warn('Fix loop config load failed', {
+            task: 'fix-loop',
+            repository: targetRepo.repository.fullName,
+            error: errorReason(error),
+        });
+        return {
+            attempted: true,
+            repository: targetRepo.repository.fullName,
+            prCreated: false,
+            reason: `Fix loop config load failed: ${errorReason(error)}`,
+        };
+    }
+    const autoFixMode = getAutoFixMode(repoConfig, input.ctx.enableAutoFixOverride);
+    if (autoFixMode === 'disabled') {
+        return {
+            attempted: false,
+            repository: targetRepo.repository.fullName,
+            reason: 'Auto fix disabled by repository config.',
+        };
+    }
+    if (autoFixMode === 'one-pass') {
+        return attemptFix(toAttemptFixInput(input));
+    }
+    if (!shouldAttemptFix(input.fixAssessment)) {
+        return {
+            attempted: false,
+            repository: targetRepo.repository.fullName,
+            reason: buildFixAssessmentSkipReason(input.fixAssessment),
+        };
+    }
+    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,
+        apiKeys: {
+            openai: input.ctx.openaiApiKey,
+            ...(input.ctx.geminiApiKey !== undefined && { gemini: input.ctx.geminiApiKey }),
+            ...(input.ctx.anthropicApiKey !== undefined && {
+                anthropic: input.ctx.anthropicApiKey,
+            }),
+        },
+    };
+    let finalState;
+    try {
+        finalState = await runFixLoop({
+            effects: new DefaultLoopEffects(session, { dryRun: input.ctx.dryRun }),
+            ...(input.ctx.dryRun ? { onTransition: logDryRunTransition } : {}),
+        });
+    }
+    catch (error) {
+        return {
+            attempted: true,
+            repository: targetRepo.repository.fullName,
+            prCreated: false,
+            reason: `${FIX_LOOP_FAILED_REASON_PREFIX} ${errorReason(error)}`,
+        };
+    }
+    if (finalState.kind === 'PUSHED_AWAITING_CI') {
+        if (input.ctx.dryRun) {
+            return {
+                attempted: true,
+                repository: targetRepo.repository.fullName,
+                prCreated: false,
+                reason: 'Dry run: PR not created.',
+            };
+        }
+        const prNumber = finalState.prNumber;
+        const prUrl = prUrlFor(targetRepo, prNumber);
+        return {
+            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 {
+        attempted: true,
+        repository: targetRepo.repository.fullName,
+        prCreated: false,
+        reason,
+        // 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:';