@todoist/doistbot-cli 0.0.0-stage → 1.0.16

package/sandbox/dist/tasks/chat/chat.js

@@ -0,0 +1,440 @@
+import { performance } from 'node:perf_hooks';
+import { SpanStatusCode } from '@opentelemetry/api';
+import { isKnownDoistbotLogin } from '../../core/bot-logins.js';
+import { recordTaskMetrics } from '../../core/datadog-metrics.js';
+import { parseBaseContext, requiredEnv, WORKSPACE_DIR } from '../../core/environment.js';
+import { logger } from '../../core/logging.js';
+import { invokePiPrompt } from '../../core/pi.js';
+import { loadPromptTemplateFile, resolvePromptFile } from '../../core/prompt-template.js';
+import { removeIssueCommentReactionIfPresent } from '../../core/reactions.js';
+import { cloneRepository, createGitHubClients } from '../../core/shared.js';
+import { withPhase } from '../../core/tracing.js';
+import { shutdownTracing } from '../../core/tracing-setup.js';
+import { buildBroPrompt, buildPrompt } from './prompt.js';
+const CHAT_PROMPT_FILE = 'chat-prompt.md';
+const BRO_PROMPT_FILE = 'bro-prompt.md';
+const CHAT_TIMEOUT_MS = 5 * 60 * 1000;
+const CHAT_PROVIDER = 'openai';
+const CHAT_MODEL = 'gpt-6-luna';
+const CHAT_THINKING_LEVEL = 'high';
+const BRO_SYSTEM_PROMPT = 'You are Doistbot re-explaining one of your own review comments. Use only the source comment in the task prompt. Do not inspect files, call tools, or add facts. Output only the rewritten explanation.';
+const EMPTY_BRO_RESPONSE = "There's no earlier Doistbot comment in this review thread for me to simplify, bro.";
+function parseContext() {
+    const base = parseBaseContext();
+    const reactionIdRaw = process.env.REACTION_ID;
+    const reactionId = reactionIdRaw ? Number(reactionIdRaw) : undefined;
+    return {
+        ...base,
+        commentId: Number(requiredEnv('COMMENT_ID')),
+        reactionId: Number.isFinite(reactionId) ? reactionId : undefined,
+        commentType: requiredEnv('COMMENT_TYPE'),
+        eventName: requiredEnv('EVENT_NAME'),
+        mode: process.env.CHAT_MODE === 'bro' ? 'bro' : 'chat',
+        dryRun: process.env.DRY_RUN?.toLowerCase() === 'true',
+    };
+}
+function findLatestDoistbotComment(entries) {
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+        const entry = entries[index];
+        if (entry && isKnownDoistbotLogin(entry.author)) {
+            return entry.body;
+        }
+    }
+    return undefined;
+}
+/**
+ * Gathers context for a review comment (inline code comment thread).
+ */
+export async function gatherReviewCommentContext(octokit, owner, repo, commentId, mode = 'chat') {
+    const comment = await octokit.rest.pulls.getReviewComment({
+        owner,
+        repo,
+        comment_id: commentId,
+    });
+    const threadEntries = [];
+    let inReplyToId = comment.data.in_reply_to_id;
+    while (inReplyToId) {
+        try {
+            const parentComment = await octokit.rest.pulls.getReviewComment({
+                owner,
+                repo,
+                comment_id: inReplyToId,
+            });
+            const parentAuthor = parentComment.data.user?.login ?? 'unknown';
+            const parentBody = parentComment.data.body ?? '';
+            if (mode === 'bro' && isKnownDoistbotLogin(parentAuthor)) {
+                return {
+                    previousDoistbotComment: parentBody,
+                };
+            }
+            if (mode === 'bro') {
+                inReplyToId = parentComment.data.in_reply_to_id;
+                continue;
+            }
+            threadEntries.unshift({ author: parentAuthor, body: parentBody });
+            inReplyToId = parentComment.data.in_reply_to_id;
+        }
+        catch (error) {
+            logger.warn('Failed to fetch parent comment', {
+                commentId: inReplyToId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            if (mode === 'bro') {
+                throw new Error('Failed to fetch the review thread for bro mode', { cause: error });
+            }
+            break;
+        }
+    }
+    if (mode === 'bro') {
+        return {};
+    }
+    const codeSnippet = comment.data.diff_hunk ?? '';
+    const commentBody = comment.data.body ?? '';
+    const currentCommentAuthor = comment.data.user?.login ?? 'unknown';
+    const previousDoistbotComment = findLatestDoistbotComment(threadEntries);
+    threadEntries.push({ author: currentCommentAuthor, body: commentBody });
+    const userQuestion = commentBody.replace(/@doistbot\s*/i, '').trim();
+    return {
+        threadHistory: threadEntries
+            .map(({ author, body }) => `**${author}**: ${body}`)
+            .join('\n\n'),
+        userQuestion,
+        codeSnippet,
+        previousDoistbotComment,
+    };
+}
+/**
+ * Gathers context for a general PR comment (not tied to specific code).
+ */
+async function gatherIssueCommentContext(octokit, owner, repo, prNumber, commentId) {
+    const [pr, comment] = await Promise.all([
+        octokit.rest.pulls.get({
+            owner,
+            repo,
+            pull_number: prNumber,
+        }),
+        octokit.rest.issues.getComment({
+            owner,
+            repo,
+            comment_id: commentId,
+        }),
+    ]);
+    const prTitle = pr.data.title ?? '';
+    const prAuthor = pr.data.user?.login ?? 'unknown';
+    const commentBody = comment.data.body ?? '';
+    // Get recent doistbot reviews to provide context
+    let threadHistory = '';
+    try {
+        const reviews = await octokit.rest.pulls.listReviews({
+            owner,
+            repo,
+            pull_number: prNumber,
+        });
+        const doistbotReview = reviews.data
+            .filter((review) => {
+            const login = review.user?.login?.toLowerCase() ?? '';
+            return isKnownDoistbotLogin(login) || login === 'github-actions[bot]';
+        })
+            .sort((a, b) => {
+            const dateA = new Date(a.submitted_at ?? 0);
+            const dateB = new Date(b.submitted_at ?? 0);
+            return dateB.getTime() - dateA.getTime();
+        })[0];
+        if (doistbotReview?.body) {
+            threadHistory = `**Previous Review Summary:**\n\n${doistbotReview.body}`;
+        }
+    }
+    catch (error) {
+        logger.warn('Failed to fetch reviews', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+    const userQuestion = commentBody.replace(/@doistbot\s*/i, '').trim();
+    return {
+        threadHistory,
+        userQuestion,
+        prTitle,
+        prAuthor,
+    };
+}
+export async function invokeChatModel(prompt, mode = 'chat') {
+    const apiKey = process.env.OPENAI_KEY?.trim();
+    if (!apiKey) {
+        // Config error: no model call attempted, so no model span. The reason is
+        // returned so the caller's root span reports the real cause.
+        logger.warn('Chat model API key missing');
+        return { ok: false, reason: 'OPENAI_KEY missing' };
+    }
+    return withPhase('chat.model', {
+        'gen_ai.operation.name': 'chat',
+        'gen_ai.provider.name': CHAT_PROVIDER,
+        'gen_ai.request.model': CHAT_MODEL,
+    }, async (span) => {
+        const result = await invokePiPrompt({
+            provider: CHAT_PROVIDER,
+            apiKey,
+            prompt,
+            cwd: WORKSPACE_DIR,
+            timeoutMs: CHAT_TIMEOUT_MS,
+            capabilityPreset: mode === 'bro' ? 'none' : 'workspace-inspection',
+            thinkingLevel: CHAT_THINKING_LEVEL,
+            // Keep the executed model in sync with the recorded span attr.
+            modelName: CHAT_MODEL,
+            ...(mode === 'bro'
+                ? {
+                    systemPrompt: BRO_SYSTEM_PROMPT,
+                    noContextFiles: true,
+                }
+                : {}),
+        });
+        // Record why the model stopped, before the ok/failure branch so
+        // terminal "error"/"aborted"/"length" endings are reported too.
+        // stopReason values:
+        //   stop     Natural end — model finished or hit a stop sequence.
+        //   length   Hit the token cap (max_tokens or context limit).
+        //   toolUse  Paused to call a tool. Expected mid-agent-loop.
+        //   error    Provider errored mid-generation.
+        //   aborted  Generation was cancelled (e.g. signal/timeout).
+        if (result.stopReason) {
+            span.setAttribute('gen_ai.response.finish_reasons', [result.stopReason]);
+        }
+        if (!result.ok) {
+            // Failure returns a result rather than throwing — mark the span
+            // ERROR explicitly so it survives to phase.end (withPhase only
+            // auto-errors on a throw).
+            span.setStatus({ code: SpanStatusCode.ERROR, message: result.error });
+            logger.warn('Chat model request failed', {
+                error: result.error,
+                timedOut: result.timedOut,
+            });
+            return { ok: false, reason: result.error };
+        }
+        const output = result.output.trim();
+        if (!output) {
+            const reason = 'chat model produced no output';
+            span.setStatus({ code: SpanStatusCode.ERROR, message: reason });
+            return { ok: false, reason };
+        }
+        return { ok: true, output };
+    });
+}
+/**
+ * Posts the response to the correct location.
+ */
+async function postResponse(octokit, ctx, response) {
+    if (ctx.commentType === 'review') {
+        await octokit.rest.pulls.createReplyForReviewComment({
+            owner: ctx.owner,
+            repo: ctx.repo,
+            pull_number: ctx.prNumber,
+            comment_id: ctx.commentId,
+            body: response,
+        });
+    }
+    else {
+        await octokit.rest.issues.createComment({
+            owner: ctx.owner,
+            repo: ctx.repo,
+            issue_number: ctx.prNumber,
+            body: response,
+        });
+    }
+    logger.info('Posted chat response', {
+        commentType: ctx.commentType,
+        commentId: ctx.commentId,
+        prNumber: ctx.prNumber,
+    });
+}
+function formatChatDryRunOutput(ctx, response) {
+    return JSON.stringify({
+        task: 'chat',
+        repository: `${ctx.owner}/${ctx.repo}`,
+        prNumber: ctx.prNumber,
+        commentId: ctx.commentId,
+        commentType: ctx.commentType,
+        eventName: ctx.eventName,
+        mode: ctx.mode,
+        response,
+    }, null, 2);
+}
+/**
+ * Removes the 👀 reaction from the triggering comment.
+ */
+async function removeReaction(octokit, ctx, reactionId) {
+    try {
+        if (ctx.commentType === 'review') {
+            await octokit.rest.reactions.deleteForPullRequestComment({
+                owner: ctx.owner,
+                repo: ctx.repo,
+                comment_id: ctx.commentId,
+                reaction_id: reactionId,
+            });
+        }
+        else {
+            await removeIssueCommentReactionIfPresent({
+                owner: ctx.owner,
+                repo: ctx.repo,
+                commentId: ctx.commentId,
+                reactionId,
+                octokit,
+                warnMessage: 'Failed to remove reaction',
+            });
+        }
+    }
+    catch (error) {
+        logger.warn('Failed to remove reaction', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+async function main() {
+    const startedAt = performance.now();
+    const ctx = parseContext();
+    const logContext = {
+        deliveryId: ctx.deliveryId ?? 'unknown',
+        repository: `${ctx.owner}/${ctx.repo}`,
+        prNumber: ctx.prNumber,
+        commentId: ctx.commentId,
+    };
+    logger.setBaseContext(logContext);
+    const reactionId = ctx.reactionId;
+    let exitCode = 0;
+    let metricOutcome = 'failure';
+    await withPhase('chat', {
+        task: 'chat',
+        'gen_ai.operation.name': 'invoke_agent',
+        'gen_ai.agent.name': 'doistbot.chat',
+        'chat.mode': ctx.mode,
+        'pr.number': ctx.prNumber,
+        'comment.id': ctx.commentId,
+        'comment.type': ctx.commentType,
+        'event.name': ctx.eventName,
+        dry_run: ctx.dryRun,
+    }, async (span) => {
+        // Inside the span so auth/setup failures are captured by the root span.
+        const { app, readOctokit, writeOctokit } = await createGitHubClients(ctx);
+        try {
+            // /bro only rewrites an existing comment, so it does not need repository contents.
+            if (ctx.mode !== 'bro') {
+                await cloneRepository({
+                    app,
+                    owner: ctx.owner,
+                    repo: ctx.repo,
+                    prNumber: ctx.prNumber,
+                    installationId: ctx.installationId,
+                });
+            }
+            // Gather thread context from GitHub API
+            let threadContext;
+            if (ctx.commentType === 'review') {
+                threadContext = await gatherReviewCommentContext(readOctokit, ctx.owner, ctx.repo, ctx.commentId, ctx.mode);
+            }
+            else {
+                threadContext = await gatherIssueCommentContext(readOctokit, ctx.owner, ctx.repo, ctx.prNumber, ctx.commentId);
+            }
+            let response;
+            if (ctx.mode === 'bro' && !threadContext.previousDoistbotComment) {
+                response = EMPTY_BRO_RESPONSE;
+            }
+            else {
+                const promptTemplate = loadPromptTemplateFile({
+                    fileName: resolvePromptFile(import.meta.url, ctx.mode === 'bro' ? BRO_PROMPT_FILE : CHAT_PROMPT_FILE),
+                    promptLabel: ctx.mode,
+                });
+                const prompt = ctx.mode === 'bro'
+                    ? buildBroPrompt({
+                        promptTemplate,
+                        previousDoistbotComment: threadContext.previousDoistbotComment ?? '',
+                    })
+                    : buildPrompt({
+                        promptTemplate,
+                        owner: ctx.owner,
+                        repo: ctx.repo,
+                        prNumber: ctx.prNumber,
+                        threadHistory: threadContext.threadHistory ?? '',
+                        userQuestion: threadContext.userQuestion ?? '',
+                        codeSnippet: threadContext.codeSnippet,
+                        prTitle: threadContext.prTitle,
+                        prAuthor: threadContext.prAuthor,
+                    });
+                const modelResult = await invokeChatModel(prompt, ctx.mode);
+                if (!modelResult.ok) {
+                    span.setStatus({ code: SpanStatusCode.ERROR, message: modelResult.reason });
+                    logger.warn('Chat model produced no usable response', {
+                        reason: modelResult.reason,
+                    });
+                    return;
+                }
+                response = modelResult.output;
+            }
+            if (ctx.dryRun) {
+                logger.info('Dry run enabled, printing chat response instead of posting to GitHub');
+                process.stdout.write(`${formatChatDryRunOutput(ctx, response)}\n`);
+            }
+            else {
+                await postResponse(writeOctokit, ctx, response);
+            }
+            metricOutcome = 'success';
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error('Chat task failed', { error: message });
+            // The catch swallows the error to post a user reply, so set the
+            // span status explicitly — withPhase only auto-errors on rethrow.
+            span.setStatus({ code: SpanStatusCode.ERROR, message });
+            if (ctx.dryRun) {
+                logger.info('Dry run enabled, skipping chat error response post');
+            }
+            else {
+                try {
+                    const errorMessage = 'Sorry, I encountered an error while processing your request. Please try again or contact the team maintaining the bot.';
+                    if (ctx.commentType === 'review') {
+                        await writeOctokit.rest.pulls.createReplyForReviewComment({
+                            owner: ctx.owner,
+                            repo: ctx.repo,
+                            pull_number: ctx.prNumber,
+                            comment_id: ctx.commentId,
+                            body: errorMessage,
+                        });
+                    }
+                    else {
+                        await writeOctokit.rest.issues.createComment({
+                            owner: ctx.owner,
+                            repo: ctx.repo,
+                            issue_number: ctx.prNumber,
+                            body: errorMessage,
+                        });
+                    }
+                }
+                catch (replyError) {
+                    logger.error('Failed to post error message', {
+                        error: replyError instanceof Error
+                            ? replyError.message
+                            : String(replyError),
+                    });
+                }
+            }
+            exitCode = 1;
+        }
+        finally {
+            // Local dry runs must stay side-effect free.
+            if (reactionId && !ctx.dryRun) {
+                await removeReaction(writeOctokit, ctx, reactionId);
+            }
+            await recordTaskMetrics({
+                type: 'chat',
+                repository: `${ctx.owner}/${ctx.repo}`,
+                model: 'openai',
+                outcome: metricOutcome,
+                durationMs: performance.now() - startedAt,
+            });
+        }
+    });
+    if (exitCode !== 0) {
+        await shutdownTracing();
+        process.exit(exitCode);
+    }
+}
+if (process.env.VITEST !== 'true') {
+    main();
+}

package/sandbox/dist/tasks/chat/prompt.js

@@ -0,0 +1,20 @@
+import { fillPromptTemplate } from '../../core/prompt-template.js';
+/**
+ * Fills the chat prompt template with variable substitution.
+ */
+export function buildPrompt({ promptTemplate, owner, repo, prNumber, threadHistory, userQuestion, codeSnippet, prTitle, prAuthor, }) {
+    return fillPromptTemplate(promptTemplate, {
+        PR_NUMBER: String(prNumber),
+        REPO_FULL: `${owner}/${repo}`,
+        PR_TITLE: prTitle ?? '',
+        PR_AUTHOR: prAuthor ?? 'unknown',
+        THREAD_HISTORY: threadHistory || 'No previous conversation.',
+        USER_QUESTION: userQuestion ?? '',
+        CODE_SNIPPET: codeSnippet ? `\`\`\`\n${codeSnippet}\n\`\`\`` : 'No code context available.',
+    });
+}
+export function buildBroPrompt({ promptTemplate, previousDoistbotComment, }) {
+    return fillPromptTemplate(promptTemplate, {
+        PREVIOUS_DOISTBOT_COMMENT: previousDoistbotComment,
+    });
+}