@doist/doistbot-cli 1.0.0 → 1.0.2

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

@@ -1,6 +1,24 @@
 import { isAnotherDeliveryInProgress, postCheckRun } from '../../core/check-run.js';
+import { logger } from '../../core/logging.js';
 import { appendReviewFeedbackLink } from './review-feedback.js';
+import { parseSeverity } from './severity.js';
 const CHECK_RUN_NAME = 'doistbot/review';
+/**
+ * Stale-pointer Check Run encoding — mirrors
+ * `apps/webhook-handler/src/tasks/review/stale-check-run.ts` so the two paths
+ * interoperate: a webhook-handler synchronize that lands after the sandbox
+ * posts a pointer here will find this pointer on `payload.before` and unwrap
+ * to the same `reviewedSha`. Kept in sync by convention; if we ever extract
+ * the upsert mechanics into a shared package, the constants move with it.
+ */
+const STALE_POINTER_EXTERNAL_ID_PREFIX = 'stale-pointer:';
+const STALE_TITLE_PREFIX = 'Stale: ';
+const MAX_TITLE_LENGTH = 100;
+function truncateTitle(value) {
+    if (value.length <= MAX_TITLE_LENGTH)
+        return value;
+    return `${value.slice(0, MAX_TITLE_LENGTH - 1)}…`;
+}
 /**
  * Concurrency lock for the review task: returns `true` if a different
  * delivery's `in_progress` Check Run is already running on this SHA. Skips
@@ -9,24 +27,31 @@ const CHECK_RUN_NAME = 'doistbot/review';
 export function isAnotherReviewInProgress(params) {
     return isAnotherDeliveryInProgress({ ...params, name: CHECK_RUN_NAME });
 }
+// Mapped type (not `Record<Severity, Lowercase<Severity>>`) so each key is
+// tied to its own lowercase value. `{ P0: 'p1', ... }` would type-check
+// under the looser `Record` form; this one rejects it.
+const SEVERITY_TO_COUNTER_KEY = {
+    P0: 'p0',
+    P1: 'p1',
+    P2: 'p2',
+    P3: 'p3',
+};
 /**
  * Counts findings by their `[Pn]` severity tag, looking at both the inline
- * comments and any summary-only findings the bot included.
- *
- * Uses the same regex pattern Doistbot's prompts emit (`[P0]`–`[P3]`).
- * Findings without a recognizable tag are bucketed as `untagged`.
+ * comments and any summary-only findings the bot included. Findings without
+ * 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 tagPattern = /\[P([0-3])\]/i;
-    function incrementByTag(text) {
-        const match = text?.match(tagPattern);
-        const tag = match ? `p${match[1]}` : 'untagged';
-        counts[tag] += 1;
+    function increment(sev) {
+        if (sev)
+            counts[SEVERITY_TO_COUNTER_KEY[sev]] += 1;
+        else
+            counts.untagged += 1;
         counts.total += 1;
     }
     for (const comment of review.comments ?? []) {
-        incrementByTag(comment.body);
+        increment(comment.body ? parseSeverity(comment.body) : null);
     }
     // Summary may also contain `[Pn]`-tagged findings — the prompt's fallback
     // tells the model to surface findings in the summary when inline placement
@@ -34,9 +59,9 @@ export function countFindingsBySeverity(review) {
     // double-count tags repeated within the same sentence; only increment for
     // lines that match.
     for (const line of review.summary?.split('\n') ?? []) {
-        if (tagPattern.test(line)) {
-            incrementByTag(line);
-        }
+        const sev = parseSeverity(line);
+        if (sev)
+            increment(sev);
     }
     return counts;
 }
@@ -170,6 +195,20 @@ export async function postReviewSuccessCheckRun({ octokit, owner, repo, sha, pul
         summaryBody: buildSuccessSummary(review, pullRequestUrl, counts),
     });
 }
+/** Shared title used by both the failure Check Run and stale-pointer recovery. */
+const FAILURE_TITLE = 'Doistbot review unavailable';
+/**
+ * Recovers the title that the terminal Check Run posted to `reviewedSha`,
+ * given the same input shape `postFinalCheckRun` already has. Lets the
+ * stale-pointer follow-up cite "Original result: …" without duplicating
+ * the title-building logic in two places.
+ */
+export function getReviewCheckRunTitle(input) {
+    if (input.conclusion === 'success') {
+        return buildSuccessTitle(countFindingsBySeverity(input.review));
+    }
+    return FAILURE_TITLE;
+}
 /**
  * Posts a `neutral` check run with a "review unavailable" title so PR authors
  * aren't left wondering whether the bot ran. `neutral` (gray −) visually
@@ -186,7 +225,7 @@ export async function postReviewFailureCheckRun({ octokit, owner, repo, sha, pul
         pullNumber,
         deliveryId,
         conclusion: 'neutral',
-        title: 'Doistbot review unavailable',
+        title: FAILURE_TITLE,
         summaryBody: [
             "Doistbot's review didn't complete (provider outage, rate limit, or other failure).",
             '',
@@ -196,3 +235,84 @@ export async function postReviewFailureCheckRun({ octokit, owner, repo, sha, pul
         ].join('\n'),
     });
 }
+/**
+ * After the terminal Check Run lands on `reviewedSha`, look up the PR's
+ * current head SHA. If it has moved during the review (i.e. the user pushed
+ * at least one commit while the review was in flight), post a neutral
+ * stale-pointer Check Run on the current head that links back to
+ * `reviewedSha`. Closes the in-progress-during-push gap that the webhook-side
+ * fix in [#311](https://github.com/Doist/doistbot-app/pull/311) can't cover
+ * on its own: that path only fires on `pull_request.synchronize` and only
+ * surfaces a pointer when a *completed* run sits on `payload.before`, so any
+ * commits pushed before the review terminated stayed empty.
+ *
+ * Uses the same `stale-pointer:<sha>` `external_id` format and same summary
+ * copy as `apps/webhook-handler/src/tasks/review/stale-check-run.ts` so the
+ * two paths interoperate: a subsequent synchronize-driven post finds this
+ * pointer on the prior head and unwraps to `reviewedSha`, keeping the
+ * "reference original" semantics across chained pushes.
+ *
+ * Skips quietly when:
+ * - Current head equals `reviewedSha` (no movement — the common case).
+ * - `pulls.get` fails (warn + return; restoring visibility is degraded UX,
+ *   not a correctness issue).
+ *
+ * The `postCheckRun` call itself swallows write failures with a warn, same
+ * pattern as the other terminal-write helpers.
+ *
+ * TOCTOU caveat: a push between the `pulls.get` here and the `postCheckRun`
+ * write can leave the new pointer on a SHA that's no longer the head. Same
+ * race shape and same bound as the existing TOCTOU notes elsewhere; the
+ * webhook-side handler will paper over it on the next synchronize.
+ */
+export async function postStaleReviewPointerIfHeadMoved({ octokit, owner, repo, pullNumber, reviewedSha, reviewedTitle, }) {
+    let currentHeadSha;
+    try {
+        const { data } = await octokit.rest.pulls.get({
+            owner,
+            repo,
+            pull_number: pullNumber,
+        });
+        currentHeadSha = data.head.sha;
+    }
+    catch (error) {
+        logger.warn('Failed to fetch PR current head; skipping stale pointer', {
+            component: 'stale-check-run',
+            pr_number: pullNumber,
+            reviewed_sha: reviewedSha,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return;
+    }
+    if (currentHeadSha === reviewedSha) {
+        return;
+    }
+    const reviewedShaShort = reviewedSha.slice(0, 7);
+    const commitUrl = `https://github.com/${owner}/${repo}/pull/${pullNumber}/commits/${reviewedSha}`;
+    const summary = [
+        `⚠️ Doistbot reviewed an earlier commit ([\`${reviewedShaShort}\`](${commitUrl})).`,
+        '',
+        `**Original result:** ${reviewedTitle}`,
+        '',
+        'Inline review comments from the original run are still on this PR; ' +
+            'they were against the prior commit and may not reflect the current diff. ' +
+            'Comment `@doistbot /review` to re-run against the latest commit.',
+    ].join('\n');
+    await postCheckRun({
+        octokit,
+        owner,
+        repo,
+        sha: currentHeadSha,
+        name: CHECK_RUN_NAME,
+        title: truncateTitle(`${STALE_TITLE_PREFIX}${reviewedTitle}`),
+        summary,
+        conclusion: 'neutral',
+        externalId: `${STALE_POINTER_EXTERNAL_ID_PREFIX}${reviewedSha}`,
+    });
+    logger.info('Posted stale-pointer Check Run on current head (head moved during review)', {
+        component: 'stale-check-run',
+        pr_number: pullNumber,
+        reviewed_sha: reviewedSha,
+        current_head_sha: currentHeadSha,
+    });
+}

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

@@ -0,0 +1,316 @@
+import { isKnownDoistbotLogin } from '../../core/bot-logins.js';
+import { fetchIssueComments } from '../../core/github-issues.js';
+import { logger } from '../../core/logging.js';
+import { invokePiPrompt } from '../../core/pi.js';
+import { WORKSPACE_DIR } from '../../core/shared.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]';
+function getSummaryProviders(apiKeys) {
+    return [
+        ...(apiKeys?.gemini ? [{ provider: 'gemini', apiKey: apiKeys.gemini }] : []),
+        ...(apiKeys?.openai ? [{ provider: 'openai', apiKey: apiKeys.openai }] : []),
+        ...(apiKeys?.anthropic
+            ? [{ provider: 'anthropic', apiKey: apiKeys.anthropic }]
+            : []),
+    ];
+}
+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 cleanBody(body) {
+    return 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,
+        replyToId: comment.in_reply_to_id ?? undefined,
+        body,
+    };
+}
+function byCreatedAtAscending(a, b) {
+    if (a.createdAt === b.createdAt) {
+        return 0;
+    }
+    if (a.createdAt === 'unknown') {
+        return 1;
+    }
+    if (b.createdAt === 'unknown') {
+        return -1;
+    }
+    return a.createdAt.localeCompare(b.createdAt);
+}
+function formatEntry(entry, index) {
+    const lines = [`### Entry ${index + 1}: ${entry.source.replace('_', ' ')}`];
+    lines.push(`- Author: ${entry.author}`);
+    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}`);
+    }
+    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 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.
+- 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
+- ...
+
+### Open questions / unresolved discussion
+- ...
+
+If a section has no relevant information, use "- None."
+
+<pr_conversation>
+${rawContext}
+</pr_conversation>`;
+}
+async function summarizeConversationContextWithModel({ provider, apiKey, rawContext, workspaceDir, }) {
+    const startedAt = Date.now();
+    logger.info('PR conversation summarization started', {
+        task: 'review',
+        provider,
+        raw_chars: rawContext.length,
+    });
+    try {
+        const result = await invokePiPrompt({
+            provider,
+            apiKey,
+            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 formatConversationEntries(entries) {
+    return entries.map((entry, index) => formatEntry(entry, index)).join('\n\n---\n\n');
+}
+export async function fetchReviewConversationContext({ octokit, owner, repo, pullNumber, 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 entries = [
+            ...issueCommentEntries,
+            ...reviewSummaryEntries,
+            ...inlineCommentEntries,
+        ].sort(byCreatedAtAscending);
+        const rawContext = formatConversationEntries(entries);
+        const rawChars = rawContext.length;
+        const baseStats = {
+            issueComments: issueCommentEntries.length,
+            reviewSummaries: reviewSummaryEntries.length,
+            inlineComments: inlineCommentEntries.length,
+            rawChars,
+        };
+        if (entries.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,
+        });
+    }
+}