@todoist/doistbot-cli 0.0.0-stage → 1.0.16

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

@@ -0,0 +1,477 @@
+import { isKnownDoistbotLogin } from '../../core/bot-logins.js';
+import { WORKSPACE_DIR } from '../../core/environment.js';
+import { fetchIssueComments } from '../../core/github-issues.js';
+import { logger } from '../../core/logging.js';
+import { invokePiPrompt } from '../../core/pi.js';
+import { resolveReviewProviderCredential } from '../../providers/credentials.js';
+import { normalizeGithubPriorityBadges } from './github-comment-format.js';
+import { stripReviewFeedbackFooter } from './review-feedback.js';
+// Roughly 6k tokens: large enough for substantive PR discussions while still
+// keeping conversation context secondary to the diff.
+export const RAW_CONVERSATION_CONTEXT_THRESHOLD_CHARS = 25_000;
+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', credential: apiKeys.gemini }] : []),
+        ...(apiKeys?.openai ? [{ provider: 'openai', credential: apiKeys.openai }] : []),
+    ];
+}
+function isRelevantBotLogin(login) {
+    const normalized = login.toLowerCase();
+    return isKnownDoistbotLogin(normalized) || normalized === GITHUB_ACTIONS_BOT_LOGIN;
+}
+function shouldIncludeEntry(login, body) {
+    if (!body || REVIEW_COMMAND_REGEX.test(body)) {
+        return false;
+    }
+    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 normalizeGithubPriorityBadges(stripReviewFeedbackFooter(body));
+}
+function toIssueCommentEntry(comment) {
+    const author = comment.user?.login ?? 'unknown';
+    const body = cleanBody(comment.body ?? '');
+    if (!shouldIncludeEntry(author, body)) {
+        return null;
+    }
+    return {
+        source: 'issue_comment',
+        author,
+        createdAt: comment.created_at ?? 'unknown',
+        url: comment.html_url ?? undefined,
+        body,
+    };
+}
+function toReviewSummaryEntry(review) {
+    const author = review.user?.login ?? 'unknown';
+    const body = cleanBody(review.body ?? '');
+    if (!shouldIncludeEntry(author, body)) {
+        return null;
+    }
+    return {
+        source: 'review_summary',
+        author,
+        createdAt: review.submitted_at ?? 'unknown',
+        url: review.html_url ?? undefined,
+        state: review.state ?? undefined,
+        body,
+    };
+}
+function toInlineCommentEntry(comment) {
+    const author = comment.user?.login ?? 'unknown';
+    const body = cleanBody(comment.body ?? '');
+    if (!shouldIncludeEntry(author, body)) {
+        return null;
+    }
+    return {
+        source: 'inline_comment',
+        author,
+        createdAt: comment.created_at ?? 'unknown',
+        url: comment.html_url ?? undefined,
+        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 compareCreatedAt(a, b) {
+    if (a === b) {
+        return 0;
+    }
+    if (a === 'unknown') {
+        return 1;
+    }
+    if (b === 'unknown') {
+        return -1;
+    }
+    return a.localeCompare(b);
+}
+// 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: ${describeAuthor(entry.author, prAuthor)}`);
+    lines.push(`- Created: ${entry.createdAt}`);
+    if (entry.state) {
+        lines.push(`- Review state: ${entry.state}`);
+    }
+    if (entry.path) {
+        lines.push(`- Location: ${formatLocation(entry)}`);
+    }
+    if (entry.replyToId != null) {
+        lines.push(`- Reply to inline comment ID: ${entry.replyToId}`);
+    }
+    if (entry.url) {
+        lines.push(`- URL: ${entry.url}`);
+    }
+    lines.push('Body:');
+    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,
+        summarized,
+        summarizationFailed,
+    };
+}
+function emptyContext(baseStats, summarizationFailed = false) {
+    return {
+        promptText: '',
+        stats: buildStats(baseStats, { summarizationFailed }),
+    };
+}
+function buildSummaryPrompt(rawContext) {
+    return `You are summarizing GitHub pull request conversation context for a code review model.
+
+Summarize the conversation so the reviewer can account for author clarifications, line-specific discussions, and previous review rounds without rereading every comment.
+
+Rules:
+- Use only facts present in the conversation.
+- 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.
+
+Use this structure:
+
+## PR conversation context
+
+Coverage: <one sentence with the kinds of comments summarized>
+
+### Author intent / clarifications
+- ...
+
+### Line-specific context
+- ...
+
+### Previous review rounds
+- ...
+
+### Findings the author declined / pushed back on (do not re-raise)
+- ...
+
+### Open questions / unresolved discussion
+- ...
+
+If a section has no relevant information, use "- None."
+
+<pr_conversation>
+${rawContext}
+</pr_conversation>`;
+}
+async function summarizeConversationContextWithModel({ provider, credential, rawContext, workspaceDir, }) {
+    const startedAt = Date.now();
+    logger.info('PR conversation summarization started', {
+        task: 'review',
+        provider,
+        raw_chars: rawContext.length,
+    });
+    try {
+        const resolvedCredential = resolveReviewProviderCredential(credential);
+        if (!resolvedCredential) {
+            return null;
+        }
+        const result = await invokePiPrompt({
+            provider,
+            apiKey: resolvedCredential.apiKey,
+            ...(resolvedCredential.piProviderId
+                ? { piProviderId: resolvedCredential.piProviderId }
+                : {}),
+            ...(resolvedCredential.modelName ? { modelName: resolvedCredential.modelName } : {}),
+            prompt: buildSummaryPrompt(rawContext),
+            cwd: workspaceDir ?? WORKSPACE_DIR,
+            timeoutMs: CONVERSATION_SUMMARY_TIMEOUT_MS,
+            capabilityPreset: 'read-only',
+            thinkingLevel: 'medium',
+        });
+        const durationMs = Date.now() - startedAt;
+        if (!result.ok) {
+            logger.warn('PR conversation context summarization failed', {
+                task: 'review',
+                provider,
+                raw_chars: rawContext.length,
+                duration_ms: durationMs,
+                timed_out: result.timedOut,
+                error: result.error,
+            });
+            return null;
+        }
+        const output = result.output.trim();
+        logger.info('PR conversation summarization finished', {
+            task: 'review',
+            provider,
+            raw_chars: rawContext.length,
+            output_chars: output.length,
+            duration_ms: durationMs,
+            outcome: output ? 'success' : 'empty',
+        });
+        return output || null;
+    }
+    catch (error) {
+        logger.warn('PR conversation context summarization errored', {
+            task: 'review',
+            provider,
+            raw_chars: rawContext.length,
+            duration_ms: Date.now() - startedAt,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return null;
+    }
+}
+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, prAuthor, summaryApiKeys, workspaceDir, rawContextThresholdChars = RAW_CONVERSATION_CONTEXT_THRESHOLD_CHARS, summarizeConversationContext: summarize = summarizeConversationContextWithModel, }) {
+    try {
+        const [issueComments, reviews, reviewComments] = await Promise.all([
+            fetchIssueComments(octokit, {
+                owner,
+                repo,
+                issueNumber: pullNumber,
+            }),
+            octokit.paginate(octokit.rest.pulls.listReviews, {
+                owner,
+                repo,
+                pull_number: pullNumber,
+                per_page: 100,
+            }),
+            octokit.paginate(octokit.rest.pulls.listReviewComments, {
+                owner,
+                repo,
+                pull_number: pullNumber,
+                per_page: 100,
+            }),
+        ]);
+        const issueCommentEntries = issueComments.flatMap((comment) => {
+            const entry = toIssueCommentEntry(comment);
+            return entry ? [entry] : [];
+        });
+        const reviewSummaryEntries = reviews.flatMap((review) => {
+            const entry = toReviewSummaryEntry(review);
+            return entry ? [entry] : [];
+        });
+        const inlineCommentEntries = reviewComments.flatMap((comment) => {
+            const entry = toInlineCommentEntry(comment);
+            return entry ? [entry] : [];
+        });
+        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,
+            reviewSummaries: reviewSummaryEntries.length,
+            inlineComments: inlineCommentEntries.length,
+            rawChars,
+        };
+        if (items.length === 0) {
+            return emptyContext(baseStats);
+        }
+        if (rawChars <= rawContextThresholdChars) {
+            return {
+                promptText: rawContext,
+                stats: buildStats(baseStats),
+            };
+        }
+        const summaryProviders = getSummaryProviders(summaryApiKeys);
+        if (summaryProviders.length === 0) {
+            logger.warn('PR conversation context omitted because summarization requires a review provider', {
+                rawChars,
+                rawContextThresholdChars,
+            });
+            return emptyContext(baseStats, true);
+        }
+        for (const summaryProvider of summaryProviders) {
+            const summarizedContext = await summarize({
+                ...summaryProvider,
+                rawContext,
+                workspaceDir,
+            });
+            if (summarizedContext) {
+                return {
+                    promptText: summarizedContext,
+                    stats: buildStats(baseStats, { summarized: true }),
+                };
+            }
+        }
+        logger.warn('PR conversation context omitted because summarization returned no output', {
+            rawChars,
+            rawContextThresholdChars,
+        });
+        return emptyContext(baseStats, true);
+    }
+    catch (error) {
+        logger.warn('Failed to fetch PR conversation context', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return emptyContext({
+            issueComments: 0,
+            reviewSummaries: 0,
+            inlineComments: 0,
+            rawChars: 0,
+        });
+    }
+}

package/sandbox/dist/tasks/review/diff.js

@@ -0,0 +1,95 @@
+export const MAX_DIFF_CHARS = 128000;
+/**
+ * Converts GitHub's file list (with unified patches) into annotated diffs plus fast line lookups.
+ */
+export function buildAnnotatedDiff(files) {
+    const annotatedFiles = [];
+    const lineLookup = new Map();
+    for (const file of files) {
+        if (!file.patch) {
+            continue;
+        }
+        const { annotatedDiff, oldLineNumbers, newLineNumbers } = annotatePatch(file.patch);
+        if (!annotatedDiff.trim()) {
+            continue;
+        }
+        annotatedFiles.push({ path: file.filename, annotatedDiff });
+        lineLookup.set(file.filename, { old: oldLineNumbers, new: newLineNumbers });
+    }
+    return { annotatedFiles, lineLookup };
+}
+/**
+ * Adds `[NEW:L#]`, `[OLD:L#]`, `[CTX:L#]` markers to every line in a unified diff.
+ */
+function annotatePatch(patch) {
+    const lines = patch.split('\n');
+    let oldLine = 0;
+    let newLine = 0;
+    const annotated = [];
+    const oldLineNumbers = new Set();
+    const newLineNumbers = new Set();
+    for (const line of lines) {
+        if (line.startsWith('@@')) {
+            annotated.push(line);
+            const match = /@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/.exec(line);
+            if (match) {
+                oldLine = Number(match[1]);
+                newLine = Number(match[2]);
+            }
+            continue;
+        }
+        if (line.startsWith('+')) {
+            annotated.push(`[NEW:L${newLine}]+ ${line.slice(1)}`);
+            newLineNumbers.add(newLine);
+            newLine += 1;
+            continue;
+        }
+        if (line.startsWith('-')) {
+            annotated.push(`[OLD:L${oldLine}]- ${line.slice(1)}`);
+            oldLineNumbers.add(oldLine);
+            oldLine += 1;
+            continue;
+        }
+        if (line.startsWith(' ')) {
+            annotated.push(`[CTX:L${newLine}]  ${line.slice(1)}`);
+            oldLine += 1;
+            newLine += 1;
+            continue;
+        }
+        // Covers lines such as ""
+        annotated.push(line);
+    }
+    return {
+        annotatedDiff: annotated.join('\n'),
+        oldLineNumbers,
+        newLineNumbers,
+    };
+}
+/**
+ * Joins annotated diffs into a single prompt-friendly string while respecting length limits.
+ */
+export function buildDiffSection(annotatedFiles) {
+    let consumed = 0;
+    let truncated = false;
+    const chunks = [];
+    for (const file of annotatedFiles) {
+        const header = `### ${file.path}\n${file.annotatedDiff}`;
+        const remaining = MAX_DIFF_CHARS - consumed;
+        if (remaining <= 0) {
+            truncated = true;
+            break;
+        }
+        if (header.length > remaining) {
+            chunks.push(header.slice(0, remaining));
+            truncated = true;
+            consumed = MAX_DIFF_CHARS;
+            break;
+        }
+        chunks.push(header);
+        consumed += header.length;
+    }
+    return {
+        diffSection: chunks.join('\n\n'),
+        truncated,
+    };
+}