@doist/doistbot-cli 1.0.1 → 1.0.3

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

@@ -8,7 +8,8 @@ import { removeIssueCommentReactionIfPresent } from '../../core/reactions.js';
 import { resolveIssueRepositories } from '../../core/repository-resolver.js';
 import { REPOS_SUBDIR, WORKSPACE_DIR } from '../../core/shared.js';
 import { parseIssueTriageContext } from './context.js';
-import { attemptFix } from './fix-attempt.js';
+import { postAutoFixFailureComment, shouldPostAutoFixFailureComment } from './fix-attempt.js';
+import { runConfiguredFix } from './fix-dispatch.js';
 import { invokeTriageModel } from './model.js';
 import { buildTriageFailureMessage, buildUnresolvedLabelsOutput, ensureStructuredTriageOutput, parseFixAssessment, REQUIRED_HEADINGS, } from './output.js';
 import { fillTemplate, loadPromptTemplate } from './prompt.js';
@@ -394,7 +395,7 @@ async function runIssueTriagePipeline(ctx, mode) {
             triageDurationMs = performance.now() - startedAt;
             return;
         }
-        const triageComment = `${TRIAGE_MARKER}\n\n${normalized.output}`;
+        const triageComment = `${TRIAGE_MARKER}\n\n${normalized.commentOutput}`;
         await postFinalTriageComment(triageComment);
         logger.info('Issue triage task completed successfully', {
             task: 'issue-triage',
@@ -436,21 +437,16 @@ async function runIssueTriagePipeline(ctx, mode) {
                 startedAt: performance.now(),
                 outcome: 'failure',
             };
-            const fixResult = await attemptFix({
+            const fixResult = await runConfiguredFix({
                 ctx,
                 octokit: writeOctokit,
                 triageOutput: normalized.output,
                 fixAssessment,
-                clonedRepos: clonedRepositories.map(({ repository, localPath }) => ({
-                    owner: repository.owner,
-                    repo: repository.repo,
-                    fullName: repository.fullName,
-                    localPath,
-                    repository,
-                })),
+                clonedRepos: clonedRepositories,
                 issueTitle: issue.title ?? 'Untitled issue',
                 issueUrl: issue.html_url ?? getIssueUrl(ctx.owner, ctx.repo, ctx.issueNumber),
                 ghToken: issueInstallationAuth.token,
+                loadRepoConfig: getCachedRepoConfig,
             });
             logger.info('triage.fix_attempted', {
                 task: 'issue-triage',
@@ -465,6 +461,7 @@ async function runIssueTriagePipeline(ctx, mode) {
                 prCreated: fixResult.attempted && fixResult.prCreated,
                 reason: 'reason' in fixResult ? fixResult.reason : undefined,
                 prUrl: 'prUrl' in fixResult ? fixResult.prUrl : undefined,
+                pr_number: 'prNumber' in fixResult ? fixResult.prNumber : undefined,
                 durationMs: performance.now() - startedAt,
             });
             pendingFixMetric = {
@@ -472,6 +469,30 @@ async function runIssueTriagePipeline(ctx, mode) {
                 startedAt: pendingFixMetric.startedAt,
                 outcome: fixResult.attempted && fixResult.prCreated ? 'success' : 'failure',
             };
+            const shouldPostFailureComment = await shouldPostAutoFixFailureComment(fixResult, {
+                dryRun: ctx.dryRun,
+                octokit: writeOctokit,
+                ctx,
+            });
+            if (shouldPostFailureComment) {
+                try {
+                    await postAutoFixFailureComment({
+                        octokit: writeOctokit,
+                        ctx,
+                        reason: 'reason' in fixResult ? fixResult.reason : 'Unknown reason',
+                        targetRepoFullName: fixResult.repository,
+                    });
+                }
+                catch (commentError) {
+                    logger.warn('Failed to post auto-fix failure comment', {
+                        task: 'issue-triage',
+                        issue_number: ctx.issueNumber,
+                        error: commentError instanceof Error
+                            ? commentError.message
+                            : String(commentError),
+                    });
+                }
+            }
         }
         else {
             logger.info('triage.fix_attempted', {

package/sandbox/dist/tasks/issue-triage/types.js

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

package/sandbox/dist/tasks/review/author-format.js

@@ -0,0 +1,14 @@
+export const REVIEW_AUTHOR_EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+export function normalizePrAuthor(prAuthor) {
+    return (prAuthor ?? '').trim().replace(/^@+/, '');
+}
+export function formatPrAuthorForGreeting(prAuthor) {
+    const normalizedAuthor = normalizePrAuthor(prAuthor);
+    if (!normalizedAuthor || normalizedAuthor.toLowerCase() === 'unknown') {
+        return null;
+    }
+    if (REVIEW_AUTHOR_EMAIL_PATTERN.test(normalizedAuthor)) {
+        return null;
+    }
+    return normalizedAuthor;
+}

package/sandbox/dist/tasks/review/author-profile.js

@@ -0,0 +1,67 @@
+import { isKnownAutomationLogin } from '../../core/bot-logins.js';
+import { logger } from '../../core/logging.js';
+import { formatPrAuthorForGreeting, REVIEW_AUTHOR_EMAIL_PATTERN } from './author-format.js';
+const URL_PATTERN = /^https?:\/\//i;
+const UNSAFE_GREETING_CHARS = new Set([
+    '@',
+    '<',
+    '>',
+    '{',
+    '}',
+    '[',
+    ']',
+    '(',
+    ')',
+    '`',
+    '*',
+    '_',
+    '#',
+    '|',
+    '\\',
+]);
+const MAX_GREETING_NAME_CHARS = 40;
+function hasUnsafeGreetingChar(value) {
+    return Array.from(value).some((char) => UNSAFE_GREETING_CHARS.has(char));
+}
+export function shouldExcludePrAuthorFromReviewSummary(login) {
+    const normalizedLogin = login?.trim().toLowerCase();
+    return isKnownAutomationLogin(normalizedLogin);
+}
+export function extractFirstNameFromProfileName(profileName) {
+    const normalized = profileName?.replace(/\s+/g, ' ').trim() ?? '';
+    if (!normalized) {
+        return null;
+    }
+    const firstToken = normalized.split(' ')[0]?.replace(/[.,;:!]+$/g, '') ?? '';
+    if (!firstToken ||
+        firstToken.length > MAX_GREETING_NAME_CHARS ||
+        REVIEW_AUTHOR_EMAIL_PATTERN.test(firstToken) ||
+        URL_PATTERN.test(firstToken) ||
+        hasUnsafeGreetingChar(firstToken) ||
+        !/\p{L}/u.test(firstToken)) {
+        return null;
+    }
+    return firstToken;
+}
+export async function resolvePrAuthorGreetingName({ octokit, login, }) {
+    const normalizedLogin = formatPrAuthorForGreeting(login);
+    if (!normalizedLogin || shouldExcludePrAuthorFromReviewSummary(normalizedLogin)) {
+        return undefined;
+    }
+    try {
+        const response = await octokit.rest.users.getByUsername({ username: normalizedLogin });
+        const greetingName = extractFirstNameFromProfileName(response.data.name);
+        if (!greetingName) {
+            logger.info('PR author GitHub profile name unavailable for greeting', {
+                profile_name_available: Boolean(response.data.name?.trim()),
+            });
+        }
+        return greetingName ?? undefined;
+    }
+    catch (error) {
+        logger.warn('Failed to resolve PR author GitHub profile name', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return undefined;
+    }
+}

package/sandbox/dist/tasks/review/check-run.js

@@ -42,7 +42,14 @@ const SEVERITY_TO_COUNTER_KEY = {
  * a recognizable tag are bucketed as `untagged`.
  */
 export function countFindingsBySeverity(review) {
-    const counts = { p0: 0, p1: 0, p2: 0, p3: 0, untagged: 0, total: 0 };
+    const counts = {
+        p0: 0,
+        p1: 0,
+        p2: 0,
+        p3: 0,
+        untagged: 0,
+        total: 0,
+    };
     function increment(sev) {
         if (sev)
             counts[SEVERITY_TO_COUNTER_KEY[sev]] += 1;

package/sandbox/dist/tasks/review/comment-mapper.js

@@ -2,25 +2,30 @@ import { logger } from '../../core/logging.js';
 /**
  * Converts model findings to review comments, filtering out invalid diff locations.
  */
+function getInvalidFindingLocationReason(finding, lineLookup) {
+    const fileLines = lineLookup.get(finding.path);
+    if (!fileLines) {
+        return 'file not in diff';
+    }
+    const validLines = finding.side === 'LEFT' ? fileLines.old : fileLines.new;
+    if (!validLines.has(finding.line)) {
+        return 'line not in diff';
+    }
+    return null;
+}
+export function canMapFindingToComment(finding, lineLookup) {
+    return getInvalidFindingLocationReason(finding, lineLookup) == null;
+}
 export function convertFindingsToComments(findings, lineLookup) {
     const comments = [];
     const skipped = [];
     for (const finding of findings) {
-        const fileLines = lineLookup.get(finding.path);
-        if (!fileLines) {
-            skipped.push({
-                path: finding.path,
-                line: finding.line,
-                reason: 'file not in diff',
-            });
-            continue;
-        }
-        const validLines = finding.side === 'LEFT' ? fileLines.old : fileLines.new;
-        if (!validLines.has(finding.line)) {
+        const invalidReason = getInvalidFindingLocationReason(finding, lineLookup);
+        if (invalidReason) {
             skipped.push({
                 path: finding.path,
                 line: finding.line,
-                reason: 'line not in diff',
+                reason: invalidReason,
             });
             continue;
         }

package/sandbox/dist/tasks/review/conversation-context.js

@@ -11,6 +11,7 @@ const CONVERSATION_SUMMARY_TIMEOUT_MS = 5 * 60 * 1000;
 const CONVERSATION_SUMMARY_TARGET_CHARS = 4_000;
 const REVIEW_COMMAND_REGEX = /^@doistbot \/review$/i;
 const GITHUB_ACTIONS_BOT_LOGIN = 'github-actions[bot]';
+const MASKED_PR_AUTHOR_LABEL = 'PR author';
 function getSummaryProviders(apiKeys) {
     return [
         ...(apiKeys?.gemini ? [{ provider: 'gemini', apiKey: apiKeys.gemini }] : []),
@@ -31,6 +32,11 @@ function shouldIncludeEntry(login, body) {
     const normalized = login.toLowerCase();
     return !normalized.endsWith('[bot]') || isRelevantBotLogin(normalized);
 }
+function shouldMaskPrAuthor(login, prAuthor) {
+    const normalizedLogin = login.trim().toLowerCase();
+    const normalizedPrAuthor = prAuthor?.trim().toLowerCase();
+    return Boolean(normalizedLogin && normalizedPrAuthor && normalizedLogin === normalizedPrAuthor);
+}
 function cleanBody(body) {
     return stripReviewFeedbackFooter(body);
 }
@@ -77,33 +83,86 @@ function toInlineCommentEntry(comment) {
         path: comment.path ?? undefined,
         line: comment.line ?? comment.original_line ?? undefined,
         side: comment.side ?? undefined,
+        id: comment.id ?? undefined,
         replyToId: comment.in_reply_to_id ?? undefined,
         body,
     };
 }
-function byCreatedAtAscending(a, b) {
-    if (a.createdAt === b.createdAt) {
+function compareCreatedAt(a, b) {
+    if (a === b) {
         return 0;
     }
-    if (a.createdAt === 'unknown') {
+    if (a === 'unknown') {
         return 1;
     }
-    if (b.createdAt === 'unknown') {
+    if (b === 'unknown') {
         return -1;
     }
-    return a.createdAt.localeCompare(b.createdAt);
+    return a.localeCompare(b);
 }
-function formatEntry(entry, index) {
+// Groups inline comments into threads (a root finding plus its replies) using
+// in_reply_to_id. Replies whose root is missing fall back to standalone entries.
+function buildInlineThreads(entries, prAuthorThumbsDownRootIds) {
+    const roots = entries.filter((entry) => entry.replyToId == null);
+    const rootById = new Map();
+    for (const root of roots) {
+        if (root.id != null) {
+            rootById.set(root.id, {
+                root,
+                replies: [],
+                prAuthorReactedThumbsDown: prAuthorThumbsDownRootIds.has(root.id),
+            });
+        }
+    }
+    const orphans = [];
+    for (const entry of entries) {
+        if (entry.replyToId == null) {
+            continue;
+        }
+        const thread = rootById.get(entry.replyToId);
+        if (thread) {
+            thread.replies.push(entry);
+        }
+        else {
+            orphans.push(entry);
+        }
+    }
+    const threads = roots.flatMap((root) => {
+        const thread = root.id == null ? undefined : rootById.get(root.id);
+        if (!thread) {
+            // Root without a usable id can't anchor replies; render it standalone.
+            orphans.push(root);
+            return [];
+        }
+        thread.replies.sort((a, b) => compareCreatedAt(a.createdAt, b.createdAt));
+        return [thread];
+    });
+    return { threads, orphans };
+}
+function describeAuthor(author, prAuthor) {
+    const normalized = author.toLowerCase();
+    if (isKnownDoistbotLogin(normalized)) {
+        return `${author} (doistbot)`;
+    }
+    if (shouldMaskPrAuthor(author, prAuthor)) {
+        return MASKED_PR_AUTHOR_LABEL;
+    }
+    return author;
+}
+function formatLocation(entry) {
+    const line = entry.line == null ? 'unknown' : String(entry.line);
+    const side = entry.side ? ` ${entry.side}` : '';
+    return `${entry.path}:${line}${side}`;
+}
+function formatEntry(entry, index, prAuthor) {
     const lines = [`### Entry ${index + 1}: ${entry.source.replace('_', ' ')}`];
-    lines.push(`- Author: ${entry.author}`);
+    lines.push(`- Author: ${describeAuthor(entry.author, prAuthor)}`);
     lines.push(`- Created: ${entry.createdAt}`);
     if (entry.state) {
         lines.push(`- Review state: ${entry.state}`);
     }
     if (entry.path) {
-        const line = entry.line == null ? 'unknown' : String(entry.line);
-        const side = entry.side ? ` ${entry.side}` : '';
-        lines.push(`- Location: ${entry.path}:${line}${side}`);
+        lines.push(`- Location: ${formatLocation(entry)}`);
     }
     if (entry.replyToId != null) {
         lines.push(`- Reply to inline comment ID: ${entry.replyToId}`);
@@ -115,6 +174,30 @@ function formatEntry(entry, index) {
     lines.push(entry.body);
     return lines.join('\n');
 }
+function formatThreadMessage(entry, prAuthor) {
+    return [`${describeAuthor(entry.author, prAuthor)} — ${entry.createdAt}:`, entry.body].join('\n');
+}
+function formatThread(thread, index, prAuthor) {
+    const { root, replies } = thread;
+    const location = root.path ? formatLocation(root) : 'unknown location';
+    const lines = [`### Entry ${index + 1}: prior inline thread on ${location}`];
+    const rootIsDoistbot = isKnownDoistbotLogin(root.author.toLowerCase());
+    const prAuthorReplied = prAuthor != null && replies.some((reply) => shouldMaskPrAuthor(reply.author, prAuthor));
+    if (rootIsDoistbot && thread.prAuthorReactedThumbsDown) {
+        lines.push('- Status: the PR author reacted 👎 to this prior doistbot finding. Treat this as author pushback / declined unless later discussion says otherwise.');
+    }
+    if (rootIsDoistbot && prAuthorReplied) {
+        lines.push('- Status: the PR author replied to this prior doistbot finding. Read their response to decide whether they accepted it or pushed back / declined it.');
+    }
+    if (root.url) {
+        lines.push(`- URL: ${root.url}`);
+    }
+    for (const message of [root, ...replies]) {
+        lines.push('');
+        lines.push(formatThreadMessage(message, prAuthor));
+    }
+    return lines.join('\n');
+}
 function buildStats(baseStats, { summarized = false, summarizationFailed = false, } = {}) {
     return {
         ...baseStats,
@@ -138,6 +221,7 @@ Rules:
 - Preserve line-specific context with file paths and line numbers when available.
 - Distinguish resolved prior review feedback from unresolved or still-relevant feedback when the conversation makes that clear.
 - Capture author intent, decisions, open questions, and previous findings that may affect a re-review.
+- Explicitly preserve any prior finding the PR author pushed back on or declined (replied disagreeing, reacted 👎, called it intentional/by-design, deferred it as out-of-scope, or said won't-fix). Record the file path, the gist of the finding, and that the author declined it, so a re-review knows not to raise it again.
 - Do not invent status or resolution when it is not stated.
 - Keep the summary under ${CONVERSATION_SUMMARY_TARGET_CHARS} characters.
 - Return markdown only; do not wrap the answer in code fences.
@@ -157,6 +241,9 @@ Coverage: <one sentence with the kinds of comments summarized>
 ### Previous review rounds
 - ...
 
+### Findings the author declined / pushed back on (do not re-raise)
+- ...
+
 ### Open questions / unresolved discussion
 - ...
 
@@ -217,10 +304,74 @@ async function summarizeConversationContextWithModel({ provider, apiKey, rawCont
         return null;
     }
 }
-function formatConversationEntries(entries) {
-    return entries.map((entry, index) => formatEntry(entry, index)).join('\n\n---\n\n');
+function buildConversationItems(standalone, inlineEntries, prAuthorThumbsDownRootIds) {
+    const { threads, orphans } = buildInlineThreads(inlineEntries, prAuthorThumbsDownRootIds);
+    const items = [
+        ...[...standalone, ...orphans].map((entry) => ({
+            kind: 'entry',
+            entry,
+            sortKey: entry.createdAt,
+        })),
+        ...threads.map((thread) => ({
+            kind: 'thread',
+            thread,
+            sortKey: thread.root.createdAt,
+        })),
+    ];
+    items.sort((a, b) => compareCreatedAt(a.sortKey, b.sortKey));
+    return items;
+}
+function formatConversationItems(items, prAuthor) {
+    return items
+        .map((item, index) => item.kind === 'thread'
+        ? formatThread(item.thread, index, prAuthor)
+        : formatEntry(item.entry, index, prAuthor))
+        .join('\n\n---\n\n');
+}
+async function fetchPrAuthorThumbsDownRootIds({ octokit, owner, repo, prAuthor, inlineEntries, }) {
+    if (!prAuthor) {
+        return new Set();
+    }
+    const doistbotRootIds = inlineEntries.flatMap((entry) => {
+        if (entry.id == null ||
+            entry.replyToId != null ||
+            !isKnownDoistbotLogin(entry.author.toLowerCase())) {
+            return [];
+        }
+        return [entry.id];
+    });
+    if (doistbotRootIds.length === 0) {
+        return new Set();
+    }
+    const normalizedPrAuthor = prAuthor.trim().toLowerCase();
+    const results = await Promise.allSettled(doistbotRootIds.map(async (commentId) => {
+        const reactions = (await octokit.paginate(octokit.rest.reactions.listForPullRequestReviewComment, {
+            owner,
+            repo,
+            comment_id: commentId,
+            per_page: 100,
+        }));
+        const hasPrAuthorThumbsDown = reactions.some((reaction) => {
+            const reactionAuthor = reaction.user?.login?.trim().toLowerCase();
+            return reaction.content === '-1' && reactionAuthor === normalizedPrAuthor;
+        });
+        return hasPrAuthorThumbsDown ? commentId : null;
+    }));
+    const thumbsDownRootIds = new Set();
+    for (const result of results) {
+        if (result.status === 'fulfilled') {
+            if (result.value != null) {
+                thumbsDownRootIds.add(result.value);
+            }
+            continue;
+        }
+        logger.warn('Failed to fetch review comment reactions for PR conversation context', {
+            error: result.reason instanceof Error ? result.reason.message : String(result.reason),
+        });
+    }
+    return thumbsDownRootIds;
 }
-export async function fetchReviewConversationContext({ octokit, owner, repo, pullNumber, summaryApiKeys, workspaceDir, rawContextThresholdChars = RAW_CONVERSATION_CONTEXT_THRESHOLD_CHARS, summarizeConversationContext: summarize = summarizeConversationContextWithModel, }) {
+export async function fetchReviewConversationContext({ octokit, owner, repo, pullNumber, prAuthor, summaryApiKeys, workspaceDir, rawContextThresholdChars = RAW_CONVERSATION_CONTEXT_THRESHOLD_CHARS, summarizeConversationContext: summarize = summarizeConversationContextWithModel, }) {
     try {
         const [issueComments, reviews, reviewComments] = await Promise.all([
             fetchIssueComments(octokit, {
@@ -253,12 +404,15 @@ export async function fetchReviewConversationContext({ octokit, owner, repo, pul
             const entry = toInlineCommentEntry(comment);
             return entry ? [entry] : [];
         });
-        const entries = [
-            ...issueCommentEntries,
-            ...reviewSummaryEntries,
-            ...inlineCommentEntries,
-        ].sort(byCreatedAtAscending);
-        const rawContext = formatConversationEntries(entries);
+        const prAuthorThumbsDownRootIds = await fetchPrAuthorThumbsDownRootIds({
+            octokit,
+            owner,
+            repo,
+            prAuthor,
+            inlineEntries: inlineCommentEntries,
+        });
+        const items = buildConversationItems([...issueCommentEntries, ...reviewSummaryEntries], inlineCommentEntries, prAuthorThumbsDownRootIds);
+        const rawContext = formatConversationItems(items, prAuthor);
         const rawChars = rawContext.length;
         const baseStats = {
             issueComments: issueCommentEntries.length,
@@ -266,7 +420,7 @@ export async function fetchReviewConversationContext({ octokit, owner, repo, pul
             inlineComments: inlineCommentEntries.length,
             rawChars,
         };
-        if (entries.length === 0) {
+        if (items.length === 0) {
             return emptyContext(baseStats);
         }
         if (rawChars <= rawContextThresholdChars) {